projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fixed a bug where hashcat crashes for accessing deallocated buffer if user spams...
[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 // in this case some required buffers are free'd, ascii_digest() would run into segfault
929 if (data.shutdown_inner == 1) return;
930
931 if (data.machine_readable == 1)
932 {
933 status_display_machine_readable ();
934
935 return;
936 }
937
938 char tmp_buf[1000] = { 0 };
939
940 uint tmp_len = 0;
941
942 log_info ("Session.Name...: %s", data.session);
943
944 char *status_type = strstatus (data.devices_status);
945
946 uint hash_mode = data.hash_mode;
947
948 char *hash_type = strhashtype (hash_mode); // not a bug
949
950 log_info ("Status.........: %s", status_type);
951
952 /**
953 * show rules
954 */
955
956 if (data.rp_files_cnt)
957 {
958 uint i;
959
960 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
961 {
962 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
963 }
964
965 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
966
967 log_info ("Rules.Type.....: %s", tmp_buf);
968
969 tmp_len = 0;
970 }
971
972 if (data.rp_gen)
973 {
974 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
975
976 if (data.rp_gen_seed)
977 {
978 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
979 }
980 }
981
982 /**
983 * show input
984 */
985
986 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
987 {
988 if (data.wordlist_mode == WL_MODE_FILE)
989 {
990 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
991 }
992 else if (data.wordlist_mode == WL_MODE_STDIN)
993 {
994 log_info ("Input.Mode.....: Pipe");
995 }
996 }
997 else if (data.attack_mode == ATTACK_MODE_COMBI)
998 {
999 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1000 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1001 }
1002 else if (data.attack_mode == ATTACK_MODE_BF)
1003 {
1004 char *mask = data.mask;
1005
1006 if (mask != NULL)
1007 {
1008 uint mask_len = data.css_cnt;
1009
1010 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1011
1012 if (mask_len > 0)
1013 {
1014 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1015 {
1016 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1017 {
1018 mask_len -= data.salts_buf[0].salt_len;
1019 }
1020 }
1021
1022 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1023
1024 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1025 }
1026
1027 if (data.maskcnt > 1)
1028 {
1029 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1030
1031 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1032 }
1033
1034 log_info ("Input.Mode.....: %s", tmp_buf);
1035 }
1036
1037 tmp_len = 0;
1038 }
1039 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1040 {
1041 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1042 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1043 }
1044 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1045 {
1046 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1047 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1048 }
1049
1050 if (data.digests_cnt == 1)
1051 {
1052 if (data.hash_mode == 2500)
1053 {
1054 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1055
1056 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1057 (char *) data.salts_buf[0].salt_buf,
1058 wpa->orig_mac1[0],
1059 wpa->orig_mac1[1],
1060 wpa->orig_mac1[2],
1061 wpa->orig_mac1[3],
1062 wpa->orig_mac1[4],
1063 wpa->orig_mac1[5],
1064 wpa->orig_mac2[0],
1065 wpa->orig_mac2[1],
1066 wpa->orig_mac2[2],
1067 wpa->orig_mac2[3],
1068 wpa->orig_mac2[4],
1069 wpa->orig_mac2[5]);
1070 }
1071 else if (data.hash_mode == 5200)
1072 {
1073 log_info ("Hash.Target....: File (%s)", data.hashfile);
1074 }
1075 else if (data.hash_mode == 9000)
1076 {
1077 log_info ("Hash.Target....: File (%s)", data.hashfile);
1078 }
1079 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1080 {
1081 log_info ("Hash.Target....: File (%s)", data.hashfile);
1082 }
1083 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1084 {
1085 log_info ("Hash.Target....: File (%s)", data.hashfile);
1086 }
1087 else
1088 {
1089 char out_buf[HCBUFSIZ] = { 0 };
1090
1091 ascii_digest (out_buf, 0, 0);
1092
1093 // limit length
1094 if (strlen (out_buf) > 40)
1095 {
1096 out_buf[41] = '.';
1097 out_buf[42] = '.';
1098 out_buf[43] = '.';
1099 out_buf[44] = 0;
1100 }
1101
1102 log_info ("Hash.Target....: %s", out_buf);
1103 }
1104 }
1105 else
1106 {
1107 if (data.hash_mode == 3000)
1108 {
1109 char out_buf1[32] = { 0 };
1110 char out_buf2[32] = { 0 };
1111
1112 ascii_digest (out_buf1, 0, 0);
1113 ascii_digest (out_buf2, 0, 1);
1114
1115 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1116 }
1117 else
1118 {
1119 log_info ("Hash.Target....: File (%s)", data.hashfile);
1120 }
1121 }
1122
1123 log_info ("Hash.Type......: %s", hash_type);
1124
1125 /**
1126 * speed new
1127 */
1128
1129 u64 speed_cnt[DEVICES_MAX] = { 0 };
1130 double speed_ms[DEVICES_MAX] = { 0 };
1131
1132 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1133 {
1134 hc_device_param_t *device_param = &data.devices_param[device_id];
1135
1136 if (device_param->skipped) continue;
1137
1138 speed_cnt[device_id] = 0;
1139 speed_ms[device_id] = 0;
1140
1141 for (int i = 0; i < SPEED_CACHE; i++)
1142 {
1143 speed_cnt[device_id] += device_param->speed_cnt[i];
1144 speed_ms[device_id] += device_param->speed_ms[i];
1145 }
1146
1147 speed_cnt[device_id] /= SPEED_CACHE;
1148 speed_ms[device_id] /= SPEED_CACHE;
1149 }
1150
1151 double hashes_all_ms = 0;
1152
1153 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1154
1155 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1156 {
1157 hc_device_param_t *device_param = &data.devices_param[device_id];
1158
1159 if (device_param->skipped) continue;
1160
1161 hashes_dev_ms[device_id] = 0;
1162
1163 if (speed_ms[device_id])
1164 {
1165 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1166
1167 hashes_all_ms += hashes_dev_ms[device_id];
1168 }
1169 }
1170
1171 /**
1172 * exec time
1173 */
1174
1175 double exec_all_ms[DEVICES_MAX] = { 0 };
1176
1177 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1178 {
1179 hc_device_param_t *device_param = &data.devices_param[device_id];
1180
1181 if (device_param->skipped) continue;
1182
1183 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1184
1185 exec_all_ms[device_id] = exec_ms_avg;
1186 }
1187
1188 /**
1189 * timers
1190 */
1191
1192 double ms_running = 0;
1193
1194 hc_timer_get (data.timer_running, ms_running);
1195
1196 double ms_paused = data.ms_paused;
1197
1198 if (data.devices_status == STATUS_PAUSED)
1199 {
1200 double ms_paused_tmp = 0;
1201
1202 hc_timer_get (data.timer_paused, ms_paused_tmp);
1203
1204 ms_paused += ms_paused_tmp;
1205 }
1206
1207 #ifdef WIN
1208
1209 __time64_t sec_run = ms_running / 1000;
1210
1211 #else
1212
1213 time_t sec_run = ms_running / 1000;
1214
1215 #endif
1216
1217 if (sec_run)
1218 {
1219 char display_run[32] = { 0 };
1220
1221 struct tm tm_run;
1222
1223 struct tm *tmp = NULL;
1224
1225 #ifdef WIN
1226
1227 tmp = _gmtime64 (&sec_run);
1228
1229 #else
1230
1231 tmp = gmtime (&sec_run);
1232
1233 #endif
1234
1235 if (tmp != NULL)
1236 {
1237 memset (&tm_run, 0, sizeof (tm_run));
1238
1239 memcpy (&tm_run, tmp, sizeof (tm_run));
1240
1241 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1242
1243 char *start = ctime (&data.proc_start);
1244
1245 size_t start_len = strlen (start);
1246
1247 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1248 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1249
1250 log_info ("Time.Started...: %s (%s)", start, display_run);
1251 }
1252 }
1253 else
1254 {
1255 log_info ("Time.Started...: 0 secs");
1256 }
1257
1258 /**
1259 * counters
1260 */
1261
1262 u64 progress_total = data.words_cnt * data.salts_cnt;
1263
1264 u64 all_done = 0;
1265 u64 all_rejected = 0;
1266 u64 all_restored = 0;
1267
1268 u64 progress_noneed = 0;
1269
1270 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1271 {
1272 all_done += data.words_progress_done[salt_pos];
1273 all_rejected += data.words_progress_rejected[salt_pos];
1274 all_restored += data.words_progress_restored[salt_pos];
1275
1276 // Important for ETA only
1277
1278 if (data.salts_shown[salt_pos] == 1)
1279 {
1280 const u64 all = data.words_progress_done[salt_pos]
1281 + data.words_progress_rejected[salt_pos]
1282 + data.words_progress_restored[salt_pos];
1283
1284 const u64 left = data.words_cnt - all;
1285
1286 progress_noneed += left;
1287 }
1288 }
1289
1290 u64 progress_cur = all_restored + all_done + all_rejected;
1291 u64 progress_end = progress_total;
1292
1293 u64 progress_skip = 0;
1294
1295 if (data.skip)
1296 {
1297 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1298
1299 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1300 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1301 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1302 }
1303
1304 if (data.limit)
1305 {
1306 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1307
1308 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1309 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1310 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1311 }
1312
1313 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1314 u64 progress_end_relative_skip = progress_end - progress_skip;
1315
1316 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1317 {
1318 if (data.devices_status != STATUS_CRACKED)
1319 {
1320 #ifdef WIN
1321 __time64_t sec_etc = 0;
1322 #else
1323 time_t sec_etc = 0;
1324 #endif
1325
1326 if (hashes_all_ms)
1327 {
1328 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1329
1330 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1331
1332 sec_etc = ms_left / 1000;
1333 }
1334
1335 if (sec_etc == 0)
1336 {
1337 //log_info ("Time.Estimated.: 0 secs");
1338 }
1339 else if ((u64) sec_etc > ETC_MAX)
1340 {
1341 log_info ("Time.Estimated.: > 10 Years");
1342 }
1343 else
1344 {
1345 char display_etc[32] = { 0 };
1346 char display_runtime[32] = { 0 };
1347
1348 struct tm tm_etc;
1349 struct tm tm_runtime;
1350
1351 struct tm *tmp = NULL;
1352
1353 #ifdef WIN
1354 tmp = _gmtime64 (&sec_etc);
1355 #else
1356 tmp = gmtime (&sec_etc);
1357 #endif
1358
1359 if (tmp != NULL)
1360 {
1361 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1362
1363 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1364
1365 time_t now;
1366
1367 time (&now);
1368
1369 now += sec_etc;
1370
1371 char *etc = ctime (&now);
1372
1373 size_t etc_len = strlen (etc);
1374
1375 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1376 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1377
1378 if (data.runtime)
1379 {
1380 time_t runtime_cur;
1381
1382 time (&runtime_cur);
1383
1384 #ifdef WIN
1385
1386 __time64_t runtime_left = data.proc_start + data.runtime - runtime_cur;
1387
1388 tmp = _gmtime64 (&runtime_left);
1389
1390 #else
1391
1392 time_t runtime_left = data.proc_start + data.runtime - runtime_cur;
1393
1394 tmp = gmtime (&runtime_left);
1395
1396 #endif
1397
1398 if ((tmp != NULL) && (runtime_left > 0) && (runtime_left < sec_etc))
1399 {
1400 memcpy (&tm_runtime, tmp, sizeof (tm_runtime));
1401
1402 format_timer_display (&tm_runtime, display_runtime, sizeof (display_runtime));
1403
1404 log_info ("Time.Estimated.: %s (%s), but limited (%s)", etc, display_etc, display_runtime);
1405 }
1406 else
1407 {
1408 log_info ("Time.Estimated.: %s (%s), but limit exceeded", etc, display_etc);
1409 }
1410 }
1411 else
1412 {
1413 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1414 }
1415 }
1416 }
1417 }
1418 }
1419
1420 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1421 {
1422 hc_device_param_t *device_param = &data.devices_param[device_id];
1423
1424 if (device_param->skipped) continue;
1425
1426 char display_dev_cur[16] = { 0 };
1427
1428 strncpy (display_dev_cur, "0.00", 4);
1429
1430 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1431
1432 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1433 }
1434
1435 char display_all_cur[16] = { 0 };
1436
1437 strncpy (display_all_cur, "0.00", 4);
1438
1439 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1440
1441 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1442
1443 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1444 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1445
1446 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1447
1448 // crack-per-time
1449
1450 if (data.digests_cnt > 100)
1451 {
1452 time_t now = time (NULL);
1453
1454 int cpt_cur_min = 0;
1455 int cpt_cur_hour = 0;
1456 int cpt_cur_day = 0;
1457
1458 for (int i = 0; i < CPT_BUF; i++)
1459 {
1460 const uint cracked = data.cpt_buf[i].cracked;
1461 const time_t timestamp = data.cpt_buf[i].timestamp;
1462
1463 if ((timestamp + 60) > now)
1464 {
1465 cpt_cur_min += cracked;
1466 }
1467
1468 if ((timestamp + 3600) > now)
1469 {
1470 cpt_cur_hour += cracked;
1471 }
1472
1473 if ((timestamp + 86400) > now)
1474 {
1475 cpt_cur_day += cracked;
1476 }
1477 }
1478
1479 double ms_real = ms_running - ms_paused;
1480
1481 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1482 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1483 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1484
1485 if ((data.cpt_start + 86400) < now)
1486 {
1487 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1488 cpt_cur_min,
1489 cpt_cur_hour,
1490 cpt_cur_day,
1491 cpt_avg_min,
1492 cpt_avg_hour,
1493 cpt_avg_day);
1494 }
1495 else if ((data.cpt_start + 3600) < now)
1496 {
1497 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1498 cpt_cur_min,
1499 cpt_cur_hour,
1500 cpt_avg_min,
1501 cpt_avg_hour,
1502 cpt_avg_day);
1503 }
1504 else if ((data.cpt_start + 60) < now)
1505 {
1506 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1507 cpt_cur_min,
1508 cpt_avg_min,
1509 cpt_avg_hour,
1510 cpt_avg_day);
1511 }
1512 else
1513 {
1514 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1515 cpt_avg_min,
1516 cpt_avg_hour,
1517 cpt_avg_day);
1518 }
1519 }
1520
1521 // Restore point
1522
1523 u64 restore_point = get_lowest_words_done ();
1524
1525 u64 restore_total = data.words_base;
1526
1527 float percent_restore = 0;
1528
1529 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1530
1531 if (progress_end_relative_skip)
1532 {
1533 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1534 {
1535 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1536 float percent_rejected = 0.0;
1537
1538 if (progress_cur)
1539 {
1540 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1541 }
1542
1543 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1544 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1545
1546 if (data.restore_disable == 0)
1547 {
1548 if (percent_finished != 1)
1549 {
1550 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1551 }
1552 }
1553 }
1554 }
1555 else
1556 {
1557 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1558 {
1559 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1560 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1561
1562 if (data.restore_disable == 0)
1563 {
1564 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1565 }
1566 }
1567 else
1568 {
1569 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1570 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1571
1572 // --restore not allowed if stdin is used -- really? why?
1573
1574 //if (data.restore_disable == 0)
1575 //{
1576 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1577 //}
1578 }
1579 }
1580
1581 #ifdef HAVE_HWMON
1582
1583 if (data.devices_status == STATUS_EXHAUSTED) return;
1584 if (data.devices_status == STATUS_CRACKED) return;
1585 if (data.devices_status == STATUS_ABORTED) return;
1586 if (data.devices_status == STATUS_QUIT) return;
1587
1588 if (data.gpu_temp_disable == 0)
1589 {
1590 hc_thread_mutex_lock (mux_adl);
1591
1592 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1593 {
1594 hc_device_param_t *device_param = &data.devices_param[device_id];
1595
1596 if (device_param->skipped) continue;
1597
1598 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1599 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1600 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1601 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1602 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1603 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1604 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1605
1606 char output_buf[256] = { 0 };
1607
1608 int output_len = 0;
1609
1610 if (num_temperature >= 0)
1611 {
1612 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1613
1614 output_len = strlen (output_buf);
1615 }
1616
1617 if (num_fanspeed >= 0)
1618 {
1619 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1620
1621 output_len = strlen (output_buf);
1622 }
1623
1624 if (num_utilization >= 0)
1625 {
1626 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1627
1628 output_len = strlen (output_buf);
1629 }
1630
1631 if (num_corespeed >= 0)
1632 {
1633 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1634
1635 output_len = strlen (output_buf);
1636 }
1637
1638 if (num_memoryspeed >= 0)
1639 {
1640 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1641
1642 output_len = strlen (output_buf);
1643 }
1644
1645 if (num_buslanes >= 0)
1646 {
1647 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1648
1649 output_len = strlen (output_buf);
1650 }
1651
1652 if (num_throttle == 1)
1653 {
1654 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1655
1656 output_len = strlen (output_buf);
1657 }
1658
1659 if (output_len == 0)
1660 {
1661 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1662
1663 output_len = strlen (output_buf);
1664 }
1665
1666 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1667 }
1668
1669 hc_thread_mutex_unlock (mux_adl);
1670 }
1671
1672 #endif // HAVE_HWMON
1673 }
1674
1675 static void status_benchmark_automate ()
1676 {
1677 u64 speed_cnt[DEVICES_MAX] = { 0 };
1678 double speed_ms[DEVICES_MAX] = { 0 };
1679
1680 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1681 {
1682 hc_device_param_t *device_param = &data.devices_param[device_id];
1683
1684 if (device_param->skipped) continue;
1685
1686 speed_cnt[device_id] = device_param->speed_cnt[0];
1687 speed_ms[device_id] = device_param->speed_ms[0];
1688 }
1689
1690 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1691
1692 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1693 {
1694 hc_device_param_t *device_param = &data.devices_param[device_id];
1695
1696 if (device_param->skipped) continue;
1697
1698 hashes_dev_ms[device_id] = 0;
1699
1700 if (speed_ms[device_id])
1701 {
1702 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1703 }
1704 }
1705
1706 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1707 {
1708 hc_device_param_t *device_param = &data.devices_param[device_id];
1709
1710 if (device_param->skipped) continue;
1711
1712 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1713 }
1714 }
1715
1716 static void status_benchmark ()
1717 {
1718 if (data.devices_status == STATUS_INIT) return;
1719 if (data.devices_status == STATUS_STARTING) return;
1720
1721 if (data.shutdown_inner == 1) return;
1722
1723 if (data.machine_readable == 1)
1724 {
1725 status_benchmark_automate ();
1726
1727 return;
1728 }
1729
1730 u64 speed_cnt[DEVICES_MAX] = { 0 };
1731 double speed_ms[DEVICES_MAX] = { 0 };
1732
1733 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1734 {
1735 hc_device_param_t *device_param = &data.devices_param[device_id];
1736
1737 if (device_param->skipped) continue;
1738
1739 speed_cnt[device_id] = device_param->speed_cnt[0];
1740 speed_ms[device_id] = device_param->speed_ms[0];
1741 }
1742
1743 double hashes_all_ms = 0;
1744
1745 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1746
1747 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1748 {
1749 hc_device_param_t *device_param = &data.devices_param[device_id];
1750
1751 if (device_param->skipped) continue;
1752
1753 hashes_dev_ms[device_id] = 0;
1754
1755 if (speed_ms[device_id])
1756 {
1757 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1758
1759 hashes_all_ms += hashes_dev_ms[device_id];
1760 }
1761 }
1762
1763 /**
1764 * exec time
1765 */
1766
1767 double exec_all_ms[DEVICES_MAX] = { 0 };
1768
1769 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1770 {
1771 hc_device_param_t *device_param = &data.devices_param[device_id];
1772
1773 if (device_param->skipped) continue;
1774
1775 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1776
1777 exec_all_ms[device_id] = exec_ms_avg;
1778 }
1779
1780 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1781 {
1782 hc_device_param_t *device_param = &data.devices_param[device_id];
1783
1784 if (device_param->skipped) continue;
1785
1786 char display_dev_cur[16] = { 0 };
1787
1788 strncpy (display_dev_cur, "0.00", 4);
1789
1790 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1791
1792 if (data.devices_active >= 10)
1793 {
1794 log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1795 }
1796 else
1797 {
1798 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1799 }
1800 }
1801
1802 char display_all_cur[16] = { 0 };
1803
1804 strncpy (display_all_cur, "0.00", 4);
1805
1806 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1807
1808 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1809 }
1810
1811 /**
1812 * hashcat -only- functions
1813 */
1814
1815 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1816 {
1817 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1818 {
1819 if (attack_kern == ATTACK_KERN_STRAIGHT)
1820 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1821 else if (attack_kern == ATTACK_KERN_COMBI)
1822 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1823 else if (attack_kern == ATTACK_KERN_BF)
1824 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1825 }
1826 else
1827 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1828 }
1829
1830 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1831 {
1832 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1833 {
1834 if (attack_kern == ATTACK_KERN_STRAIGHT)
1835 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1836 else if (attack_kern == ATTACK_KERN_COMBI)
1837 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1838 else if (attack_kern == ATTACK_KERN_BF)
1839 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1840 }
1841 else
1842 {
1843 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1844 }
1845 }
1846
1847 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1848 {
1849 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1850 {
1851 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1852 }
1853 else
1854 {
1855 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1856 }
1857 }
1858
1859 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1860 {
1861 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1862 {
1863 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1864 }
1865 else
1866 {
1867 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1868 }
1869 }
1870
1871 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1872 {
1873 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1874 }
1875
1876 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1877 {
1878 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1879 }
1880
1881 static char *filename_from_filepath (char *filepath)
1882 {
1883 char *ptr = NULL;
1884
1885 if ((ptr = strrchr (filepath, '/')) != NULL)
1886 {
1887 ptr++;
1888 }
1889 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1890 {
1891 ptr++;
1892 }
1893 else
1894 {
1895 ptr = filepath;
1896 }
1897
1898 return ptr;
1899 }
1900
1901 static uint convert_from_hex (char *line_buf, const uint line_len)
1902 {
1903 if (line_len & 1) return (line_len); // not in hex
1904
1905 if (data.hex_wordlist == 1)
1906 {
1907 uint i;
1908 uint j;
1909
1910 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1911 {
1912 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1913 }
1914
1915 memset (line_buf + i, 0, line_len - i);
1916
1917 return (i);
1918 }
1919 else if (line_len >= 6) // $HEX[] = 6
1920 {
1921 if (line_buf[0] != '$') return (line_len);
1922 if (line_buf[1] != 'H') return (line_len);
1923 if (line_buf[2] != 'E') return (line_len);
1924 if (line_buf[3] != 'X') return (line_len);
1925 if (line_buf[4] != '[') return (line_len);
1926 if (line_buf[line_len - 1] != ']') return (line_len);
1927
1928 uint i;
1929 uint j;
1930
1931 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1932 {
1933 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1934 }
1935
1936 memset (line_buf + i, 0, line_len - i);
1937
1938 return (i);
1939 }
1940
1941 return (line_len);
1942 }
1943
1944 static void clear_prompt ()
1945 {
1946 fputc ('\r', stdout);
1947
1948 for (size_t i = 0; i < strlen (PROMPT); i++)
1949 {
1950 fputc (' ', stdout);
1951 }
1952
1953 fputc ('\r', stdout);
1954
1955 fflush (stdout);
1956 }
1957
1958 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1959 {
1960 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1961 }
1962
1963 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1964 {
1965 char *outfile = data.outfile;
1966 uint quiet = data.quiet;
1967 FILE *pot_fp = data.pot_fp;
1968 uint loopback = data.loopback;
1969 uint debug_mode = data.debug_mode;
1970 char *debug_file = data.debug_file;
1971
1972 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1973 int debug_rule_len = 0; // -1 error
1974 uint debug_plain_len = 0;
1975
1976 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1977
1978 // hash
1979
1980 char out_buf[HCBUFSIZ] = { 0 };
1981
1982 const u32 salt_pos = plain->salt_pos;
1983 const u32 digest_pos = plain->digest_pos; // relative
1984 const u32 gidvid = plain->gidvid;
1985 const u32 il_pos = plain->il_pos;
1986
1987 ascii_digest (out_buf, salt_pos, digest_pos);
1988
1989 // plain
1990
1991 u64 crackpos = device_param->words_off;
1992
1993 uint plain_buf[16] = { 0 };
1994
1995 u8 *plain_ptr = (u8 *) plain_buf;
1996
1997 unsigned int plain_len = 0;
1998
1999 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2000 {
2001 pw_t pw;
2002
2003 gidd_to_pw_t (device_param, gidvid, &pw);
2004
2005 for (int i = 0; i < 16; i++)
2006 {
2007 plain_buf[i] = pw.i[i];
2008 }
2009
2010 plain_len = pw.pw_len;
2011
2012 const uint off = device_param->innerloop_pos + il_pos;
2013
2014 if (debug_mode > 0)
2015 {
2016 debug_rule_len = 0;
2017
2018 // save rule
2019 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
2020 {
2021 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
2022
2023 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
2024 }
2025
2026 // save plain
2027 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
2028 {
2029 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
2030
2031 memcpy (debug_plain_ptr, plain_ptr, plain_len);
2032
2033 debug_plain_len = plain_len;
2034 }
2035 }
2036
2037 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2038
2039 crackpos += gidvid;
2040 crackpos *= data.kernel_rules_cnt;
2041 crackpos += device_param->innerloop_pos + il_pos;
2042
2043 if (plain_len > data.pw_max) plain_len = data.pw_max;
2044 }
2045 else if (data.attack_mode == ATTACK_MODE_COMBI)
2046 {
2047 pw_t pw;
2048
2049 gidd_to_pw_t (device_param, gidvid, &pw);
2050
2051 for (int i = 0; i < 16; i++)
2052 {
2053 plain_buf[i] = pw.i[i];
2054 }
2055
2056 plain_len = pw.pw_len;
2057
2058 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2059 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2060
2061 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2062 {
2063 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2064 }
2065 else
2066 {
2067 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2068
2069 memcpy (plain_ptr, comb_buf, comb_len);
2070 }
2071
2072 plain_len += comb_len;
2073
2074 crackpos += gidvid;
2075 crackpos *= data.combs_cnt;
2076 crackpos += device_param->innerloop_pos + il_pos;
2077
2078 if (data.pw_max != PW_DICTMAX1)
2079 {
2080 if (plain_len > data.pw_max) plain_len = data.pw_max;
2081 }
2082 }
2083 else if (data.attack_mode == ATTACK_MODE_BF)
2084 {
2085 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2086 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2087
2088 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2089 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2090
2091 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2092 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2093
2094 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2095 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2096
2097 plain_len = data.css_cnt;
2098
2099 crackpos += gidvid;
2100 crackpos *= data.bfs_cnt;
2101 crackpos += device_param->innerloop_pos + il_pos;
2102 }
2103 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2104 {
2105 pw_t pw;
2106
2107 gidd_to_pw_t (device_param, gidvid, &pw);
2108
2109 for (int i = 0; i < 16; i++)
2110 {
2111 plain_buf[i] = pw.i[i];
2112 }
2113
2114 plain_len = pw.pw_len;
2115
2116 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2117
2118 uint start = 0;
2119 uint stop = device_param->kernel_params_mp_buf32[4];
2120
2121 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2122
2123 plain_len += start + stop;
2124
2125 crackpos += gidvid;
2126 crackpos *= data.combs_cnt;
2127 crackpos += device_param->innerloop_pos + il_pos;
2128
2129 if (data.pw_max != PW_DICTMAX1)
2130 {
2131 if (plain_len > data.pw_max) plain_len = data.pw_max;
2132 }
2133 }
2134 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2135 {
2136 pw_t pw;
2137
2138 gidd_to_pw_t (device_param, gidvid, &pw);
2139
2140 for (int i = 0; i < 16; i++)
2141 {
2142 plain_buf[i] = pw.i[i];
2143 }
2144
2145 plain_len = pw.pw_len;
2146
2147 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2148
2149 uint start = 0;
2150 uint stop = device_param->kernel_params_mp_buf32[4];
2151
2152 memmove (plain_ptr + stop, plain_ptr, plain_len);
2153
2154 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2155
2156 plain_len += start + stop;
2157
2158 crackpos += gidvid;
2159 crackpos *= data.combs_cnt;
2160 crackpos += device_param->innerloop_pos + il_pos;
2161
2162 if (data.pw_max != PW_DICTMAX1)
2163 {
2164 if (plain_len > data.pw_max) plain_len = data.pw_max;
2165 }
2166 }
2167
2168 if (data.attack_mode == ATTACK_MODE_BF)
2169 {
2170 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2171 {
2172 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2173 {
2174 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2175 {
2176 plain_len = plain_len - data.salts_buf[0].salt_len;
2177 }
2178 }
2179
2180 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2181 {
2182 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2183 {
2184 plain_ptr[j] = plain_ptr[i];
2185 }
2186
2187 plain_len = plain_len / 2;
2188 }
2189 }
2190 }
2191
2192 // if enabled, update also the potfile
2193
2194 if (pot_fp)
2195 {
2196 lock_file (pot_fp);
2197
2198 fprintf (pot_fp, "%s:", out_buf);
2199
2200 format_plain (pot_fp, plain_ptr, plain_len, 1);
2201
2202 fputc ('\n', pot_fp);
2203
2204 fflush (pot_fp);
2205
2206 unlock_file (pot_fp);
2207 }
2208
2209 // outfile
2210
2211 FILE *out_fp = NULL;
2212
2213 if (outfile != NULL)
2214 {
2215 if ((out_fp = fopen (outfile, "ab")) == NULL)
2216 {
2217 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2218
2219 out_fp = stdout;
2220 }
2221
2222 lock_file (out_fp);
2223 }
2224 else
2225 {
2226 out_fp = stdout;
2227
2228 if (quiet == 0) clear_prompt ();
2229 }
2230
2231 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2232
2233 if (outfile != NULL)
2234 {
2235 if (out_fp != stdout)
2236 {
2237 fclose (out_fp);
2238 }
2239 }
2240 else
2241 {
2242 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2243 {
2244 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2245 {
2246 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2247 if (quiet == 0) fflush (stdout);
2248 }
2249 }
2250 }
2251
2252 // loopback
2253
2254 if (loopback)
2255 {
2256 char *loopback_file = data.loopback_file;
2257
2258 FILE *fb_fp = NULL;
2259
2260 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2261 {
2262 lock_file (fb_fp);
2263
2264 format_plain (fb_fp, plain_ptr, plain_len, 1);
2265
2266 fputc ('\n', fb_fp);
2267
2268 fclose (fb_fp);
2269 }
2270 }
2271
2272 // (rule) debug mode
2273
2274 // the next check implies that:
2275 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2276 // - debug_mode > 0
2277
2278 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2279 {
2280 if (debug_rule_len < 0) debug_rule_len = 0;
2281
2282 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2283
2284 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2285
2286 if ((quiet == 0) && (debug_file == NULL))
2287 {
2288 fprintf (stdout, "%s", PROMPT);
2289
2290 fflush (stdout);
2291 }
2292 }
2293 }
2294
2295 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2296 {
2297 salt_t *salt_buf = &data.salts_buf[salt_pos];
2298
2299 u32 num_cracked;
2300
2301 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2302
2303 if (num_cracked)
2304 {
2305 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2306
2307 log_info_nn ("");
2308
2309 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2310
2311 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2312
2313 uint cpt_cracked = 0;
2314
2315 hc_thread_mutex_lock (mux_display);
2316
2317 for (uint i = 0; i < num_cracked; i++)
2318 {
2319 const uint hash_pos = cracked[i].hash_pos;
2320
2321 if (data.digests_shown[hash_pos] == 1) continue;
2322
2323 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2324 {
2325 data.digests_shown[hash_pos] = 1;
2326
2327 data.digests_done++;
2328
2329 cpt_cracked++;
2330
2331 salt_buf->digests_done++;
2332
2333 if (salt_buf->digests_done == salt_buf->digests_cnt)
2334 {
2335 data.salts_shown[salt_pos] = 1;
2336
2337 data.salts_done++;
2338 }
2339 }
2340
2341 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2342
2343 check_hash (device_param, &cracked[i]);
2344 }
2345
2346 hc_thread_mutex_unlock (mux_display);
2347
2348 myfree (cracked);
2349
2350 if (cpt_cracked > 0)
2351 {
2352 hc_thread_mutex_lock (mux_display);
2353
2354 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2355 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2356
2357 data.cpt_pos++;
2358
2359 data.cpt_total += cpt_cracked;
2360
2361 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2362
2363 hc_thread_mutex_unlock (mux_display);
2364 }
2365
2366 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2367 {
2368 // we need to reset cracked state on the device
2369 // otherwise host thinks again and again the hash was cracked
2370 // and returns invalid password each time
2371
2372 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2373
2374 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2375 }
2376
2377 num_cracked = 0;
2378
2379 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2380 }
2381 }
2382
2383 // stolen from princeprocessor ;)
2384
2385 typedef struct
2386 {
2387 FILE *fp;
2388
2389 char buf[BUFSIZ];
2390 int len;
2391
2392 } out_t;
2393
2394 static void out_flush (out_t *out)
2395 {
2396 fwrite (out->buf, 1, out->len, out->fp);
2397
2398 out->len = 0;
2399 }
2400
2401 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2402 {
2403 char *ptr = out->buf + out->len;
2404
2405 memcpy (ptr, pw_buf, pw_len);
2406
2407 ptr[pw_len] = '\n';
2408
2409 out->len += pw_len + 1;
2410
2411 if (out->len >= BUFSIZ - 100)
2412 {
2413 out_flush (out);
2414 }
2415 }
2416
2417 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2418 {
2419 out_t out;
2420
2421 out.fp = stdout;
2422 out.len = 0;
2423
2424 uint plain_buf[16] = { 0 };
2425
2426 u8 *plain_ptr = (u8 *) plain_buf;
2427
2428 uint plain_len = 0;
2429
2430 const uint il_cnt = device_param->kernel_params_buf32[30]; // ugly, i know
2431
2432 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2433 {
2434 pw_t pw;
2435
2436 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2437 {
2438 gidd_to_pw_t (device_param, gidvid, &pw);
2439
2440 const uint pos = device_param->innerloop_pos;
2441
2442 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2443 {
2444 for (int i = 0; i < 8; i++)
2445 {
2446 plain_buf[i] = pw.i[i];
2447 }
2448
2449 plain_len = pw.pw_len;
2450
2451 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2452
2453 if (plain_len > data.pw_max) plain_len = data.pw_max;
2454
2455 out_push (&out, plain_ptr, plain_len);
2456 }
2457 }
2458 }
2459 else if (data.attack_mode == ATTACK_MODE_COMBI)
2460 {
2461 pw_t pw;
2462
2463 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2464 {
2465 gidd_to_pw_t (device_param, gidvid, &pw);
2466
2467 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2468 {
2469 for (int i = 0; i < 8; i++)
2470 {
2471 plain_buf[i] = pw.i[i];
2472 }
2473
2474 plain_len = pw.pw_len;
2475
2476 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2477 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2478
2479 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2480 {
2481 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2482 }
2483 else
2484 {
2485 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2486
2487 memcpy (plain_ptr, comb_buf, comb_len);
2488 }
2489
2490 plain_len += comb_len;
2491
2492 if (data.pw_max != PW_DICTMAX1)
2493 {
2494 if (plain_len > data.pw_max) plain_len = data.pw_max;
2495 }
2496
2497 out_push (&out, plain_ptr, plain_len);
2498 }
2499 }
2500 }
2501 else if (data.attack_mode == ATTACK_MODE_BF)
2502 {
2503 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2504 {
2505 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2506 {
2507 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2508 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2509
2510 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2511 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2512
2513 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2514 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2515
2516 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2517 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2518
2519 plain_len = data.css_cnt;
2520
2521 out_push (&out, plain_ptr, plain_len);
2522 }
2523 }
2524 }
2525 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2526 {
2527 pw_t pw;
2528
2529 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2530 {
2531 gidd_to_pw_t (device_param, gidvid, &pw);
2532
2533 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2534 {
2535 for (int i = 0; i < 8; i++)
2536 {
2537 plain_buf[i] = pw.i[i];
2538 }
2539
2540 plain_len = pw.pw_len;
2541
2542 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2543
2544 uint start = 0;
2545 uint stop = device_param->kernel_params_mp_buf32[4];
2546
2547 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2548
2549 plain_len += start + stop;
2550
2551 out_push (&out, plain_ptr, plain_len);
2552 }
2553 }
2554 }
2555 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2556 {
2557 pw_t pw;
2558
2559 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2560 {
2561 gidd_to_pw_t (device_param, gidvid, &pw);
2562
2563 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2564 {
2565 for (int i = 0; i < 8; i++)
2566 {
2567 plain_buf[i] = pw.i[i];
2568 }
2569
2570 plain_len = pw.pw_len;
2571
2572 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2573
2574 uint start = 0;
2575 uint stop = device_param->kernel_params_mp_buf32[4];
2576
2577 memmove (plain_ptr + stop, plain_ptr, plain_len);
2578
2579 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2580
2581 plain_len += start + stop;
2582
2583 out_push (&out, plain_ptr, plain_len);
2584 }
2585 }
2586 }
2587
2588 out_flush (&out);
2589 }
2590
2591 static void save_hash ()
2592 {
2593 char *hashfile = data.hashfile;
2594
2595 char new_hashfile[256] = { 0 };
2596 char old_hashfile[256] = { 0 };
2597
2598 snprintf (new_hashfile, 255, "%s.new", hashfile);
2599 snprintf (old_hashfile, 255, "%s.old", hashfile);
2600
2601 unlink (new_hashfile);
2602
2603 char separator = data.separator;
2604
2605 FILE *fp = fopen (new_hashfile, "wb");
2606
2607 if (fp == NULL)
2608 {
2609 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2610
2611 exit (-1);
2612 }
2613
2614 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2615 {
2616 if (data.salts_shown[salt_pos] == 1) continue;
2617
2618 salt_t *salt_buf = &data.salts_buf[salt_pos];
2619
2620 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2621 {
2622 uint idx = salt_buf->digests_offset + digest_pos;
2623
2624 if (data.digests_shown[idx] == 1) continue;
2625
2626 if (data.hash_mode != 2500)
2627 {
2628 if (data.username == 1)
2629 {
2630 user_t *user = data.hash_info[idx]->user;
2631
2632 uint i;
2633
2634 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2635
2636 fputc (separator, fp);
2637 }
2638
2639 char out_buf[HCBUFSIZ]; // scratch buffer
2640
2641 out_buf[0] = 0;
2642
2643 ascii_digest (out_buf, salt_pos, digest_pos);
2644
2645 fputs (out_buf, fp);
2646
2647 fputc ('\n', fp);
2648 }
2649 else
2650 {
2651 hccap_t hccap;
2652
2653 to_hccap_t (&hccap, salt_pos, digest_pos);
2654
2655 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2656 }
2657 }
2658 }
2659
2660 fflush (fp);
2661
2662 fclose (fp);
2663
2664 unlink (old_hashfile);
2665
2666 if (rename (hashfile, old_hashfile) != 0)
2667 {
2668 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2669
2670 exit (-1);
2671 }
2672
2673 unlink (hashfile);
2674
2675 if (rename (new_hashfile, hashfile) != 0)
2676 {
2677 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2678
2679 exit (-1);
2680 }
2681
2682 unlink (old_hashfile);
2683 }
2684
2685 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2686 {
2687 uint num_elements = num;
2688
2689 device_param->kernel_params_buf32[33] = data.combs_mode;
2690 device_param->kernel_params_buf32[34] = num;
2691
2692 uint kernel_threads = device_param->kernel_threads;
2693
2694 while (num_elements % kernel_threads) num_elements++;
2695
2696 cl_kernel kernel = NULL;
2697
2698 switch (kern_run)
2699 {
2700 case KERN_RUN_1: kernel = device_param->kernel1; break;
2701 case KERN_RUN_12: kernel = device_param->kernel12; break;
2702 case KERN_RUN_2: kernel = device_param->kernel2; break;
2703 case KERN_RUN_23: kernel = device_param->kernel23; break;
2704 case KERN_RUN_3: kernel = device_param->kernel3; break;
2705 }
2706
2707 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2708 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2709 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2710 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2711 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2712 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2713 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2714 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2715 hc_clSetKernelArg (data.ocl, kernel, 32, sizeof (cl_uint), device_param->kernel_params[32]);
2716 hc_clSetKernelArg (data.ocl, kernel, 33, sizeof (cl_uint), device_param->kernel_params[33]);
2717 hc_clSetKernelArg (data.ocl, kernel, 34, sizeof (cl_uint), device_param->kernel_params[34]);
2718
2719 cl_event event;
2720
2721 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2722 {
2723 const size_t global_work_size[3] = { num_elements, 32, 1 };
2724 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2725
2726 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2727 }
2728 else
2729 {
2730 if (kern_run == KERN_RUN_2)
2731 {
2732 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2733 {
2734 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2735 }
2736 }
2737
2738 while (num_elements % kernel_threads) num_elements++;
2739
2740 const size_t global_work_size[3] = { num_elements, 1, 1 };
2741 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2742
2743 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2744 }
2745
2746 hc_clFlush (data.ocl, device_param->command_queue);
2747
2748 if (device_param->nvidia_spin_damp)
2749 {
2750 if (data.devices_status == STATUS_RUNNING)
2751 {
2752 if (iteration < EXPECTED_ITERATIONS)
2753 {
2754 switch (kern_run)
2755 {
2756 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2757 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2758 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2759 }
2760 }
2761 }
2762 }
2763
2764 hc_clWaitForEvents (data.ocl, 1, &event);
2765
2766 cl_ulong time_start;
2767 cl_ulong time_end;
2768
2769 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2770 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2771
2772 const double exec_us = (double) (time_end - time_start) / 1000;
2773
2774 if (data.devices_status == STATUS_RUNNING)
2775 {
2776 if (iteration < EXPECTED_ITERATIONS)
2777 {
2778 switch (kern_run)
2779 {
2780 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2781 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2782 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2783 }
2784 }
2785 }
2786
2787 if (event_update)
2788 {
2789 uint exec_pos = device_param->exec_pos;
2790
2791 device_param->exec_ms[exec_pos] = exec_us / 1000;
2792
2793 exec_pos++;
2794
2795 if (exec_pos == EXEC_CACHE)
2796 {
2797 exec_pos = 0;
2798 }
2799
2800 device_param->exec_pos = exec_pos;
2801 }
2802
2803 hc_clReleaseEvent (data.ocl, event);
2804
2805 hc_clFinish (data.ocl, device_param->command_queue);
2806 }
2807
2808 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2809 {
2810 uint num_elements = num;
2811
2812 switch (kern_run)
2813 {
2814 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2815 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2816 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2817 }
2818
2819 // causes problems with special threads like in bcrypt
2820 // const uint kernel_threads = device_param->kernel_threads;
2821
2822 uint kernel_threads = device_param->kernel_threads;
2823
2824 while (num_elements % kernel_threads) num_elements++;
2825
2826 cl_kernel kernel = NULL;
2827
2828 switch (kern_run)
2829 {
2830 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2831 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2832 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2833 }
2834
2835 switch (kern_run)
2836 {
2837 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2838 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2839 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2840 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2841 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2842 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2843 break;
2844 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2845 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2846 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2847 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2848 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2849 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2850 break;
2851 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2852 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2853 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2854 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2855 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2856 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2857 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2858 break;
2859 }
2860
2861 const size_t global_work_size[3] = { num_elements, 1, 1 };
2862 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2863
2864 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2865
2866 hc_clFlush (data.ocl, device_param->command_queue);
2867
2868 hc_clFinish (data.ocl, device_param->command_queue);
2869 }
2870
2871 static void run_kernel_tm (hc_device_param_t *device_param)
2872 {
2873 const uint num_elements = 1024; // fixed
2874
2875 uint kernel_threads = 32;
2876
2877 cl_kernel kernel = device_param->kernel_tm;
2878
2879 const size_t global_work_size[3] = { num_elements, 1, 1 };
2880 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2881
2882 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2883
2884 hc_clFlush (data.ocl, device_param->command_queue);
2885
2886 hc_clFinish (data.ocl, device_param->command_queue);
2887 }
2888
2889 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2890 {
2891 uint num_elements = num;
2892
2893 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2894 device_param->kernel_params_amp_buf32[6] = num_elements;
2895
2896 // causes problems with special threads like in bcrypt
2897 // const uint kernel_threads = device_param->kernel_threads;
2898
2899 uint kernel_threads = device_param->kernel_threads;
2900
2901 while (num_elements % kernel_threads) num_elements++;
2902
2903 cl_kernel kernel = device_param->kernel_amp;
2904
2905 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2906 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2907
2908 const size_t global_work_size[3] = { num_elements, 1, 1 };
2909 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2910
2911 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2912
2913 hc_clFlush (data.ocl, device_param->command_queue);
2914
2915 hc_clFinish (data.ocl, device_param->command_queue);
2916 }
2917
2918 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2919 {
2920 const u32 num16d = num / 16;
2921 const u32 num16m = num % 16;
2922
2923 if (num16d)
2924 {
2925 device_param->kernel_params_memset_buf32[1] = value;
2926 device_param->kernel_params_memset_buf32[2] = num16d;
2927
2928 uint kernel_threads = device_param->kernel_threads;
2929
2930 uint num_elements = num16d;
2931
2932 while (num_elements % kernel_threads) num_elements++;
2933
2934 cl_kernel kernel = device_param->kernel_memset;
2935
2936 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2937 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2938 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2939
2940 const size_t global_work_size[3] = { num_elements, 1, 1 };
2941 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2942
2943 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2944
2945 hc_clFlush (data.ocl, device_param->command_queue);
2946
2947 hc_clFinish (data.ocl, device_param->command_queue);
2948 }
2949
2950 if (num16m)
2951 {
2952 u32 tmp[4];
2953
2954 tmp[0] = value;
2955 tmp[1] = value;
2956 tmp[2] = value;
2957 tmp[3] = value;
2958
2959 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2960 }
2961 }
2962
2963 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2964 {
2965 run_kernel_memset (device_param, buf, 0, size);
2966
2967 /*
2968 int rc = -1;
2969
2970 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2971 {
2972 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2973
2974 const cl_uchar zero = 0;
2975
2976 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2977 }
2978
2979 if (rc != 0)
2980 {
2981 // NOTE: clEnqueueFillBuffer () always fails with -59
2982 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2983 // How's that possible, OpenCL 1.2 support is advertised??
2984 // We need to workaround...
2985
2986 #define FILLSZ 0x100000
2987
2988 char *tmp = (char *) mymalloc (FILLSZ);
2989
2990 for (size_t i = 0; i < size; i += FILLSZ)
2991 {
2992 const size_t left = size - i;
2993
2994 const size_t fillsz = MIN (FILLSZ, left);
2995
2996 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2997 }
2998
2999 myfree (tmp);
3000 }
3001 */
3002 }
3003
3004 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt, const uint fast_iteration)
3005 {
3006 if (data.hash_mode == 2000)
3007 {
3008 process_stdout (device_param, pws_cnt);
3009
3010 return;
3011 }
3012
3013 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3014 {
3015 if (attack_mode == ATTACK_MODE_BF)
3016 {
3017 if (opts_type & OPTS_TYPE_PT_BITSLICE)
3018 {
3019 const uint size_tm = 32 * sizeof (bs_word_t);
3020
3021 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
3022
3023 run_kernel_tm (device_param);
3024
3025 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
3026 }
3027 }
3028
3029 if (highest_pw_len < 16)
3030 {
3031 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
3032 }
3033 else if (highest_pw_len < 32)
3034 {
3035 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
3036 }
3037 else
3038 {
3039 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3040 }
3041 }
3042 else
3043 {
3044 run_kernel_amp (device_param, pws_cnt);
3045
3046 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3047
3048 if (opts_type & OPTS_TYPE_HOOK12)
3049 {
3050 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3051
3052 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3053
3054 // do something with data
3055
3056 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3057 }
3058
3059 uint iter = salt_buf->salt_iter;
3060
3061 uint loop_step = device_param->kernel_loops;
3062
3063 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3064 {
3065 uint loop_left = iter - loop_pos;
3066
3067 loop_left = MIN (loop_left, loop_step);
3068
3069 device_param->kernel_params_buf32[28] = loop_pos;
3070 device_param->kernel_params_buf32[29] = loop_left;
3071
3072 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3073
3074 if (data.devices_status == STATUS_CRACKED) break;
3075 if (data.devices_status == STATUS_ABORTED) break;
3076 if (data.devices_status == STATUS_QUIT) break;
3077 if (data.devices_status == STATUS_BYPASS) break;
3078
3079 /**
3080 * speed
3081 */
3082
3083 const float iter_part = (float) (loop_pos + loop_left) / iter;
3084
3085 const u64 perf_sum_all = pws_cnt * iter_part;
3086
3087 double speed_ms;
3088
3089 hc_timer_get (device_param->timer_speed, speed_ms);
3090
3091 const u32 speed_pos = device_param->speed_pos;
3092
3093 device_param->speed_cnt[speed_pos] = perf_sum_all;
3094
3095 device_param->speed_ms[speed_pos] = speed_ms;
3096
3097 if (data.benchmark == 1)
3098 {
3099 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3100 }
3101 }
3102
3103 if (opts_type & OPTS_TYPE_HOOK23)
3104 {
3105 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3106
3107 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3108
3109 // do something with data
3110
3111 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
3112 }
3113
3114 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3115 }
3116 }
3117
3118 static int run_rule_engine (const int rule_len, const char *rule_buf)
3119 {
3120 if (rule_len == 0)
3121 {
3122 return 0;
3123 }
3124 else if (rule_len == 1)
3125 {
3126 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3127 }
3128
3129 return 1;
3130 }
3131
3132 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3133 {
3134 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3135 {
3136 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3137 }
3138 else if (data.attack_kern == ATTACK_KERN_COMBI)
3139 {
3140 if (data.attack_mode == ATTACK_MODE_COMBI)
3141 {
3142 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3143 {
3144 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3145 {
3146 for (u32 i = 0; i < pws_cnt; i++)
3147 {
3148 const u32 pw_len = device_param->pws_buf[i].pw_len;
3149
3150 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3151
3152 ptr[pw_len] = 0x01;
3153 }
3154 }
3155 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3156 {
3157 for (u32 i = 0; i < pws_cnt; i++)
3158 {
3159 const u32 pw_len = device_param->pws_buf[i].pw_len;
3160
3161 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3162
3163 ptr[pw_len] = 0x80;
3164 }
3165 }
3166 }
3167 }
3168 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3169 {
3170 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3171 {
3172 for (u32 i = 0; i < pws_cnt; i++)
3173 {
3174 const u32 pw_len = device_param->pws_buf[i].pw_len;
3175
3176 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3177
3178 ptr[pw_len] = 0x01;
3179 }
3180 }
3181 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3182 {
3183 for (u32 i = 0; i < pws_cnt; i++)
3184 {
3185 const u32 pw_len = device_param->pws_buf[i].pw_len;
3186
3187 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3188
3189 ptr[pw_len] = 0x80;
3190 }
3191 }
3192 }
3193
3194 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3195 }
3196 else if (data.attack_kern == ATTACK_KERN_BF)
3197 {
3198 const u64 off = device_param->words_off;
3199
3200 device_param->kernel_params_mp_l_buf64[3] = off;
3201
3202 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3203 }
3204 }
3205
3206 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3207 {
3208 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3209
3210 device_param->kernel_params_buf32[28] = 0;
3211 device_param->kernel_params_buf32[29] = kernel_loops; // not a bug, both need to be set
3212 device_param->kernel_params_buf32[30] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3213
3214 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3215 {
3216 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3217 }
3218 else
3219 {
3220 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3221 }
3222
3223 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3224
3225 return exec_ms_prev;
3226 }
3227
3228 static void autotune (hc_device_param_t *device_param)
3229 {
3230 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3231
3232 const u32 kernel_accel_min = device_param->kernel_accel_min;
3233 const u32 kernel_accel_max = device_param->kernel_accel_max;
3234
3235 const u32 kernel_loops_min = device_param->kernel_loops_min;
3236 const u32 kernel_loops_max = device_param->kernel_loops_max;
3237
3238 u32 kernel_accel = kernel_accel_min;
3239 u32 kernel_loops = kernel_loops_min;
3240
3241 // in this case the user specified a fixed -u and -n on the commandline
3242 // no way to tune anything
3243 // but we need to run a few caching rounds
3244
3245 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3246 {
3247 if (data.hash_mode != 2000)
3248 {
3249 try_run (device_param, kernel_accel, kernel_loops);
3250 try_run (device_param, kernel_accel, kernel_loops);
3251 try_run (device_param, kernel_accel, kernel_loops);
3252 try_run (device_param, kernel_accel, kernel_loops);
3253 }
3254
3255 device_param->kernel_accel = kernel_accel;
3256 device_param->kernel_loops = kernel_loops;
3257
3258 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3259
3260 device_param->kernel_power = kernel_power;
3261
3262 return;
3263 }
3264
3265 // from here it's clear we are allowed to autotune
3266 // so let's init some fake words
3267
3268 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3269
3270 if (data.attack_kern == ATTACK_KERN_BF)
3271 {
3272 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3273 }
3274 else
3275 {
3276 for (u32 i = 0; i < kernel_power_max; i++)
3277 {
3278 device_param->pws_buf[i].i[0] = i;
3279 device_param->pws_buf[i].i[1] = 0x01234567;
3280 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3281 }
3282
3283 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3284 }
3285
3286 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3287 {
3288 if (data.kernel_rules_cnt > 1)
3289 {
3290 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, MIN (kernel_loops_max, KERNEL_RULES) * sizeof (kernel_rule_t), 0, NULL, NULL);
3291 }
3292 }
3293 else
3294 {
3295 run_kernel_amp (device_param, kernel_power_max);
3296 }
3297
3298 #define VERIFIER_CNT 1
3299
3300 // first find out highest kernel-loops that stays below target_ms
3301
3302 if (kernel_loops_min < kernel_loops_max)
3303 {
3304 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3305 {
3306 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3307
3308 for (int i = 0; i < VERIFIER_CNT; i++)
3309 {
3310 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3311
3312 exec_ms = MIN (exec_ms, exec_ms_v);
3313 }
3314
3315 if (exec_ms < target_ms) break;
3316 }
3317 }
3318
3319 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3320
3321 #define STEPS_CNT 10
3322
3323 if (kernel_accel_min < kernel_accel_max)
3324 {
3325 for (int i = 0; i < STEPS_CNT; i++)
3326 {
3327 const u32 kernel_accel_try = 1 << i;
3328
3329 if (kernel_accel_try < kernel_accel_min) continue;
3330 if (kernel_accel_try > kernel_accel_max) break;
3331
3332 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3333
3334 for (int i = 0; i < VERIFIER_CNT; i++)
3335 {
3336 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3337
3338 exec_ms = MIN (exec_ms, exec_ms_v);
3339 }
3340
3341 if (exec_ms > target_ms) break;
3342
3343 kernel_accel = kernel_accel_try;
3344 }
3345 }
3346
3347 // at this point we want to know the actual runtime for the following reason:
3348 // we need a reference for the balancing loop following up, and this
3349 // the balancing loop can have an effect that the creates a new opportunity, for example:
3350 // if the target is 95 ms and the current runtime is 48ms the above loop
3351 // stopped the execution because the previous exec_ms was > 95ms
3352 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3353 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3354
3355 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3356
3357 for (int i = 0; i < VERIFIER_CNT; i++)
3358 {
3359 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3360
3361 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3362 }
3363
3364 u32 diff = kernel_loops - kernel_accel;
3365
3366 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3367 {
3368 u32 kernel_accel_orig = kernel_accel;
3369 u32 kernel_loops_orig = kernel_loops;
3370
3371 for (u32 f = 1; f < 1024; f++)
3372 {
3373 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3374 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3375
3376 if (kernel_accel_try > kernel_accel_max) break;
3377 if (kernel_loops_try < kernel_loops_min) break;
3378
3379 u32 diff_new = kernel_loops_try - kernel_accel_try;
3380
3381 if (diff_new > diff) break;
3382
3383 diff_new = diff;
3384
3385 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3386
3387 for (int i = 0; i < VERIFIER_CNT; i++)
3388 {
3389 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3390
3391 exec_ms = MIN (exec_ms, exec_ms_v);
3392 }
3393
3394 if (exec_ms < exec_ms_pre_final)
3395 {
3396 exec_ms_pre_final = exec_ms;
3397
3398 kernel_accel = kernel_accel_try;
3399 kernel_loops = kernel_loops_try;
3400 }
3401 }
3402 }
3403
3404 const double exec_left = target_ms / exec_ms_pre_final;
3405
3406 const double accel_left = kernel_accel_max / kernel_accel;
3407
3408 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3409
3410 if (exec_accel_min >= 1.0)
3411 {
3412 // this is safe to not overflow kernel_accel_max because of accel_left
3413
3414 kernel_accel = (double) kernel_accel * exec_accel_min;
3415 }
3416
3417 // reset them fake words
3418
3419 /*
3420 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3421
3422 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3423 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3424 */
3425
3426 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3427
3428 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3429 {
3430 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3431 }
3432
3433 // reset timer
3434
3435 device_param->exec_pos = 0;
3436
3437 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3438
3439 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3440 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3441 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3442
3443 // store
3444
3445 device_param->kernel_accel = kernel_accel;
3446 device_param->kernel_loops = kernel_loops;
3447
3448 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3449
3450 device_param->kernel_power = kernel_power;
3451
3452 #ifdef DEBUG
3453
3454 if (data.quiet == 0)
3455 {
3456 clear_prompt ();
3457
3458 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3459 "- Device #%u: autotuned kernel-loops to %u\n",
3460 device_param->device_id + 1, kernel_accel,
3461 device_param->device_id + 1, kernel_loops);
3462
3463 fprintf (stdout, "%s", PROMPT);
3464
3465 fflush (stdout);
3466 }
3467
3468 #endif
3469 }
3470
3471 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3472 {
3473 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3474
3475 // init speed timer
3476
3477 uint speed_pos = device_param->speed_pos;
3478
3479 #ifdef _POSIX
3480 if (device_param->timer_speed.tv_sec == 0)
3481 {
3482 hc_timer_set (&device_param->timer_speed);
3483 }
3484 #endif
3485
3486 #ifdef _WIN
3487 if (device_param->timer_speed.QuadPart == 0)
3488 {
3489 hc_timer_set (&device_param->timer_speed);
3490 }
3491 #endif
3492
3493 // find higest password length, this is for optimization stuff
3494
3495 uint highest_pw_len = 0;
3496
3497 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3498 {
3499 }
3500 else if (data.attack_kern == ATTACK_KERN_COMBI)
3501 {
3502 }
3503 else if (data.attack_kern == ATTACK_KERN_BF)
3504 {
3505 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3506 + device_param->kernel_params_mp_l_buf32[5];
3507 }
3508
3509 // iteration type
3510
3511 uint innerloop_step = 0;
3512 uint innerloop_cnt = 0;
3513
3514 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3515 else innerloop_step = 1;
3516
3517 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3518 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3519 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3520
3521 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3522
3523 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3524 {
3525 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3526
3527 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3528
3529 if (data.devices_status == STATUS_CRACKED) break;
3530 if (data.devices_status == STATUS_ABORTED) break;
3531 if (data.devices_status == STATUS_QUIT) break;
3532 if (data.devices_status == STATUS_BYPASS) break;
3533
3534 salt_t *salt_buf = &data.salts_buf[salt_pos];
3535
3536 device_param->kernel_params_buf32[27] = salt_pos;
3537 device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
3538 device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
3539
3540 FILE *combs_fp = device_param->combs_fp;
3541
3542 if (data.attack_mode == ATTACK_MODE_COMBI)
3543 {
3544 rewind (combs_fp);
3545 }
3546
3547 // innerloops
3548
3549 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3550 {
3551 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3552
3553 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3554
3555 if (data.devices_status == STATUS_CRACKED) break;
3556 if (data.devices_status == STATUS_ABORTED) break;
3557 if (data.devices_status == STATUS_QUIT) break;
3558 if (data.devices_status == STATUS_BYPASS) break;
3559
3560 uint fast_iteration = 0;
3561
3562 uint innerloop_left = innerloop_cnt - innerloop_pos;
3563
3564 if (innerloop_left > innerloop_step)
3565 {
3566 innerloop_left = innerloop_step;
3567
3568 fast_iteration = 1;
3569 }
3570
3571 device_param->innerloop_pos = innerloop_pos;
3572 device_param->innerloop_left = innerloop_left;
3573
3574 device_param->kernel_params_buf32[30] = innerloop_left;
3575
3576 // i think we can get rid of this
3577 if (innerloop_left == 0)
3578 {
3579 puts ("bug, how should this happen????\n");
3580
3581 continue;
3582 }
3583
3584 if (data.salts_shown[salt_pos] == 1)
3585 {
3586 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3587
3588 continue;
3589 }
3590
3591 // initialize amplifiers
3592
3593 if (data.attack_mode == ATTACK_MODE_COMBI)
3594 {
3595 uint i = 0;
3596
3597 while (i < innerloop_left)
3598 {
3599 if (feof (combs_fp)) break;
3600
3601 int line_len = fgetl (combs_fp, line_buf);
3602
3603 if (line_len >= PW_MAX1) continue;
3604
3605 line_len = convert_from_hex (line_buf, line_len);
3606
3607 char *line_buf_new = line_buf;
3608
3609 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3610 {
3611 char rule_buf_out[BLOCK_SIZE] = { 0 };
3612
3613 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3614
3615 if (rule_len_out < 0)
3616 {
3617 data.words_progress_rejected[salt_pos] += pws_cnt;
3618
3619 continue;
3620 }
3621
3622 line_len = rule_len_out;
3623
3624 line_buf_new = rule_buf_out;
3625 }
3626
3627 line_len = MIN (line_len, PW_DICTMAX);
3628
3629 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3630
3631 memcpy (ptr, line_buf_new, line_len);
3632
3633 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3634
3635 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3636 {
3637 uppercase (ptr, line_len);
3638 }
3639
3640 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3641 {
3642 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3643 {
3644 ptr[line_len] = 0x80;
3645 }
3646
3647 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3648 {
3649 ptr[line_len] = 0x01;
3650 }
3651 }
3652
3653 device_param->combs_buf[i].pw_len = line_len;
3654
3655 i++;
3656 }
3657
3658 for (uint j = i; j < innerloop_left; j++)
3659 {
3660 device_param->combs_buf[j].i[0] = 0;
3661 device_param->combs_buf[j].i[1] = 0;
3662 device_param->combs_buf[j].i[2] = 0;
3663 device_param->combs_buf[j].i[3] = 0;
3664 device_param->combs_buf[j].i[4] = 0;
3665 device_param->combs_buf[j].i[5] = 0;
3666 device_param->combs_buf[j].i[6] = 0;
3667 device_param->combs_buf[j].i[7] = 0;
3668
3669 device_param->combs_buf[j].pw_len = 0;
3670 }
3671
3672 innerloop_left = i;
3673 }
3674 else if (data.attack_mode == ATTACK_MODE_BF)
3675 {
3676 u64 off = innerloop_pos;
3677
3678 device_param->kernel_params_mp_r_buf64[3] = off;
3679
3680 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3681 }
3682 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3683 {
3684 u64 off = innerloop_pos;
3685
3686 device_param->kernel_params_mp_buf64[3] = off;
3687
3688 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3689 }
3690 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3691 {
3692 u64 off = innerloop_pos;
3693
3694 device_param->kernel_params_mp_buf64[3] = off;
3695
3696 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3697 }
3698
3699 // copy amplifiers
3700
3701 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3702 {
3703 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3704 }
3705 else if (data.attack_mode == ATTACK_MODE_COMBI)
3706 {
3707 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3708 }
3709 else if (data.attack_mode == ATTACK_MODE_BF)
3710 {
3711 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3712 }
3713 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3714 {
3715 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3716 }
3717 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3718 {
3719 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3720 }
3721
3722 if (data.benchmark == 1)
3723 {
3724 hc_timer_set (&device_param->timer_speed);
3725 }
3726
3727 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3728
3729 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3730
3731 if (data.devices_status == STATUS_CRACKED) break;
3732 if (data.devices_status == STATUS_ABORTED) break;
3733 if (data.devices_status == STATUS_QUIT) break;
3734 if (data.devices_status == STATUS_BYPASS) break;
3735
3736 /**
3737 * result
3738 */
3739
3740 if (data.benchmark == 0)
3741 {
3742 check_cracked (device_param, salt_pos);
3743 }
3744
3745 /**
3746 * progress
3747 */
3748
3749 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3750
3751 hc_thread_mutex_lock (mux_counter);
3752
3753 data.words_progress_done[salt_pos] += perf_sum_all;
3754
3755 hc_thread_mutex_unlock (mux_counter);
3756
3757 /**
3758 * speed
3759 */
3760
3761 double speed_ms;
3762
3763 hc_timer_get (device_param->timer_speed, speed_ms);
3764
3765 hc_timer_set (&device_param->timer_speed);
3766
3767 // current speed
3768
3769 //hc_thread_mutex_lock (mux_display);
3770
3771 device_param->speed_cnt[speed_pos] = perf_sum_all;
3772
3773 device_param->speed_ms[speed_pos] = speed_ms;
3774
3775 //hc_thread_mutex_unlock (mux_display);
3776
3777 speed_pos++;
3778
3779 if (speed_pos == SPEED_CACHE)
3780 {
3781 speed_pos = 0;
3782 }
3783
3784 /**
3785 * benchmark
3786 */
3787
3788 if (data.benchmark == 1) break;
3789 }
3790 }
3791
3792 device_param->speed_pos = speed_pos;
3793
3794 myfree (line_buf);
3795 }
3796
3797 static void load_segment (wl_data_t *wl_data, FILE *fd)
3798 {
3799 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3800
3801 wl_data->pos = 0;
3802
3803 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3804
3805 wl_data->buf[wl_data->cnt] = 0;
3806
3807 if (wl_data->cnt == 0) return;
3808
3809 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3810
3811 while (!feof (fd))
3812 {
3813 if (wl_data->cnt == wl_data->avail)
3814 {
3815 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3816
3817 wl_data->avail += wl_data->incr;
3818 }
3819
3820 const int c = fgetc (fd);
3821
3822 if (c == EOF) break;
3823
3824 wl_data->buf[wl_data->cnt] = (char) c;
3825
3826 wl_data->cnt++;
3827
3828 if (c == '\n') break;
3829 }
3830
3831 // ensure stream ends with a newline
3832
3833 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3834 {
3835 wl_data->cnt++;
3836
3837 wl_data->buf[wl_data->cnt - 1] = '\n';
3838 }
3839
3840 return;
3841 }
3842
3843 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3844 {
3845 char *ptr = buf;
3846
3847 for (u32 i = 0; i < sz; i++, ptr++)
3848 {
3849 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3850
3851 if (i == 7)
3852 {
3853 *off = i;
3854 *len = i;
3855
3856 return;
3857 }
3858
3859 if (*ptr != '\n') continue;
3860
3861 *off = i + 1;
3862
3863 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3864
3865 *len = i;
3866
3867 return;
3868 }
3869
3870 *off = sz;
3871 *len = sz;
3872 }
3873
3874 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3875 {
3876 char *ptr = buf;
3877
3878 for (u32 i = 0; i < sz; i++, ptr++)
3879 {
3880 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3881
3882 if (*ptr != '\n') continue;
3883
3884 *off = i + 1;
3885
3886 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3887
3888 *len = i;
3889
3890 return;
3891 }
3892
3893 *off = sz;
3894 *len = sz;
3895 }
3896
3897 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3898 {
3899 char *ptr = buf;
3900
3901 for (u32 i = 0; i < sz; i++, ptr++)
3902 {
3903 if (*ptr != '\n') continue;
3904
3905 *off = i + 1;
3906
3907 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3908
3909 *len = i;
3910
3911 return;
3912 }
3913
3914 *off = sz;
3915 *len = sz;
3916 }
3917
3918 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3919 {
3920 while (wl_data->pos < wl_data->cnt)
3921 {
3922 uint off;
3923 uint len;
3924
3925 char *ptr = wl_data->buf + wl_data->pos;
3926
3927 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3928
3929 wl_data->pos += off;
3930
3931 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3932 {
3933 char rule_buf_out[BLOCK_SIZE] = { 0 };
3934
3935 int rule_len_out = -1;
3936
3937 if (len < BLOCK_SIZE)
3938 {
3939 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3940 }
3941
3942 if (rule_len_out < 0)
3943 {
3944 continue;
3945 }
3946
3947 if (rule_len_out > PW_MAX)
3948 {
3949 continue;
3950 }
3951 }
3952 else
3953 {
3954 if (len > PW_MAX)
3955 {
3956 continue;
3957 }
3958 }
3959
3960 *out_buf = ptr;
3961 *out_len = len;
3962
3963 return;
3964 }
3965
3966 if (feof (fd))
3967 {
3968 fprintf (stderr, "BUG feof()!!\n");
3969
3970 return;
3971 }
3972
3973 load_segment (wl_data, fd);
3974
3975 get_next_word (wl_data, fd, out_buf, out_len);
3976 }
3977
3978 #ifdef _POSIX
3979 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3980 #endif
3981
3982 #ifdef _WIN
3983 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3984 #endif
3985 {
3986 hc_signal (NULL);
3987
3988 dictstat_t d;
3989
3990 d.cnt = 0;
3991
3992 #ifdef _POSIX
3993 fstat (fileno (fd), &d.stat);
3994 #endif
3995
3996 #ifdef _WIN
3997 _fstat64 (fileno (fd), &d.stat);
3998 #endif
3999
4000 d.stat.st_mode = 0;
4001 d.stat.st_nlink = 0;
4002 d.stat.st_uid = 0;
4003 d.stat.st_gid = 0;
4004 d.stat.st_rdev = 0;
4005 d.stat.st_atime = 0;
4006
4007 #ifdef _POSIX
4008 d.stat.st_blksize = 0;
4009 d.stat.st_blocks = 0;
4010 #endif
4011
4012 if (d.stat.st_size == 0) return 0;
4013
4014 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4015
4016 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
4017 {
4018 if (d_cache)
4019 {
4020 u64 cnt = d_cache->cnt;
4021
4022 u64 keyspace = cnt;
4023
4024 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4025 {
4026 keyspace *= data.kernel_rules_cnt;
4027 }
4028 else if (data.attack_kern == ATTACK_KERN_COMBI)
4029 {
4030 keyspace *= data.combs_cnt;
4031 }
4032
4033 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
4034 if (data.quiet == 0) log_info ("");
4035
4036 hc_signal (sigHandler_default);
4037
4038 return (keyspace);
4039 }
4040 }
4041
4042 time_t now = 0;
4043 time_t prev = 0;
4044
4045 u64 comp = 0;
4046 u64 cnt = 0;
4047 u64 cnt2 = 0;
4048
4049 while (!feof (fd))
4050 {
4051 load_segment (wl_data, fd);
4052
4053 comp += wl_data->cnt;
4054
4055 u32 i = 0;
4056
4057 while (i < wl_data->cnt)
4058 {
4059 u32 len;
4060 u32 off;
4061
4062 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4063
4064 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4065 {
4066 char rule_buf_out[BLOCK_SIZE] = { 0 };
4067
4068 int rule_len_out = -1;
4069
4070 if (len < BLOCK_SIZE)
4071 {
4072 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4073 }
4074
4075 if (rule_len_out < 0)
4076 {
4077 len = PW_MAX1;
4078 }
4079 else
4080 {
4081 len = rule_len_out;
4082 }
4083 }
4084
4085 if (len < PW_MAX1)
4086 {
4087 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4088 {
4089 cnt += data.kernel_rules_cnt;
4090 }
4091 else if (data.attack_kern == ATTACK_KERN_COMBI)
4092 {
4093 cnt += data.combs_cnt;
4094 }
4095
4096 d.cnt++;
4097 }
4098
4099 i += off;
4100
4101 cnt2++;
4102 }
4103
4104 time (&now);
4105
4106 if ((now - prev) == 0) continue;
4107
4108 float percent = (float) comp / (float) d.stat.st_size;
4109
4110 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
4111
4112 time (&prev);
4113 }
4114
4115 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
4116 if (data.quiet == 0) log_info ("");
4117
4118 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4119
4120 hc_signal (sigHandler_default);
4121
4122 return (cnt);
4123 }
4124
4125 static void *thread_monitor (void *p)
4126 {
4127 uint runtime_check = 0;
4128 uint remove_check = 0;
4129 uint status_check = 0;
4130 uint restore_check = 0;
4131
4132 uint restore_left = data.restore_timer;
4133 uint remove_left = data.remove_timer;
4134 uint status_left = data.status_timer;
4135
4136 #ifdef HAVE_HWMON
4137 uint hwmon_check = 0;
4138
4139 int slowdown_warnings = 0;
4140
4141 // these variables are mainly used for fan control
4142
4143 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4144
4145 // temperature controller "loopback" values
4146
4147 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4148 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4149
4150 int temp_threshold = 1; // degrees celcius
4151
4152 int fan_speed_min = 15; // in percentage
4153 int fan_speed_max = 100;
4154
4155 time_t last_temp_check_time;
4156 #endif // HAVE_HWMON
4157
4158 uint sleep_time = 1;
4159
4160 if (data.runtime)
4161 {
4162 runtime_check = 1;
4163 }
4164
4165 if (data.restore_timer)
4166 {
4167 restore_check = 1;
4168 }
4169
4170 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4171 {
4172 remove_check = 1;
4173 }
4174
4175 if (data.status == 1)
4176 {
4177 status_check = 1;
4178 }
4179
4180 #ifdef HAVE_HWMON
4181 if (data.gpu_temp_disable == 0)
4182 {
4183 time (&last_temp_check_time);
4184
4185 hwmon_check = 1;
4186 }
4187 #endif
4188
4189 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4190 {
4191 #ifdef HAVE_HWMON
4192 if (hwmon_check == 0)
4193 #endif
4194 return (p);
4195 }
4196
4197 while (data.shutdown_inner == 0)
4198 {
4199 hc_sleep (sleep_time);
4200
4201 if (data.devices_status != STATUS_RUNNING) continue;
4202
4203 #ifdef HAVE_HWMON
4204
4205 if (hwmon_check == 1)
4206 {
4207 hc_thread_mutex_lock (mux_adl);
4208
4209 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4210 {
4211 hc_device_param_t *device_param = &data.devices_param[device_id];
4212
4213 if (device_param->skipped) continue;
4214
4215 if (device_param->device_vendor_id == VENDOR_ID_NV)
4216 {
4217 if (data.hm_nvapi)
4218 {
4219 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4220 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4221
4222 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4223 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4224
4225 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4226
4227 perfPolicies_status.info_value = perfPolicies_info.info_value;
4228
4229 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4230
4231 if (perfPolicies_status.throttle & 2)
4232 {
4233 if (slowdown_warnings < 3)
4234 {
4235 if (data.quiet == 0) clear_prompt ();
4236
4237 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4238
4239 if (slowdown_warnings == 2)
4240 {
4241 log_info ("");
4242 }
4243
4244 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4245 if (data.quiet == 0) fflush (stdout);
4246
4247 slowdown_warnings++;
4248 }
4249 }
4250 else
4251 {
4252 slowdown_warnings = 0;
4253 }
4254 }
4255 }
4256 }
4257
4258 hc_thread_mutex_unlock (mux_adl);
4259 }
4260
4261 if (hwmon_check == 1)
4262 {
4263 hc_thread_mutex_lock (mux_adl);
4264
4265 time_t temp_check_time;
4266
4267 time (&temp_check_time);
4268
4269 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4270
4271 if (Ta == 0) Ta = 1;
4272
4273 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4274 {
4275 hc_device_param_t *device_param = &data.devices_param[device_id];
4276
4277 if (device_param->skipped) continue;
4278
4279 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4280
4281 const int temperature = hm_get_temperature_with_device_id (device_id);
4282
4283 if (temperature > (int) data.gpu_temp_abort)
4284 {
4285 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4286
4287 if (data.devices_status != STATUS_QUIT) myabort ();
4288
4289 break;
4290 }
4291
4292 const int gpu_temp_retain = data.gpu_temp_retain;
4293
4294 if (gpu_temp_retain)
4295 {
4296 if (data.hm_device[device_id].fan_set_supported == 1)
4297 {
4298 int temp_cur = temperature;
4299
4300 int temp_diff_new = gpu_temp_retain - temp_cur;
4301
4302 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4303
4304 // calculate Ta value (time difference in seconds between the last check and this check)
4305
4306 last_temp_check_time = temp_check_time;
4307
4308 float Kp = 1.8;
4309 float Ki = 0.005;
4310 float Kd = 6;
4311
4312 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4313
4314 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
4315
4316 if (abs (fan_diff_required) >= temp_threshold)
4317 {
4318 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4319
4320 int fan_speed_level = fan_speed_cur;
4321
4322 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4323
4324 int fan_speed_new = fan_speed_level - fan_diff_required;
4325
4326 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4327 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4328
4329 if (fan_speed_new != fan_speed_cur)
4330 {
4331 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4332 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4333
4334 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4335 {
4336 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4337 {
4338 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4339 }
4340 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4341 {
4342 #ifdef WIN
4343 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4344 #endif
4345
4346 #ifdef LINUX
4347 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4348 #endif
4349 }
4350
4351 fan_speed_chgd[device_id] = 1;
4352 }
4353
4354 temp_diff_old[device_id] = temp_diff_new;
4355 }
4356 }
4357 }
4358 }
4359 }
4360
4361 hc_thread_mutex_unlock (mux_adl);
4362 }
4363 #endif // HAVE_HWMON
4364
4365 if (restore_check == 1)
4366 {
4367 restore_left--;
4368
4369 if (restore_left == 0)
4370 {
4371 if (data.restore_disable == 0) cycle_restore ();
4372
4373 restore_left = data.restore_timer;
4374 }
4375 }
4376
4377 if ((runtime_check == 1) && (data.runtime_start > 0))
4378 {
4379 time_t runtime_cur;
4380
4381 time (&runtime_cur);
4382
4383 int runtime_left = data.proc_start + data.runtime - runtime_cur;
4384
4385 if (runtime_left <= 0)
4386 {
4387 if (data.benchmark == 0)
4388 {
4389 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4390 }
4391
4392 if (data.devices_status != STATUS_QUIT) myabort ();
4393 }
4394 }
4395
4396 if (remove_check == 1)
4397 {
4398 remove_left--;
4399
4400 if (remove_left == 0)
4401 {
4402 if (data.digests_saved != data.digests_done)
4403 {
4404 data.digests_saved = data.digests_done;
4405
4406 save_hash ();
4407 }
4408
4409 remove_left = data.remove_timer;
4410 }
4411 }
4412
4413 if (status_check == 1)
4414 {
4415 status_left--;
4416
4417 if (status_left == 0)
4418 {
4419 hc_thread_mutex_lock (mux_display);
4420
4421 if (data.quiet == 0) clear_prompt ();
4422
4423 if (data.quiet == 0) log_info ("");
4424
4425 status_display ();
4426
4427 if (data.quiet == 0) log_info ("");
4428
4429 hc_thread_mutex_unlock (mux_display);
4430
4431 status_left = data.status_timer;
4432 }
4433 }
4434 }
4435
4436 #ifdef HAVE_HWMON
4437 myfree (fan_speed_chgd);
4438
4439 myfree (temp_diff_old);
4440 myfree (temp_diff_sum);
4441 #endif
4442
4443 p = NULL;
4444
4445 return (p);
4446 }
4447
4448 static void *thread_outfile_remove (void *p)
4449 {
4450 // some hash-dependent constants
4451 char *outfile_dir = data.outfile_check_directory;
4452 uint dgst_size = data.dgst_size;
4453 uint isSalted = data.isSalted;
4454 uint esalt_size = data.esalt_size;
4455 uint hash_mode = data.hash_mode;
4456
4457 uint outfile_check_timer = data.outfile_check_timer;
4458
4459 char separator = data.separator;
4460
4461 // some hash-dependent functions
4462 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4463 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4464
4465 // buffers
4466 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4467
4468 hash_buf.digest = mymalloc (dgst_size);
4469
4470 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4471
4472 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4473
4474 uint digest_buf[64] = { 0 };
4475
4476 outfile_data_t *out_info = NULL;
4477
4478 char **out_files = NULL;
4479
4480 time_t folder_mtime = 0;
4481
4482 int out_cnt = 0;
4483
4484 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4485
4486 while (data.shutdown_inner == 0)
4487 {
4488 hc_sleep (1);
4489
4490 if (data.devices_status != STATUS_RUNNING) continue;
4491
4492 check_left--;
4493
4494 if (check_left == 0)
4495 {
4496 struct stat outfile_check_stat;
4497
4498 if (stat (outfile_dir, &outfile_check_stat) == 0)
4499 {
4500 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4501
4502 if (is_dir == 1)
4503 {
4504 if (outfile_check_stat.st_mtime > folder_mtime)
4505 {
4506 char **out_files_new = scan_directory (outfile_dir);
4507
4508 int out_cnt_new = count_dictionaries (out_files_new);
4509
4510 outfile_data_t *out_info_new = NULL;
4511
4512 if (out_cnt_new > 0)
4513 {
4514 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4515
4516 for (int i = 0; i < out_cnt_new; i++)
4517 {
4518 out_info_new[i].file_name = out_files_new[i];
4519
4520 // check if there are files that we have seen/checked before (and not changed)
4521
4522 for (int j = 0; j < out_cnt; j++)
4523 {
4524 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4525 {
4526 struct stat outfile_stat;
4527
4528 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4529 {
4530 if (outfile_stat.st_ctime == out_info[j].ctime)
4531 {
4532 out_info_new[i].ctime = out_info[j].ctime;
4533 out_info_new[i].seek = out_info[j].seek;
4534 }
4535 }
4536 }
4537 }
4538 }
4539 }
4540
4541 local_free (out_info);
4542 local_free (out_files);
4543
4544 out_files = out_files_new;
4545 out_cnt = out_cnt_new;
4546 out_info = out_info_new;
4547
4548 folder_mtime = outfile_check_stat.st_mtime;
4549 }
4550
4551 for (int j = 0; j < out_cnt; j++)
4552 {
4553 FILE *fp = fopen (out_info[j].file_name, "rb");
4554
4555 if (fp != NULL)
4556 {
4557 //hc_thread_mutex_lock (mux_display);
4558
4559 #ifdef _POSIX
4560 struct stat outfile_stat;
4561
4562 fstat (fileno (fp), &outfile_stat);
4563 #endif
4564
4565 #ifdef _WIN
4566 struct stat64 outfile_stat;
4567
4568 _fstat64 (fileno (fp), &outfile_stat);
4569 #endif
4570
4571 if (outfile_stat.st_ctime > out_info[j].ctime)
4572 {
4573 out_info[j].ctime = outfile_stat.st_ctime;
4574 out_info[j].seek = 0;
4575 }
4576
4577 fseek (fp, out_info[j].seek, SEEK_SET);
4578
4579 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4580
4581 while (!feof (fp))
4582 {
4583 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4584
4585 if (ptr == NULL) break;
4586
4587 int line_len = strlen (line_buf);
4588
4589 if (line_len <= 0) continue;
4590
4591 int iter = MAX_CUT_TRIES;
4592
4593 for (uint i = line_len - 1; i && iter; i--, line_len--)
4594 {
4595 if (line_buf[i] != separator) continue;
4596
4597 int parser_status = PARSER_OK;
4598
4599 if ((hash_mode != 2500) && (hash_mode != 6800))
4600 {
4601 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4602 }
4603
4604 uint found = 0;
4605
4606 if (parser_status == PARSER_OK)
4607 {
4608 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4609 {
4610 if (data.salts_shown[salt_pos] == 1) continue;
4611
4612 salt_t *salt_buf = &data.salts_buf[salt_pos];
4613
4614 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4615 {
4616 uint idx = salt_buf->digests_offset + digest_pos;
4617
4618 if (data.digests_shown[idx] == 1) continue;
4619
4620 uint cracked = 0;
4621
4622 if (hash_mode == 6800)
4623 {
4624 if (i == salt_buf->salt_len)
4625 {
4626 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4627 }
4628 }
4629 else if (hash_mode == 2500)
4630 {
4631 // BSSID : MAC1 : MAC2 (:plain)
4632 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4633 {
4634 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4635
4636 if (!cracked) continue;
4637
4638 // now compare MAC1 and MAC2 too, since we have this additional info
4639 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4640 char *mac2_pos = mac1_pos + 12 + 1;
4641
4642 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4643 wpa_t *wpa = &wpas[salt_pos];
4644
4645 // compare hex string(s) vs binary MAC address(es)
4646
4647 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4648 {
4649 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4650 {
4651 cracked = 0;
4652
4653 break;
4654 }
4655 }
4656
4657 // early skip ;)
4658 if (!cracked) continue;
4659
4660 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4661 {
4662 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4663 {
4664 cracked = 0;
4665
4666 break;
4667 }
4668 }
4669 }
4670 }
4671 else
4672 {
4673 char *digests_buf_ptr = (char *) data.digests_buf;
4674
4675 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4676
4677 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4678 }
4679
4680 if (cracked == 1)
4681 {
4682 found = 1;
4683
4684 data.digests_shown[idx] = 1;
4685
4686 data.digests_done++;
4687
4688 salt_buf->digests_done++;
4689
4690 if (salt_buf->digests_done == salt_buf->digests_cnt)
4691 {
4692 data.salts_shown[salt_pos] = 1;
4693
4694 data.salts_done++;
4695
4696 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4697 }
4698 }
4699 }
4700
4701 if (data.devices_status == STATUS_CRACKED) break;
4702 }
4703 }
4704
4705 if (found) break;
4706
4707 if (data.devices_status == STATUS_CRACKED) break;
4708
4709 iter--;
4710 }
4711
4712 if (data.devices_status == STATUS_CRACKED) break;
4713 }
4714
4715 myfree (line_buf);
4716
4717 out_info[j].seek = ftell (fp);
4718
4719 //hc_thread_mutex_unlock (mux_display);
4720
4721 fclose (fp);
4722 }
4723 }
4724 }
4725 }
4726
4727 check_left = outfile_check_timer;
4728 }
4729 }
4730
4731 if (esalt_size) local_free (hash_buf.esalt);
4732
4733 if (isSalted) local_free (hash_buf.salt);
4734
4735 local_free (hash_buf.digest);
4736
4737 local_free (out_info);
4738
4739 local_free (out_files);
4740
4741 p = NULL;
4742
4743 return (p);
4744 }
4745
4746 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4747 {
4748 //if (device_param->pws_cnt < device_param->kernel_power)
4749 //{
4750 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4751
4752 u8 *ptr = (u8 *) pw->i;
4753
4754 memcpy (ptr, pw_buf, pw_len);
4755
4756 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4757
4758 pw->pw_len = pw_len;
4759
4760 device_param->pws_cnt++;
4761 //}
4762 //else
4763 //{
4764 // fprintf (stderr, "BUG pw_add()!!\n");
4765 //
4766 // return;
4767 //}
4768 }
4769
4770 static void set_kernel_power_final (const u64 kernel_power_final)
4771 {
4772 if (data.quiet == 0)
4773 {
4774 clear_prompt ();
4775
4776 //log_info ("");
4777
4778 log_info ("INFO: approaching final keyspace, workload adjusted");
4779 log_info ("");
4780
4781 fprintf (stdout, "%s", PROMPT);
4782
4783 fflush (stdout);
4784 }
4785
4786 data.kernel_power_final = kernel_power_final;
4787 }
4788
4789 static u32 get_power (hc_device_param_t *device_param)
4790 {
4791 const u64 kernel_power_final = data.kernel_power_final;
4792
4793 if (kernel_power_final)
4794 {
4795 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4796
4797 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4798
4799 // work should be at least the hardware power available without any accelerator
4800
4801 const u64 work = MAX (words_left_device, device_param->hardware_power);
4802
4803 return work;
4804 }
4805
4806 return device_param->kernel_power;
4807 }
4808
4809 static uint get_work (hc_device_param_t *device_param, const u64 max)
4810 {
4811 hc_thread_mutex_lock (mux_dispatcher);
4812
4813 const u64 words_cur = data.words_cur;
4814 const u64 words_base = (data.limit == 0) ? data.words_base : MIN (data.limit, data.words_base);
4815
4816 device_param->words_off = words_cur;
4817
4818 const u64 kernel_power_all = data.kernel_power_all;
4819
4820 const u64 words_left = words_base - words_cur;
4821
4822 if (words_left < kernel_power_all)
4823 {
4824 if (data.kernel_power_final == 0)
4825 {
4826 set_kernel_power_final (words_left);
4827 }
4828 }
4829
4830 const u32 kernel_power = get_power (device_param);
4831
4832 uint work = MIN (words_left, kernel_power);
4833
4834 work = MIN (work, max);
4835
4836 data.words_cur += work;
4837
4838 hc_thread_mutex_unlock (mux_dispatcher);
4839
4840 return work;
4841 }
4842
4843 static void *thread_autotune (void *p)
4844 {
4845 hc_device_param_t *device_param = (hc_device_param_t *) p;
4846
4847 if (device_param->skipped) return NULL;
4848
4849 autotune (device_param);
4850
4851 return NULL;
4852 }
4853
4854 static void *thread_calc_stdin (void *p)
4855 {
4856 hc_device_param_t *device_param = (hc_device_param_t *) p;
4857
4858 if (device_param->skipped) return NULL;
4859
4860 char *buf = (char *) mymalloc (HCBUFSIZ);
4861
4862 const uint attack_kern = data.attack_kern;
4863
4864 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4865 {
4866 hc_thread_mutex_lock (mux_dispatcher);
4867
4868 if (feof (stdin) != 0)
4869 {
4870 hc_thread_mutex_unlock (mux_dispatcher);
4871
4872 break;
4873 }
4874
4875 uint words_cur = 0;
4876
4877 while (words_cur < device_param->kernel_power)
4878 {
4879 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4880
4881 if (line_buf == NULL) break;
4882
4883 uint line_len = in_superchop (line_buf);
4884
4885 line_len = convert_from_hex (line_buf, line_len);
4886
4887 // post-process rule engine
4888
4889 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4890 {
4891 char rule_buf_out[BLOCK_SIZE] = { 0 };
4892
4893 int rule_len_out = -1;
4894
4895 if (line_len < BLOCK_SIZE)
4896 {
4897 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4898 }
4899
4900 if (rule_len_out < 0) continue;
4901
4902 line_buf = rule_buf_out;
4903 line_len = rule_len_out;
4904 }
4905
4906 if (line_len > PW_MAX)
4907 {
4908 continue;
4909 }
4910
4911 // hmm that's always the case, or?
4912
4913 if (attack_kern == ATTACK_KERN_STRAIGHT)
4914 {
4915 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4916 {
4917 hc_thread_mutex_lock (mux_counter);
4918
4919 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4920 {
4921 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4922 }
4923
4924 hc_thread_mutex_unlock (mux_counter);
4925
4926 continue;
4927 }
4928 }
4929
4930 pw_add (device_param, (u8 *) line_buf, line_len);
4931
4932 words_cur++;
4933
4934 if (data.devices_status == STATUS_CRACKED) break;
4935 if (data.devices_status == STATUS_ABORTED) break;
4936 if (data.devices_status == STATUS_QUIT) break;
4937 if (data.devices_status == STATUS_BYPASS) break;
4938 }
4939
4940 hc_thread_mutex_unlock (mux_dispatcher);
4941
4942 if (data.devices_status == STATUS_CRACKED) break;
4943 if (data.devices_status == STATUS_ABORTED) break;
4944 if (data.devices_status == STATUS_QUIT) break;
4945 if (data.devices_status == STATUS_BYPASS) break;
4946
4947 // flush
4948
4949 const uint pws_cnt = device_param->pws_cnt;
4950
4951 if (pws_cnt)
4952 {
4953 run_copy (device_param, pws_cnt);
4954
4955 run_cracker (device_param, pws_cnt);
4956
4957 device_param->pws_cnt = 0;
4958
4959 /*
4960 still required?
4961 if (attack_kern == ATTACK_KERN_STRAIGHT)
4962 {
4963 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4964 }
4965 else if (attack_kern == ATTACK_KERN_COMBI)
4966 {
4967 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4968 }
4969 */
4970 }
4971 }
4972
4973 device_param->kernel_accel = 0;
4974 device_param->kernel_loops = 0;
4975
4976 myfree (buf);
4977
4978 return NULL;
4979 }
4980
4981 static void *thread_calc (void *p)
4982 {
4983 hc_device_param_t *device_param = (hc_device_param_t *) p;
4984
4985 if (device_param->skipped) return NULL;
4986
4987 const uint attack_mode = data.attack_mode;
4988 const uint attack_kern = data.attack_kern;
4989
4990 if (attack_mode == ATTACK_MODE_BF)
4991 {
4992 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4993 {
4994 const uint work = get_work (device_param, -1);
4995
4996 if (work == 0) break;
4997
4998 const u64 words_off = device_param->words_off;
4999 const u64 words_fin = words_off + work;
5000
5001 const uint pws_cnt = work;
5002
5003 device_param->pws_cnt = pws_cnt;
5004
5005 if (pws_cnt)
5006 {
5007 run_copy (device_param, pws_cnt);
5008
5009 run_cracker (device_param, pws_cnt);
5010
5011 device_param->pws_cnt = 0;
5012
5013 /*
5014 still required?
5015 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
5016 */
5017 }
5018
5019 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5020
5021 if (data.devices_status == STATUS_CRACKED) break;
5022 if (data.devices_status == STATUS_ABORTED) break;
5023 if (data.devices_status == STATUS_QUIT) break;
5024 if (data.devices_status == STATUS_BYPASS) break;
5025
5026 if (data.benchmark == 1) break;
5027
5028 device_param->words_done = words_fin;
5029 }
5030 }
5031 else
5032 {
5033 const uint segment_size = data.segment_size;
5034
5035 char *dictfile = data.dictfile;
5036
5037 if (attack_mode == ATTACK_MODE_COMBI)
5038 {
5039 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5040 {
5041 dictfile = data.dictfile2;
5042 }
5043 }
5044
5045 FILE *fd = fopen (dictfile, "rb");
5046
5047 if (fd == NULL)
5048 {
5049 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5050
5051 return NULL;
5052 }
5053
5054 if (attack_mode == ATTACK_MODE_COMBI)
5055 {
5056 const uint combs_mode = data.combs_mode;
5057
5058 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5059 {
5060 const char *dictfilec = data.dictfile2;
5061
5062 FILE *combs_fp = fopen (dictfilec, "rb");
5063
5064 if (combs_fp == NULL)
5065 {
5066 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5067
5068 fclose (fd);
5069
5070 return NULL;
5071 }
5072
5073 device_param->combs_fp = combs_fp;
5074 }
5075 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5076 {
5077 const char *dictfilec = data.dictfile;
5078
5079 FILE *combs_fp = fopen (dictfilec, "rb");
5080
5081 if (combs_fp == NULL)
5082 {
5083 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5084
5085 fclose (fd);
5086
5087 return NULL;
5088 }
5089
5090 device_param->combs_fp = combs_fp;
5091 }
5092 }
5093
5094 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5095
5096 wl_data->buf = (char *) mymalloc (segment_size);
5097 wl_data->avail = segment_size;
5098 wl_data->incr = segment_size;
5099 wl_data->cnt = 0;
5100 wl_data->pos = 0;
5101
5102 u64 words_cur = 0;
5103
5104 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5105 {
5106 u64 words_off = 0;
5107 u64 words_fin = 0;
5108
5109 u64 max = -1;
5110
5111 while (max)
5112 {
5113 const uint work = get_work (device_param, max);
5114
5115 if (work == 0) break;
5116
5117 max = 0;
5118
5119 words_off = device_param->words_off;
5120 words_fin = words_off + work;
5121
5122 char *line_buf;
5123 uint line_len;
5124
5125 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5126
5127 for ( ; words_cur < words_fin; words_cur++)
5128 {
5129 get_next_word (wl_data, fd, &line_buf, &line_len);
5130
5131 line_len = convert_from_hex (line_buf, line_len);
5132
5133 // post-process rule engine
5134
5135 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5136 {
5137 char rule_buf_out[BLOCK_SIZE] = { 0 };
5138
5139 int rule_len_out = -1;
5140
5141 if (line_len < BLOCK_SIZE)
5142 {
5143 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5144 }
5145
5146 if (rule_len_out < 0) continue;
5147
5148 line_buf = rule_buf_out;
5149 line_len = rule_len_out;
5150 }
5151
5152 if (attack_kern == ATTACK_KERN_STRAIGHT)
5153 {
5154 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5155 {
5156 max++;
5157
5158 hc_thread_mutex_lock (mux_counter);
5159
5160 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5161 {
5162 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5163 }
5164
5165 hc_thread_mutex_unlock (mux_counter);
5166
5167 continue;
5168 }
5169 }
5170 else if (attack_kern == ATTACK_KERN_COMBI)
5171 {
5172 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5173 // since we still need to combine the plains
5174
5175 if (line_len > data.pw_max)
5176 {
5177 max++;
5178
5179 hc_thread_mutex_lock (mux_counter);
5180
5181 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5182 {
5183 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5184 }
5185
5186 hc_thread_mutex_unlock (mux_counter);
5187
5188 continue;
5189 }
5190 }
5191
5192 pw_add (device_param, (u8 *) line_buf, line_len);
5193
5194 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5195
5196 if (data.devices_status == STATUS_CRACKED) break;
5197 if (data.devices_status == STATUS_ABORTED) break;
5198 if (data.devices_status == STATUS_QUIT) break;
5199 if (data.devices_status == STATUS_BYPASS) break;
5200 }
5201
5202 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5203
5204 if (data.devices_status == STATUS_CRACKED) break;
5205 if (data.devices_status == STATUS_ABORTED) break;
5206 if (data.devices_status == STATUS_QUIT) break;
5207 if (data.devices_status == STATUS_BYPASS) break;
5208 }
5209
5210 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5211
5212 if (data.devices_status == STATUS_CRACKED) break;
5213 if (data.devices_status == STATUS_ABORTED) break;
5214 if (data.devices_status == STATUS_QUIT) break;
5215 if (data.devices_status == STATUS_BYPASS) break;
5216
5217 //
5218 // flush
5219 //
5220
5221 const uint pws_cnt = device_param->pws_cnt;
5222
5223 if (pws_cnt)
5224 {
5225 run_copy (device_param, pws_cnt);
5226
5227 run_cracker (device_param, pws_cnt);
5228
5229 device_param->pws_cnt = 0;
5230
5231 /*
5232 still required?
5233 if (attack_kern == ATTACK_KERN_STRAIGHT)
5234 {
5235 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5236 }
5237 else if (attack_kern == ATTACK_KERN_COMBI)
5238 {
5239 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5240 }
5241 */
5242 }
5243
5244 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5245
5246 if (data.devices_status == STATUS_CRACKED) break;
5247 if (data.devices_status == STATUS_ABORTED) break;
5248 if (data.devices_status == STATUS_QUIT) break;
5249 if (data.devices_status == STATUS_BYPASS) break;
5250
5251 if (words_fin == 0) break;
5252
5253 device_param->words_done = words_fin;
5254 }
5255
5256 if (attack_mode == ATTACK_MODE_COMBI)
5257 {
5258 fclose (device_param->combs_fp);
5259 }
5260
5261 free (wl_data->buf);
5262 free (wl_data);
5263
5264 fclose (fd);
5265 }
5266
5267 device_param->kernel_accel = 0;
5268 device_param->kernel_loops = 0;
5269
5270 return NULL;
5271 }
5272
5273 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5274 {
5275 if (!device_param)
5276 {
5277 log_error ("ERROR: %s : Invalid argument", __func__);
5278
5279 exit (-1);
5280 }
5281
5282 salt_t *salt_buf = &data.salts_buf[salt_pos];
5283
5284 device_param->kernel_params_buf32[27] = salt_pos;
5285 device_param->kernel_params_buf32[30] = 1;
5286 device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
5287 device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
5288 device_param->kernel_params_buf32[33] = 0;
5289 device_param->kernel_params_buf32[34] = 1;
5290
5291 char *dictfile_old = data.dictfile;
5292
5293 const char *weak_hash_check = "weak-hash-check";
5294
5295 data.dictfile = (char *) weak_hash_check;
5296
5297 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5298
5299 data.kernel_rules_buf[0].cmds[0] = 0;
5300
5301 /**
5302 * run the kernel
5303 */
5304
5305 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5306 {
5307 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5308 }
5309 else
5310 {
5311 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5312
5313 uint loop_step = 16;
5314
5315 const uint iter = salt_buf->salt_iter;
5316
5317 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5318 {
5319 uint loop_left = iter - loop_pos;
5320
5321 loop_left = MIN (loop_left, loop_step);
5322
5323 device_param->kernel_params_buf32[28] = loop_pos;
5324 device_param->kernel_params_buf32[29] = loop_left;
5325
5326 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5327 }
5328
5329 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5330 }
5331
5332 /**
5333 * result
5334 */
5335
5336 check_cracked (device_param, salt_pos);
5337
5338 /**
5339 * cleanup
5340 */
5341
5342 device_param->kernel_params_buf32[27] = 0;
5343 device_param->kernel_params_buf32[28] = 0;
5344 device_param->kernel_params_buf32[29] = 0;
5345 device_param->kernel_params_buf32[30] = 0;
5346 device_param->kernel_params_buf32[31] = 0;
5347 device_param->kernel_params_buf32[32] = 0;
5348 device_param->kernel_params_buf32[33] = 0;
5349 device_param->kernel_params_buf32[34] = 0;
5350
5351 data.dictfile = dictfile_old;
5352
5353 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5354 }
5355
5356 // hlfmt hashcat
5357
5358 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5359 {
5360 if (data.username == 0)
5361 {
5362 *hashbuf_pos = line_buf;
5363 *hashbuf_len = line_len;
5364 }
5365 else
5366 {
5367 char *pos = line_buf;
5368 int len = line_len;
5369
5370 for (int i = 0; i < line_len; i++, pos++, len--)
5371 {
5372 if (line_buf[i] == data.separator)
5373 {
5374 pos++;
5375
5376 len--;
5377
5378 break;
5379 }
5380 }
5381
5382 *hashbuf_pos = pos;
5383 *hashbuf_len = len;
5384 }
5385 }
5386
5387 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5388 {
5389 char *pos = NULL;
5390 int len = 0;
5391
5392 int sep_cnt = 0;
5393
5394 for (int i = 0; i < line_len; i++)
5395 {
5396 if (line_buf[i] == data.separator)
5397 {
5398 sep_cnt++;
5399
5400 continue;
5401 }
5402
5403 if (sep_cnt == 0)
5404 {
5405 if (pos == NULL) pos = line_buf + i;
5406
5407 len++;
5408 }
5409 }
5410
5411 *userbuf_pos = pos;
5412 *userbuf_len = len;
5413 }
5414
5415 // hlfmt pwdump
5416
5417 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5418 {
5419 int sep_cnt = 0;
5420
5421 int sep2_len = 0;
5422 int sep3_len = 0;
5423
5424 for (int i = 0; i < line_len; i++)
5425 {
5426 if (line_buf[i] == ':')
5427 {
5428 sep_cnt++;
5429
5430 continue;
5431 }
5432
5433 if (sep_cnt == 2) sep2_len++;
5434 if (sep_cnt == 3) sep3_len++;
5435 }
5436
5437 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5438
5439 return 0;
5440 }
5441
5442 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5443 {
5444 char *pos = NULL;
5445 int len = 0;
5446
5447 int sep_cnt = 0;
5448
5449 for (int i = 0; i < line_len; i++)
5450 {
5451 if (line_buf[i] == ':')
5452 {
5453 sep_cnt++;
5454
5455 continue;
5456 }
5457
5458 if (data.hash_mode == 1000)
5459 {
5460 if (sep_cnt == 3)
5461 {
5462 if (pos == NULL) pos = line_buf + i;
5463
5464 len++;
5465 }
5466 }
5467 else if (data.hash_mode == 3000)
5468 {
5469 if (sep_cnt == 2)
5470 {
5471 if (pos == NULL) pos = line_buf + i;
5472
5473 len++;
5474 }
5475 }
5476 }
5477
5478 *hashbuf_pos = pos;
5479 *hashbuf_len = len;
5480 }
5481
5482 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5483 {
5484 char *pos = NULL;
5485 int len = 0;
5486
5487 int sep_cnt = 0;
5488
5489 for (int i = 0; i < line_len; i++)
5490 {
5491 if (line_buf[i] == ':')
5492 {
5493 sep_cnt++;
5494
5495 continue;
5496 }
5497
5498 if (sep_cnt == 0)
5499 {
5500 if (pos == NULL) pos = line_buf + i;
5501
5502 len++;
5503 }
5504 }
5505
5506 *userbuf_pos = pos;
5507 *userbuf_len = len;
5508 }
5509
5510 // hlfmt passwd
5511
5512 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5513 {
5514 int sep_cnt = 0;
5515
5516 char sep5_first = 0;
5517 char sep6_first = 0;
5518
5519 for (int i = 0; i < line_len; i++)
5520 {
5521 if (line_buf[i] == ':')
5522 {
5523 sep_cnt++;
5524
5525 continue;
5526 }
5527
5528 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5529 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5530 }
5531
5532 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5533
5534 return 0;
5535 }
5536
5537 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5538 {
5539 char *pos = NULL;
5540 int len = 0;
5541
5542 int sep_cnt = 0;
5543
5544 for (int i = 0; i < line_len; i++)
5545 {
5546 if (line_buf[i] == ':')
5547 {
5548 sep_cnt++;
5549
5550 continue;
5551 }
5552
5553 if (sep_cnt == 1)
5554 {
5555 if (pos == NULL) pos = line_buf + i;
5556
5557 len++;
5558 }
5559 }
5560
5561 *hashbuf_pos = pos;
5562 *hashbuf_len = len;
5563 }
5564
5565 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5566 {
5567 char *pos = NULL;
5568 int len = 0;
5569
5570 int sep_cnt = 0;
5571
5572 for (int i = 0; i < line_len; i++)
5573 {
5574 if (line_buf[i] == ':')
5575 {
5576 sep_cnt++;
5577
5578 continue;
5579 }
5580
5581 if (sep_cnt == 0)
5582 {
5583 if (pos == NULL) pos = line_buf + i;
5584
5585 len++;
5586 }
5587 }
5588
5589 *userbuf_pos = pos;
5590 *userbuf_len = len;
5591 }
5592
5593 // hlfmt shadow
5594
5595 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5596 {
5597 int sep_cnt = 0;
5598
5599 for (int i = 0; i < line_len; i++)
5600 {
5601 if (line_buf[i] == ':') sep_cnt++;
5602 }
5603
5604 if (sep_cnt == 8) return 1;
5605
5606 return 0;
5607 }
5608
5609 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5610 {
5611 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5612 }
5613
5614 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5615 {
5616 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5617 }
5618
5619 // hlfmt main
5620
5621 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5622 {
5623 switch (hashfile_format)
5624 {
5625 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5626 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5627 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5628 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5629 }
5630 }
5631
5632 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5633 {
5634 switch (hashfile_format)
5635 {
5636 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5637 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5638 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5639 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5640 }
5641 }
5642
5643 char *strhlfmt (const uint hashfile_format)
5644 {
5645 switch (hashfile_format)
5646 {
5647 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5648 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5649 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5650 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5651 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5652 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5653 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5654 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5655 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5656 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5657 }
5658
5659 return ((char *) "Unknown");
5660 }
5661
5662 static uint hlfmt_detect (FILE *fp, uint max_check)
5663 {
5664 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5665
5666 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5667 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5668
5669 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5670
5671 uint num_check = 0;
5672
5673 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5674
5675 while (!feof (fp))
5676 {
5677 int line_len = fgetl (fp, line_buf);
5678
5679 if (line_len == 0) continue;
5680
5681 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5682 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5683 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5684
5685 if (num_check == max_check) break;
5686
5687 num_check++;
5688 }
5689
5690 myfree (line_buf);
5691
5692 uint hashlist_format = HLFMT_HASHCAT;
5693
5694 for (int i = 1; i < HLFMTS_CNT; i++)
5695 {
5696 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5697
5698 hashlist_format = i;
5699 }
5700
5701 free (formats_cnt);
5702
5703 return hashlist_format;
5704 }
5705
5706 /**
5707 * some further helper function
5708 */
5709
5710 // wrapper around mymalloc for ADL
5711
5712 #if defined(HAVE_HWMON)
5713 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5714 {
5715 return mymalloc (iSize);
5716 }
5717 #endif
5718
5719 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
5720 {
5721 u64 collisions = 0;
5722
5723 const uint dgst_pos0 = data.dgst_pos0;
5724 const uint dgst_pos1 = data.dgst_pos1;
5725 const uint dgst_pos2 = data.dgst_pos2;
5726 const uint dgst_pos3 = data.dgst_pos3;
5727
5728 memset (bitmap_a, 0, bitmap_size);
5729 memset (bitmap_b, 0, bitmap_size);
5730 memset (bitmap_c, 0, bitmap_size);
5731 memset (bitmap_d, 0, bitmap_size);
5732
5733 for (uint i = 0; i < digests_cnt; i++)
5734 {
5735 uint *digest_ptr = (uint *) digests_buf_ptr;
5736
5737 digests_buf_ptr += dgst_size;
5738
5739 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5740 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5741 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5742 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5743
5744 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5745 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5746 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5747 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5748
5749 if (bitmap_a[idx0] & val0) collisions++;
5750 if (bitmap_b[idx1] & val1) collisions++;
5751 if (bitmap_c[idx2] & val2) collisions++;
5752 if (bitmap_d[idx3] & val3) collisions++;
5753
5754 bitmap_a[idx0] |= val0;
5755 bitmap_b[idx1] |= val1;
5756 bitmap_c[idx2] |= val2;
5757 bitmap_d[idx3] |= val3;
5758
5759 if (collisions >= collisions_max) return 0x7fffffff;
5760 }
5761
5762 return collisions;
5763 }
5764
5765 /**
5766 * main
5767 */
5768
5769 #ifdef WIN
5770 void SetConsoleWindowSize (const int x)
5771 {
5772 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5773
5774 if (h == INVALID_HANDLE_VALUE) return;
5775
5776 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5777
5778 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5779
5780 SMALL_RECT *sr = &bufferInfo.srWindow;
5781
5782 sr->Right = MAX (sr->Right, x - 1);
5783
5784 COORD co;
5785
5786 co.X = sr->Right + 1;
5787 co.Y = 9999;
5788
5789 if (!SetConsoleScreenBufferSize (h, co)) return;
5790
5791 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5792 }
5793 #endif
5794
5795 int main (int argc, char **argv)
5796 {
5797 #ifdef WIN
5798 SetConsoleWindowSize (132);
5799 #endif
5800
5801 /**
5802 * To help users a bit
5803 */
5804
5805 char *compute = getenv ("COMPUTE");
5806
5807 if (compute)
5808 {
5809 static char display[100];
5810
5811 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5812
5813 putenv (display);
5814 }
5815 else
5816 {
5817 if (getenv ("DISPLAY") == NULL)
5818 putenv ((char *) "DISPLAY=:0");
5819 }
5820
5821 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5822 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5823
5824 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5825 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5826
5827 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5828 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5829
5830 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5831 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5832
5833 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5834 putenv ((char *) "POCL_KERNEL_CACHE=0");
5835
5836 umask (077);
5837
5838 /**
5839 * Real init
5840 */
5841
5842 memset (&data, 0, sizeof (hc_global_data_t));
5843
5844 time_t proc_start;
5845
5846 time (&proc_start);
5847
5848 data.proc_start = proc_start;
5849
5850 int myargc = argc;
5851 char **myargv = argv;
5852
5853 hc_thread_mutex_init (mux_dispatcher);
5854 hc_thread_mutex_init (mux_counter);
5855 hc_thread_mutex_init (mux_display);
5856 hc_thread_mutex_init (mux_adl);
5857
5858 /**
5859 * commandline parameters
5860 */
5861
5862 uint usage = USAGE;
5863 uint version = VERSION;
5864 uint quiet = QUIET;
5865 uint benchmark = BENCHMARK;
5866 uint stdout_flag = STDOUT_FLAG;
5867 uint show = SHOW;
5868 uint left = LEFT;
5869 uint username = USERNAME;
5870 uint remove = REMOVE;
5871 uint remove_timer = REMOVE_TIMER;
5872 u64 skip = SKIP;
5873 u64 limit = LIMIT;
5874 uint keyspace = KEYSPACE;
5875 uint potfile_disable = POTFILE_DISABLE;
5876 char *potfile_path = NULL;
5877 uint debug_mode = DEBUG_MODE;
5878 char *debug_file = NULL;
5879 char *induction_dir = NULL;
5880 char *outfile_check_dir = NULL;
5881 uint force = FORCE;
5882 uint runtime = RUNTIME;
5883 uint hash_mode = HASH_MODE;
5884 uint attack_mode = ATTACK_MODE;
5885 uint markov_disable = MARKOV_DISABLE;
5886 uint markov_classic = MARKOV_CLASSIC;
5887 uint markov_threshold = MARKOV_THRESHOLD;
5888 char *markov_hcstat = NULL;
5889 char *outfile = NULL;
5890 uint outfile_format = OUTFILE_FORMAT;
5891 uint outfile_autohex = OUTFILE_AUTOHEX;
5892 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5893 uint restore = RESTORE;
5894 uint restore_timer = RESTORE_TIMER;
5895 uint restore_disable = RESTORE_DISABLE;
5896 uint status = STATUS;
5897 uint status_timer = STATUS_TIMER;
5898 uint machine_readable = MACHINE_READABLE;
5899 uint loopback = LOOPBACK;
5900 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5901 char *session = NULL;
5902 uint hex_charset = HEX_CHARSET;
5903 uint hex_salt = HEX_SALT;
5904 uint hex_wordlist = HEX_WORDLIST;
5905 uint rp_gen = RP_GEN;
5906 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5907 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5908 uint rp_gen_seed = RP_GEN_SEED;
5909 char *rule_buf_l = (char *) RULE_BUF_L;
5910 char *rule_buf_r = (char *) RULE_BUF_R;
5911 uint increment = INCREMENT;
5912 uint increment_min = INCREMENT_MIN;
5913 uint increment_max = INCREMENT_MAX;
5914 char *cpu_affinity = NULL;
5915 OCL_PTR *ocl = NULL;
5916 char *opencl_devices = NULL;
5917 char *opencl_platforms = NULL;
5918 char *opencl_device_types = NULL;
5919 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5920 char *truecrypt_keyfiles = NULL;
5921 char *veracrypt_keyfiles = NULL;
5922 uint veracrypt_pim = 0;
5923 uint workload_profile = WORKLOAD_PROFILE;
5924 uint kernel_accel = KERNEL_ACCEL;
5925 uint kernel_loops = KERNEL_LOOPS;
5926 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5927 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5928 #ifdef HAVE_HWMON
5929 uint gpu_temp_abort = GPU_TEMP_ABORT;
5930 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5931 uint powertune_enable = POWERTUNE_ENABLE;
5932 #endif
5933 uint logfile_disable = LOGFILE_DISABLE;
5934 uint segment_size = SEGMENT_SIZE;
5935 uint scrypt_tmto = SCRYPT_TMTO;
5936 char separator = SEPARATOR;
5937 uint bitmap_min = BITMAP_MIN;
5938 uint bitmap_max = BITMAP_MAX;
5939 char *custom_charset_1 = NULL;
5940 char *custom_charset_2 = NULL;
5941 char *custom_charset_3 = NULL;
5942 char *custom_charset_4 = NULL;
5943
5944 #define IDX_HELP 'h'
5945 #define IDX_VERSION 'V'
5946 #define IDX_VERSION_LOWER 'v'
5947 #define IDX_QUIET 0xff02
5948 #define IDX_SHOW 0xff03
5949 #define IDX_LEFT 0xff04
5950 #define IDX_REMOVE 0xff05
5951 #define IDX_REMOVE_TIMER 0xff37
5952 #define IDX_SKIP 's'
5953 #define IDX_LIMIT 'l'
5954 #define IDX_KEYSPACE 0xff35
5955 #define IDX_POTFILE_DISABLE 0xff06
5956 #define IDX_POTFILE_PATH 0xffe0
5957 #define IDX_DEBUG_MODE 0xff43
5958 #define IDX_DEBUG_FILE 0xff44
5959 #define IDX_INDUCTION_DIR 0xff46
5960 #define IDX_OUTFILE_CHECK_DIR 0xff47
5961 #define IDX_USERNAME 0xff07
5962 #define IDX_FORCE 0xff08
5963 #define IDX_RUNTIME 0xff09
5964 #define IDX_BENCHMARK 'b'
5965 #define IDX_STDOUT_FLAG 0xff77
5966 #define IDX_HASH_MODE 'm'
5967 #define IDX_ATTACK_MODE 'a'
5968 #define IDX_RP_FILE 'r'
5969 #define IDX_RP_GEN 'g'
5970 #define IDX_RP_GEN_FUNC_MIN 0xff10
5971 #define IDX_RP_GEN_FUNC_MAX 0xff11
5972 #define IDX_RP_GEN_SEED 0xff34
5973 #define IDX_RULE_BUF_L 'j'
5974 #define IDX_RULE_BUF_R 'k'
5975 #define IDX_INCREMENT 'i'
5976 #define IDX_INCREMENT_MIN 0xff12
5977 #define IDX_INCREMENT_MAX 0xff13
5978 #define IDX_OUTFILE 'o'
5979 #define IDX_OUTFILE_FORMAT 0xff14
5980 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5981 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5982 #define IDX_RESTORE 0xff15
5983 #define IDX_RESTORE_DISABLE 0xff27
5984 #define IDX_STATUS 0xff17
5985 #define IDX_STATUS_TIMER 0xff18
5986 #define IDX_MACHINE_READABLE 0xff50
5987 #define IDX_LOOPBACK 0xff38
5988 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5989 #define IDX_SESSION 0xff19
5990 #define IDX_HEX_CHARSET 0xff20
5991 #define IDX_HEX_SALT 0xff21
5992 #define IDX_HEX_WORDLIST 0xff40
5993 #define IDX_MARKOV_DISABLE 0xff22
5994 #define IDX_MARKOV_CLASSIC 0xff23
5995 #define IDX_MARKOV_THRESHOLD 't'
5996 #define IDX_MARKOV_HCSTAT 0xff24
5997 #define IDX_CPU_AFFINITY 0xff25
5998 #define IDX_OPENCL_DEVICES 'd'
5999 #define IDX_OPENCL_PLATFORMS 0xff72
6000 #define IDX_OPENCL_DEVICE_TYPES 'D'
6001 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
6002 #define IDX_WORKLOAD_PROFILE 'w'
6003 #define IDX_KERNEL_ACCEL 'n'
6004 #define IDX_KERNEL_LOOPS 'u'
6005 #define IDX_NVIDIA_SPIN_DAMP 0xff79
6006 #define IDX_GPU_TEMP_DISABLE 0xff29
6007 #define IDX_GPU_TEMP_ABORT 0xff30
6008 #define IDX_GPU_TEMP_RETAIN 0xff31
6009 #define IDX_POWERTUNE_ENABLE 0xff41
6010 #define IDX_LOGFILE_DISABLE 0xff51
6011 #define IDX_TRUECRYPT_KEYFILES 0xff52
6012 #define IDX_VERACRYPT_KEYFILES 0xff53
6013 #define IDX_VERACRYPT_PIM 0xff54
6014 #define IDX_SCRYPT_TMTO 0xff61
6015 #define IDX_SEGMENT_SIZE 'c'
6016 #define IDX_SEPARATOR 'p'
6017 #define IDX_BITMAP_MIN 0xff70
6018 #define IDX_BITMAP_MAX 0xff71
6019 #define IDX_CUSTOM_CHARSET_1 '1'
6020 #define IDX_CUSTOM_CHARSET_2 '2'
6021 #define IDX_CUSTOM_CHARSET_3 '3'
6022 #define IDX_CUSTOM_CHARSET_4 '4'
6023
6024 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
6025
6026 struct option long_options[] =
6027 {
6028 {"help", no_argument, 0, IDX_HELP},
6029 {"version", no_argument, 0, IDX_VERSION},
6030 {"quiet", no_argument, 0, IDX_QUIET},
6031 {"show", no_argument, 0, IDX_SHOW},
6032 {"left", no_argument, 0, IDX_LEFT},
6033 {"username", no_argument, 0, IDX_USERNAME},
6034 {"remove", no_argument, 0, IDX_REMOVE},
6035 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
6036 {"skip", required_argument, 0, IDX_SKIP},
6037 {"limit", required_argument, 0, IDX_LIMIT},
6038 {"keyspace", no_argument, 0, IDX_KEYSPACE},
6039 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
6040 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
6041 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
6042 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
6043 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
6044 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6045 {"force", no_argument, 0, IDX_FORCE},
6046 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6047 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
6048 {"restore", no_argument, 0, IDX_RESTORE},
6049 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6050 {"status", no_argument, 0, IDX_STATUS},
6051 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6052 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
6053 {"loopback", no_argument, 0, IDX_LOOPBACK},
6054 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6055 {"session", required_argument, 0, IDX_SESSION},
6056 {"runtime", required_argument, 0, IDX_RUNTIME},
6057 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6058 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6059 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6060 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
6061 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6062 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6063 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6064 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6065 {"rules-file", required_argument, 0, IDX_RP_FILE},
6066 {"outfile", required_argument, 0, IDX_OUTFILE},
6067 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6068 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6069 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6070 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6071 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6072 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6073 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6074 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6075 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6076 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6077 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6078 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
6079 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
6080 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6081 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6082 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6083 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6084 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6085 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6086 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6087 #ifdef HAVE_HWMON
6088 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6089 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6090 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6091 #endif // HAVE_HWMON
6092 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6093 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6094 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6095 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6096 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6097 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6098 {"seperator", required_argument, 0, IDX_SEPARATOR},
6099 {"separator", required_argument, 0, IDX_SEPARATOR},
6100 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6101 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6102 {"increment", no_argument, 0, IDX_INCREMENT},
6103 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6104 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6105 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6106 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6107 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6108 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6109 {0, 0, 0, 0}
6110 };
6111
6112 uint rp_files_cnt = 0;
6113
6114 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6115
6116 int option_index = 0;
6117 int c = -1;
6118
6119 optind = 1;
6120 optopt = 0;
6121
6122 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6123 {
6124 switch (c)
6125 {
6126 case IDX_HELP: usage = 1; break;
6127 case IDX_VERSION:
6128 case IDX_VERSION_LOWER: version = 1; break;
6129 case IDX_RESTORE: restore = 1; break;
6130 case IDX_SESSION: session = optarg; break;
6131 case IDX_SHOW: show = 1; break;
6132 case IDX_LEFT: left = 1; break;
6133 case '?': return (-1);
6134 }
6135 }
6136
6137 if (optopt != 0)
6138 {
6139 log_error ("ERROR: Invalid argument specified");
6140
6141 return (-1);
6142 }
6143
6144 /**
6145 * exit functions
6146 */
6147
6148 if (version)
6149 {
6150 log_info ("%s", VERSION_TAG);
6151
6152 return (0);
6153 }
6154
6155 if (usage)
6156 {
6157 usage_big_print (PROGNAME);
6158
6159 return (0);
6160 }
6161
6162 /**
6163 * session needs to be set, always!
6164 */
6165
6166 if (session == NULL) session = (char *) PROGNAME;
6167
6168 /**
6169 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6170 */
6171
6172 char *exec_path = get_exec_path ();
6173
6174 #ifdef LINUX
6175
6176 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6177 char *resolved_exec_path = realpath (exec_path, NULL);
6178
6179 if (resolved_install_folder == NULL)
6180 {
6181 log_error ("ERROR: %s: %s", resolved_install_folder, strerror (errno));
6182
6183 return (-1);
6184 }
6185
6186 if (resolved_exec_path == NULL)
6187 {
6188 log_error ("ERROR: %s: %s", resolved_exec_path, strerror (errno));
6189
6190 return (-1);
6191 }
6192
6193 char *install_dir = get_install_dir (resolved_exec_path);
6194 char *profile_dir = NULL;
6195 char *session_dir = NULL;
6196 char *shared_dir = NULL;
6197
6198 if (strcmp (install_dir, resolved_install_folder) == 0)
6199 {
6200 struct passwd *pw = getpwuid (getuid ());
6201
6202 const char *homedir = pw->pw_dir;
6203
6204 profile_dir = get_profile_dir (homedir);
6205 session_dir = get_session_dir (profile_dir);
6206 shared_dir = strdup (SHARED_FOLDER);
6207
6208 mkdir (profile_dir, 0700);
6209 mkdir (session_dir, 0700);
6210 }
6211 else
6212 {
6213 profile_dir = install_dir;
6214 session_dir = install_dir;
6215 shared_dir = install_dir;
6216 }
6217
6218 myfree (resolved_install_folder);
6219 myfree (resolved_exec_path);
6220
6221 #else
6222
6223 char *install_dir = get_install_dir (exec_path);
6224 char *profile_dir = install_dir;
6225 char *session_dir = install_dir;
6226 char *shared_dir = install_dir;
6227
6228 #endif
6229
6230 data.install_dir = install_dir;
6231 data.profile_dir = profile_dir;
6232 data.session_dir = session_dir;
6233 data.shared_dir = shared_dir;
6234
6235 myfree (exec_path);
6236
6237 /**
6238 * kernel cache, we need to make sure folder exist
6239 */
6240
6241 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6242
6243 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6244
6245 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6246
6247 mkdir (kernels_folder, 0700);
6248
6249 myfree (kernels_folder);
6250
6251 /**
6252 * session
6253 */
6254
6255 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6256
6257 data.session = session;
6258
6259 char *eff_restore_file = (char *) mymalloc (session_size);
6260 char *new_restore_file = (char *) mymalloc (session_size);
6261
6262 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6263 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6264
6265 data.eff_restore_file = eff_restore_file;
6266 data.new_restore_file = new_restore_file;
6267
6268 if (((show == 1) || (left == 1)) && (restore == 1))
6269 {
6270 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6271 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6272
6273 return (-1);
6274 }
6275
6276 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6277 if ((show == 1) || (left == 1))
6278 {
6279 restore_disable = 1;
6280
6281 restore = 0;
6282 }
6283
6284 data.restore_disable = restore_disable;
6285
6286 restore_data_t *rd = init_restore (argc, argv);
6287
6288 data.rd = rd;
6289
6290 /**
6291 * restore file
6292 */
6293
6294 if (restore == 1)
6295 {
6296 read_restore (eff_restore_file, rd);
6297
6298 if (rd->version_bin < RESTORE_MIN)
6299 {
6300 log_error ("ERROR: Incompatible restore-file version");
6301
6302 return (-1);
6303 }
6304
6305 myargc = rd->argc;
6306 myargv = rd->argv;
6307
6308 #ifdef _POSIX
6309 rd->pid = getpid ();
6310 #elif _WIN
6311 rd->pid = GetCurrentProcessId ();
6312 #endif
6313 }
6314
6315 uint hash_mode_chgd = 0;
6316 uint runtime_chgd = 0;
6317 uint kernel_loops_chgd = 0;
6318 uint kernel_accel_chgd = 0;
6319 uint nvidia_spin_damp_chgd = 0;
6320 uint attack_mode_chgd = 0;
6321 uint outfile_format_chgd = 0;
6322 uint rp_gen_seed_chgd = 0;
6323 uint remove_timer_chgd = 0;
6324 uint increment_min_chgd = 0;
6325 uint increment_max_chgd = 0;
6326 uint workload_profile_chgd = 0;
6327 uint opencl_vector_width_chgd = 0;
6328
6329 optind = 1;
6330 optopt = 0;
6331 option_index = 0;
6332
6333 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6334 {
6335 switch (c)
6336 {
6337 //case IDX_HELP: usage = 1; break;
6338 //case IDX_VERSION: version = 1; break;
6339 //case IDX_RESTORE: restore = 1; break;
6340 case IDX_QUIET: quiet = 1; break;
6341 //case IDX_SHOW: show = 1; break;
6342 case IDX_SHOW: break;
6343 //case IDX_LEFT: left = 1; break;
6344 case IDX_LEFT: break;
6345 case IDX_USERNAME: username = 1; break;
6346 case IDX_REMOVE: remove = 1; break;
6347 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6348 remove_timer_chgd = 1; break;
6349 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6350 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6351 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6352 case IDX_DEBUG_FILE: debug_file = optarg; break;
6353 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6354 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6355 case IDX_FORCE: force = 1; break;
6356 case IDX_SKIP: skip = atoll (optarg); break;
6357 case IDX_LIMIT: limit = atoll (optarg); break;
6358 case IDX_KEYSPACE: keyspace = 1; break;
6359 case IDX_BENCHMARK: benchmark = 1; break;
6360 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6361 case IDX_RESTORE: break;
6362 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6363 case IDX_STATUS: status = 1; break;
6364 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6365 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6366 case IDX_LOOPBACK: loopback = 1; break;
6367 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6368 //case IDX_SESSION: session = optarg; break;
6369 case IDX_SESSION: break;
6370 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6371 hash_mode_chgd = 1; break;
6372 case IDX_RUNTIME: runtime = atoi (optarg);
6373 runtime_chgd = 1; break;
6374 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6375 attack_mode_chgd = 1; break;
6376 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6377 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6378 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6379 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6380 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6381 rp_gen_seed_chgd = 1; break;
6382 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6383 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6384 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6385 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6386 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6387 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6388 case IDX_OUTFILE: outfile = optarg; break;
6389 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6390 outfile_format_chgd = 1; break;
6391 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6392 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6393 case IDX_HEX_CHARSET: hex_charset = 1; break;
6394 case IDX_HEX_SALT: hex_salt = 1; break;
6395 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6396 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6397 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6398 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6399 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6400 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6401 opencl_vector_width_chgd = 1; break;
6402 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6403 workload_profile_chgd = 1; break;
6404 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6405 kernel_accel_chgd = 1; break;
6406 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6407 kernel_loops_chgd = 1; break;
6408 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6409 nvidia_spin_damp_chgd = 1; break;
6410 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6411 #ifdef HAVE_HWMON
6412 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6413 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6414 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6415 #endif // HAVE_HWMON
6416 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6417 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6418 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6419 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6420 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6421 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6422 case IDX_SEPARATOR: separator = optarg[0]; break;
6423 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6424 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6425 case IDX_INCREMENT: increment = 1; break;
6426 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6427 increment_min_chgd = 1; break;
6428 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6429 increment_max_chgd = 1; break;
6430 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6431 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6432 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6433 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6434
6435 default:
6436 log_error ("ERROR: Invalid argument specified");
6437 return (-1);
6438 }
6439 }
6440
6441 if (optopt != 0)
6442 {
6443 log_error ("ERROR: Invalid argument specified");
6444
6445 return (-1);
6446 }
6447
6448 /**
6449 * Inform user things getting started,
6450 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6451 * - we do not need to check algorithm_pos
6452 */
6453
6454 if (quiet == 0)
6455 {
6456 if (benchmark == 1)
6457 {
6458 if (machine_readable == 0)
6459 {
6460 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6461 log_info ("");
6462 }
6463 else
6464 {
6465 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6466 }
6467 }
6468 else if (restore == 1)
6469 {
6470 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6471 log_info ("");
6472 }
6473 else if (stdout_flag == 1)
6474 {
6475 // do nothing
6476 }
6477 else if (keyspace == 1)
6478 {
6479 // do nothing
6480 }
6481 else
6482 {
6483 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6484 log_info ("");
6485 }
6486 }
6487
6488 /**
6489 * sanity check
6490 */
6491
6492 if (attack_mode > 7)
6493 {
6494 log_error ("ERROR: Invalid attack-mode specified");
6495
6496 return (-1);
6497 }
6498
6499 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6500 {
6501 log_error ("ERROR: Invalid runtime specified");
6502
6503 return (-1);
6504 }
6505
6506 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6507 {
6508 log_error ("ERROR: Invalid hash-type specified");
6509
6510 return (-1);
6511 }
6512
6513 // renamed hash modes
6514
6515 if (hash_mode_chgd)
6516 {
6517 int n = -1;
6518
6519 switch (hash_mode)
6520 {
6521 case 123: n = 124;
6522 break;
6523 }
6524
6525 if (n >= 0)
6526 {
6527 log_error ("Old -m specified, use -m %d instead", n);
6528
6529 return (-1);
6530 }
6531 }
6532
6533 if (username == 1)
6534 {
6535 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6536 {
6537 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6538
6539 return (-1);
6540 }
6541 }
6542
6543 if (outfile_format > 16)
6544 {
6545 log_error ("ERROR: Invalid outfile-format specified");
6546
6547 return (-1);
6548 }
6549
6550 if (left == 1)
6551 {
6552 if (outfile_format_chgd == 1)
6553 {
6554 if (outfile_format > 1)
6555 {
6556 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6557
6558 return (-1);
6559 }
6560 }
6561 else
6562 {
6563 outfile_format = OUTFILE_FMT_HASH;
6564 }
6565 }
6566
6567 if (show == 1)
6568 {
6569 if (outfile_format_chgd == 1)
6570 {
6571 if ((outfile_format > 7) && (outfile_format < 16))
6572 {
6573 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6574
6575 return (-1);
6576 }
6577 }
6578 }
6579
6580 if (increment_min < INCREMENT_MIN)
6581 {
6582 log_error ("ERROR: Invalid increment-min specified");
6583
6584 return (-1);
6585 }
6586
6587 if (increment_max > INCREMENT_MAX)
6588 {
6589 log_error ("ERROR: Invalid increment-max specified");
6590
6591 return (-1);
6592 }
6593
6594 if (increment_min > increment_max)
6595 {
6596 log_error ("ERROR: Invalid increment-min specified");
6597
6598 return (-1);
6599 }
6600
6601 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6602 {
6603 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6604
6605 return (-1);
6606 }
6607
6608 if ((increment == 0) && (increment_min_chgd == 1))
6609 {
6610 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6611
6612 return (-1);
6613 }
6614
6615 if ((increment == 0) && (increment_max_chgd == 1))
6616 {
6617 log_error ("ERROR: Increment-max is only supported combined with increment switch");
6618
6619 return (-1);
6620 }
6621
6622 if (rp_files_cnt && rp_gen)
6623 {
6624 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6625
6626 return (-1);
6627 }
6628
6629 if (rp_files_cnt || rp_gen)
6630 {
6631 if (attack_mode != ATTACK_MODE_STRAIGHT)
6632 {
6633 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6634
6635 return (-1);
6636 }
6637 }
6638
6639 if (rp_gen_func_min > rp_gen_func_max)
6640 {
6641 log_error ("ERROR: Invalid rp-gen-func-min specified");
6642
6643 return (-1);
6644 }
6645
6646 if (kernel_accel_chgd == 1)
6647 {
6648 if (force == 0)
6649 {
6650 log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6651 log_info ("Please consider using the -w option instead");
6652 log_info ("You can use --force to override this but do not post error reports if you do so");
6653 log_info ("");
6654
6655 return (-1);
6656 }
6657
6658 if (kernel_accel < 1)
6659 {
6660 log_error ("ERROR: Invalid kernel-accel specified");
6661
6662 return (-1);
6663 }
6664
6665 if (kernel_accel > 1024)
6666 {
6667 log_error ("ERROR: Invalid kernel-accel specified");
6668
6669 return (-1);
6670 }
6671 }
6672
6673 if (kernel_loops_chgd == 1)
6674 {
6675 if (force == 0)
6676 {
6677 log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
6678 log_info ("Please consider using the -w option instead");
6679 log_info ("You can use --force to override this but do not post error reports if you do so");
6680 log_info ("");
6681
6682 return (-1);
6683 }
6684
6685 if (kernel_loops < 1)
6686 {
6687 log_error ("ERROR: Invalid kernel-loops specified");
6688
6689 return (-1);
6690 }
6691
6692 if (kernel_loops > 1024)
6693 {
6694 log_error ("ERROR: Invalid kernel-loops specified");
6695
6696 return (-1);
6697 }
6698 }
6699
6700 if ((workload_profile < 1) || (workload_profile > 4))
6701 {
6702 log_error ("ERROR: workload-profile %i not available", workload_profile);
6703
6704 return (-1);
6705 }
6706
6707 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6708 {
6709 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6710
6711 return (-1);
6712 }
6713
6714 if (show == 1 || left == 1)
6715 {
6716 attack_mode = ATTACK_MODE_NONE;
6717
6718 if (remove == 1)
6719 {
6720 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6721
6722 return (-1);
6723 }
6724
6725 if (potfile_disable == 1)
6726 {
6727 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6728
6729 return (-1);
6730 }
6731 }
6732
6733 uint attack_kern = ATTACK_KERN_NONE;
6734
6735 switch (attack_mode)
6736 {
6737 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6738 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6739 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6740 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6741 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6742 }
6743
6744 if (benchmark == 1)
6745 {
6746 if (myargv[optind] != 0)
6747 {
6748 log_error ("ERROR: Invalid argument for benchmark mode specified");
6749
6750 return (-1);
6751 }
6752
6753 if (attack_mode_chgd == 1)
6754 {
6755 if (attack_mode != ATTACK_MODE_BF)
6756 {
6757 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6758
6759 return (-1);
6760 }
6761 }
6762 }
6763 else
6764 {
6765 if (stdout_flag == 1) // no hash here
6766 {
6767 optind--;
6768 }
6769
6770 if (keyspace == 1)
6771 {
6772 int num_additional_params = 1;
6773
6774 if (attack_kern == ATTACK_KERN_COMBI)
6775 {
6776 num_additional_params = 2;
6777 }
6778
6779 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6780
6781 if (keyspace_wordlist_specified == 0) optind--;
6782 }
6783
6784 if (attack_kern == ATTACK_KERN_NONE)
6785 {
6786 if ((optind + 1) != myargc)
6787 {
6788 usage_mini_print (myargv[0]);
6789
6790 return (-1);
6791 }
6792 }
6793 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6794 {
6795 if ((optind + 1) > myargc)
6796 {
6797 usage_mini_print (myargv[0]);
6798
6799 return (-1);
6800 }
6801 }
6802 else if (attack_kern == ATTACK_KERN_COMBI)
6803 {
6804 if ((optind + 3) != myargc)
6805 {
6806 usage_mini_print (myargv[0]);
6807
6808 return (-1);
6809 }
6810 }
6811 else if (attack_kern == ATTACK_KERN_BF)
6812 {
6813 if ((optind + 1) > myargc)
6814 {
6815 usage_mini_print (myargv[0]);
6816
6817 return (-1);
6818 }
6819 }
6820 else
6821 {
6822 usage_mini_print (myargv[0]);
6823
6824 return (-1);
6825 }
6826 }
6827
6828 if (skip != 0 && limit != 0)
6829 {
6830 limit += skip;
6831 }
6832
6833 if (keyspace == 1)
6834 {
6835 if (show == 1)
6836 {
6837 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6838
6839 return (-1);
6840 }
6841 else if (left == 1)
6842 {
6843 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6844
6845 return (-1);
6846 }
6847
6848 potfile_disable = 1;
6849
6850 restore_disable = 1;
6851
6852 restore = 0;
6853
6854 weak_hash_threshold = 0;
6855
6856 quiet = 1;
6857 }
6858
6859 if (stdout_flag == 1)
6860 {
6861 status_timer = 0;
6862 restore_timer = 0;
6863 restore_disable = 1;
6864 restore = 0;
6865 potfile_disable = 1;
6866 weak_hash_threshold = 0;
6867 gpu_temp_disable = 1;
6868 hash_mode = 2000;
6869 quiet = 1;
6870 outfile_format = OUTFILE_FMT_PLAIN;
6871 kernel_accel = 1024;
6872 kernel_loops = 1024;
6873 force = 1;
6874 outfile_check_timer = 0;
6875 session = "stdout";
6876 opencl_vector_width = 1;
6877 }
6878
6879 if (remove_timer_chgd == 1)
6880 {
6881 if (remove == 0)
6882 {
6883 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6884
6885 return (-1);
6886 }
6887
6888 if (remove_timer < 1)
6889 {
6890 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6891
6892 return (-1);
6893 }
6894 }
6895
6896 if (loopback == 1)
6897 {
6898 if (attack_mode == ATTACK_MODE_STRAIGHT)
6899 {
6900 if ((rp_files_cnt == 0) && (rp_gen == 0))
6901 {
6902 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6903
6904 return (-1);
6905 }
6906 }
6907 else
6908 {
6909 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6910
6911 return (-1);
6912 }
6913 }
6914
6915 if (debug_mode > 0)
6916 {
6917 if (attack_mode != ATTACK_MODE_STRAIGHT)
6918 {
6919 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6920
6921 return (-1);
6922 }
6923
6924 if ((rp_files_cnt == 0) && (rp_gen == 0))
6925 {
6926 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6927
6928 return (-1);
6929 }
6930 }
6931
6932 if (debug_mode > 4)
6933 {
6934 log_error ("ERROR: Invalid debug-mode specified");
6935
6936 return (-1);
6937 }
6938
6939 if (debug_file != NULL)
6940 {
6941 if (debug_mode < 1)
6942 {
6943 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6944
6945 return (-1);
6946 }
6947 }
6948
6949 if (induction_dir != NULL)
6950 {
6951 if (attack_mode == ATTACK_MODE_BF)
6952 {
6953 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6954
6955 return (-1);
6956 }
6957 }
6958
6959 if (attack_mode != ATTACK_MODE_STRAIGHT)
6960 {
6961 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6962 {
6963 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6964
6965 return (-1);
6966 }
6967
6968 weak_hash_threshold = 0;
6969 }
6970
6971 if (nvidia_spin_damp > 100)
6972 {
6973 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6974
6975 return (-1);
6976 }
6977
6978
6979 /**
6980 * induction directory
6981 */
6982
6983 char *induction_directory = NULL;
6984
6985 if (attack_mode != ATTACK_MODE_BF)
6986 {
6987 if (induction_dir == NULL)
6988 {
6989 induction_directory = (char *) mymalloc (session_size);
6990
6991 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6992
6993 // create induction folder if it does not already exist
6994
6995 if (keyspace == 0)
6996 {
6997 if (rmdir (induction_directory) == -1)
6998 {
6999 if (errno == ENOENT)
7000 {
7001 // good, we can ignore
7002 }
7003 else if (errno == ENOTEMPTY)
7004 {
7005 char *induction_directory_mv = (char *) mymalloc (session_size);
7006
7007 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
7008
7009 if (rename (induction_directory, induction_directory_mv) != 0)
7010 {
7011 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
7012
7013 return (-1);
7014 }
7015 }
7016 else
7017 {
7018 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7019
7020 return (-1);
7021 }
7022 }
7023
7024 if (mkdir (induction_directory, 0700) == -1)
7025 {
7026 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7027
7028 return (-1);
7029 }
7030 }
7031 }
7032 else
7033 {
7034 induction_directory = induction_dir;
7035 }
7036 }
7037
7038 data.induction_directory = induction_directory;
7039
7040 /**
7041 * loopback
7042 */
7043
7044 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
7045
7046 char *loopback_file = (char *) mymalloc (loopback_size);
7047
7048 /**
7049 * tuning db
7050 */
7051
7052 char tuning_db_file[256] = { 0 };
7053
7054 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
7055
7056 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7057
7058 /**
7059 * outfile-check directory
7060 */
7061
7062 char *outfile_check_directory = NULL;
7063
7064 if (outfile_check_dir == NULL)
7065 {
7066 outfile_check_directory = (char *) mymalloc (session_size);
7067
7068 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7069 }
7070 else
7071 {
7072 outfile_check_directory = outfile_check_dir;
7073 }
7074
7075 data.outfile_check_directory = outfile_check_directory;
7076
7077 if (keyspace == 0)
7078 {
7079 struct stat outfile_check_stat;
7080
7081 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7082 {
7083 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7084
7085 if (is_dir == 0)
7086 {
7087 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7088
7089 return (-1);
7090 }
7091 }
7092 else if (outfile_check_dir == NULL)
7093 {
7094 if (mkdir (outfile_check_directory, 0700) == -1)
7095 {
7096 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7097
7098 return (-1);
7099 }
7100 }
7101 }
7102
7103 /**
7104 * special other stuff
7105 */
7106
7107 if (hash_mode == 9710)
7108 {
7109 outfile_format = 5;
7110 outfile_format_chgd = 1;
7111 }
7112
7113 if (hash_mode == 9810)
7114 {
7115 outfile_format = 5;
7116 outfile_format_chgd = 1;
7117 }
7118
7119 if (hash_mode == 10410)
7120 {
7121 outfile_format = 5;
7122 outfile_format_chgd = 1;
7123 }
7124
7125 /**
7126 * store stuff
7127 */
7128
7129 data.hash_mode = hash_mode;
7130 data.restore = restore;
7131 data.restore_timer = restore_timer;
7132 data.restore_disable = restore_disable;
7133 data.status = status;
7134 data.status_timer = status_timer;
7135 data.machine_readable = machine_readable;
7136 data.loopback = loopback;
7137 data.runtime = runtime;
7138 data.remove = remove;
7139 data.remove_timer = remove_timer;
7140 data.debug_mode = debug_mode;
7141 data.debug_file = debug_file;
7142 data.username = username;
7143 data.quiet = quiet;
7144 data.outfile = outfile;
7145 data.outfile_format = outfile_format;
7146 data.outfile_autohex = outfile_autohex;
7147 data.hex_charset = hex_charset;
7148 data.hex_salt = hex_salt;
7149 data.hex_wordlist = hex_wordlist;
7150 data.separator = separator;
7151 data.rp_files = rp_files;
7152 data.rp_files_cnt = rp_files_cnt;
7153 data.rp_gen = rp_gen;
7154 data.rp_gen_seed = rp_gen_seed;
7155 data.force = force;
7156 data.benchmark = benchmark;
7157 data.skip = skip;
7158 data.limit = limit;
7159 #ifdef HAVE_HWMON
7160 data.powertune_enable = powertune_enable;
7161 #endif
7162 data.logfile_disable = logfile_disable;
7163 data.truecrypt_keyfiles = truecrypt_keyfiles;
7164 data.veracrypt_keyfiles = veracrypt_keyfiles;
7165 data.veracrypt_pim = veracrypt_pim;
7166 data.scrypt_tmto = scrypt_tmto;
7167 data.workload_profile = workload_profile;
7168
7169 /**
7170 * cpu affinity
7171 */
7172
7173 if (cpu_affinity)
7174 {
7175 set_cpu_affinity (cpu_affinity);
7176 }
7177
7178 if (rp_gen_seed_chgd == 0)
7179 {
7180 srand (proc_start);
7181 }
7182 else
7183 {
7184 srand (rp_gen_seed);
7185 }
7186
7187 /**
7188 * logfile init
7189 */
7190
7191 if (logfile_disable == 0)
7192 {
7193 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7194
7195 char *logfile = (char *) mymalloc (logfile_size);
7196
7197 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7198
7199 data.logfile = logfile;
7200
7201 char *topid = logfile_generate_topid ();
7202
7203 data.topid = topid;
7204 }
7205
7206 // logfile_append() checks for logfile_disable internally to make it easier from here
7207
7208 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7209 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7210 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7211 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7212 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7213 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7214 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7215 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7216 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7217 #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));
7218
7219 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7220 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7221 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7222 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7223 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7224 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7225 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7226 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7227
7228 logfile_top_msg ("START");
7229
7230 logfile_top_uint (attack_mode);
7231 logfile_top_uint (attack_kern);
7232 logfile_top_uint (benchmark);
7233 logfile_top_uint (stdout_flag);
7234 logfile_top_uint (bitmap_min);
7235 logfile_top_uint (bitmap_max);
7236 logfile_top_uint (debug_mode);
7237 logfile_top_uint (force);
7238 logfile_top_uint (kernel_accel);
7239 logfile_top_uint (kernel_loops);
7240 logfile_top_uint (nvidia_spin_damp);
7241 logfile_top_uint (gpu_temp_disable);
7242 #ifdef HAVE_HWMON
7243 logfile_top_uint (gpu_temp_abort);
7244 logfile_top_uint (gpu_temp_retain);
7245 #endif
7246 logfile_top_uint (hash_mode);
7247 logfile_top_uint (hex_charset);
7248 logfile_top_uint (hex_salt);
7249 logfile_top_uint (hex_wordlist);
7250 logfile_top_uint (increment);
7251 logfile_top_uint (increment_max);
7252 logfile_top_uint (increment_min);
7253 logfile_top_uint (keyspace);
7254 logfile_top_uint (left);
7255 logfile_top_uint (logfile_disable);
7256 logfile_top_uint (loopback);
7257 logfile_top_uint (markov_classic);
7258 logfile_top_uint (markov_disable);
7259 logfile_top_uint (markov_threshold);
7260 logfile_top_uint (outfile_autohex);
7261 logfile_top_uint (outfile_check_timer);
7262 logfile_top_uint (outfile_format);
7263 logfile_top_uint (potfile_disable);
7264 logfile_top_string (potfile_path);
7265 #if defined(HAVE_HWMON)
7266 logfile_top_uint (powertune_enable);
7267 #endif
7268 logfile_top_uint (scrypt_tmto);
7269 logfile_top_uint (quiet);
7270 logfile_top_uint (remove);
7271 logfile_top_uint (remove_timer);
7272 logfile_top_uint (restore);
7273 logfile_top_uint (restore_disable);
7274 logfile_top_uint (restore_timer);
7275 logfile_top_uint (rp_gen);
7276 logfile_top_uint (rp_gen_func_max);
7277 logfile_top_uint (rp_gen_func_min);
7278 logfile_top_uint (rp_gen_seed);
7279 logfile_top_uint (runtime);
7280 logfile_top_uint (segment_size);
7281 logfile_top_uint (show);
7282 logfile_top_uint (status);
7283 logfile_top_uint (machine_readable);
7284 logfile_top_uint (status_timer);
7285 logfile_top_uint (usage);
7286 logfile_top_uint (username);
7287 logfile_top_uint (version);
7288 logfile_top_uint (weak_hash_threshold);
7289 logfile_top_uint (workload_profile);
7290 logfile_top_uint64 (limit);
7291 logfile_top_uint64 (skip);
7292 logfile_top_char (separator);
7293 logfile_top_string (cpu_affinity);
7294 logfile_top_string (custom_charset_1);
7295 logfile_top_string (custom_charset_2);
7296 logfile_top_string (custom_charset_3);
7297 logfile_top_string (custom_charset_4);
7298 logfile_top_string (debug_file);
7299 logfile_top_string (opencl_devices);
7300 logfile_top_string (opencl_platforms);
7301 logfile_top_string (opencl_device_types);
7302 logfile_top_uint (opencl_vector_width);
7303 logfile_top_string (induction_dir);
7304 logfile_top_string (markov_hcstat);
7305 logfile_top_string (outfile);
7306 logfile_top_string (outfile_check_dir);
7307 logfile_top_string (rule_buf_l);
7308 logfile_top_string (rule_buf_r);
7309 logfile_top_string (session);
7310 logfile_top_string (truecrypt_keyfiles);
7311 logfile_top_string (veracrypt_keyfiles);
7312 logfile_top_uint (veracrypt_pim);
7313
7314 /**
7315 * Init OpenCL library loader
7316 */
7317
7318 if (keyspace == 0)
7319 {
7320 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7321
7322 ocl_init (ocl);
7323
7324 data.ocl = ocl;
7325 }
7326
7327 /**
7328 * OpenCL platform selection
7329 */
7330
7331 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7332
7333 /**
7334 * OpenCL device selection
7335 */
7336
7337 u32 devices_filter = setup_devices_filter (opencl_devices);
7338
7339 /**
7340 * OpenCL device type selection
7341 */
7342
7343 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7344
7345 /**
7346 * benchmark
7347 */
7348
7349 if (benchmark == 1)
7350 {
7351 /**
7352 * disable useless stuff for benchmark
7353 */
7354
7355 status_timer = 0;
7356 restore_timer = 0;
7357 restore_disable = 1;
7358 potfile_disable = 1;
7359 weak_hash_threshold = 0;
7360 nvidia_spin_damp = 0;
7361 gpu_temp_disable = 1;
7362 outfile_check_timer = 0;
7363
7364 #ifdef HAVE_HWMON
7365 if (powertune_enable == 1)
7366 {
7367 gpu_temp_disable = 0;
7368 }
7369 #endif
7370
7371 data.status_timer = status_timer;
7372 data.restore_timer = restore_timer;
7373 data.restore_disable = restore_disable;
7374 data.outfile_check_timer = outfile_check_timer;
7375
7376 /**
7377 * force attack mode to be bruteforce
7378 */
7379
7380 attack_mode = ATTACK_MODE_BF;
7381 attack_kern = ATTACK_KERN_BF;
7382
7383 if (workload_profile_chgd == 0)
7384 {
7385 workload_profile = 3;
7386
7387 data.workload_profile = workload_profile;
7388 }
7389 }
7390
7391 /**
7392 * status, monitor and outfile remove threads
7393 */
7394
7395 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
7396
7397 data.wordlist_mode = wordlist_mode;
7398
7399 if (wordlist_mode == WL_MODE_STDIN)
7400 {
7401 status = 1;
7402
7403 data.status = status;
7404 }
7405
7406 uint outer_threads_cnt = 0;
7407
7408 hc_thread_t *outer_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
7409
7410 data.shutdown_outer = 0;
7411
7412 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
7413 {
7414 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
7415 {
7416 hc_thread_create (outer_threads[outer_threads_cnt], thread_keypress, NULL);
7417
7418 outer_threads_cnt++;
7419 }
7420 }
7421
7422 /**
7423 * config
7424 */
7425
7426 uint hash_type = 0;
7427 uint salt_type = 0;
7428 uint attack_exec = 0;
7429 uint opts_type = 0;
7430 uint kern_type = 0;
7431 uint dgst_size = 0;
7432 uint esalt_size = 0;
7433 uint opti_type = 0;
7434 uint dgst_pos0 = -1;
7435 uint dgst_pos1 = -1;
7436 uint dgst_pos2 = -1;
7437 uint dgst_pos3 = -1;
7438
7439 int (*parse_func) (char *, uint, hash_t *);
7440 int (*sort_by_digest) (const void *, const void *);
7441
7442 uint algorithm_pos = 0;
7443 uint algorithm_max = 1;
7444
7445 uint *algorithms = default_benchmark_algorithms;
7446
7447 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7448
7449 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7450 {
7451 /*
7452 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7453 * the following algos are skipped entirely
7454 */
7455
7456 if (algorithm_pos > 0)
7457 {
7458 local_free (rd);
7459
7460 rd = init_restore (argc, argv);
7461
7462 data.rd = rd;
7463 }
7464
7465 /**
7466 * update hash_mode in case of multihash benchmark
7467 */
7468
7469 if (benchmark == 1)
7470 {
7471 if (hash_mode_chgd == 0)
7472 {
7473 hash_mode = algorithms[algorithm_pos];
7474
7475 data.hash_mode = hash_mode;
7476 }
7477
7478 quiet = 1;
7479
7480 data.quiet = quiet;
7481 }
7482
7483 switch (hash_mode)
7484 {
7485 case 0: hash_type = HASH_TYPE_MD5;
7486 salt_type = SALT_TYPE_NONE;
7487 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7488 opts_type = OPTS_TYPE_PT_GENERATE_LE
7489 | OPTS_TYPE_PT_ADD80
7490 | OPTS_TYPE_PT_ADDBITS14;
7491 kern_type = KERN_TYPE_MD5;
7492 dgst_size = DGST_SIZE_4_4;
7493 parse_func = md5_parse_hash;
7494 sort_by_digest = sort_by_digest_4_4;
7495 opti_type = OPTI_TYPE_ZERO_BYTE
7496 | OPTI_TYPE_PRECOMPUTE_INIT
7497 | OPTI_TYPE_PRECOMPUTE_MERKLE
7498 | OPTI_TYPE_MEET_IN_MIDDLE
7499 | OPTI_TYPE_EARLY_SKIP
7500 | OPTI_TYPE_NOT_ITERATED
7501 | OPTI_TYPE_NOT_SALTED
7502 | OPTI_TYPE_RAW_HASH;
7503 dgst_pos0 = 0;
7504 dgst_pos1 = 3;
7505 dgst_pos2 = 2;
7506 dgst_pos3 = 1;
7507 break;
7508
7509 case 10: hash_type = HASH_TYPE_MD5;
7510 salt_type = SALT_TYPE_INTERN;
7511 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7512 opts_type = OPTS_TYPE_PT_GENERATE_LE
7513 | OPTS_TYPE_ST_ADD80
7514 | OPTS_TYPE_ST_ADDBITS14;
7515 kern_type = KERN_TYPE_MD5_PWSLT;
7516 dgst_size = DGST_SIZE_4_4;
7517 parse_func = md5s_parse_hash;
7518 sort_by_digest = sort_by_digest_4_4;
7519 opti_type = OPTI_TYPE_ZERO_BYTE
7520 | OPTI_TYPE_PRECOMPUTE_INIT
7521 | OPTI_TYPE_PRECOMPUTE_MERKLE
7522 | OPTI_TYPE_MEET_IN_MIDDLE
7523 | OPTI_TYPE_EARLY_SKIP
7524 | OPTI_TYPE_NOT_ITERATED
7525 | OPTI_TYPE_APPENDED_SALT
7526 | OPTI_TYPE_RAW_HASH;
7527 dgst_pos0 = 0;
7528 dgst_pos1 = 3;
7529 dgst_pos2 = 2;
7530 dgst_pos3 = 1;
7531 break;
7532
7533 case 11: hash_type = HASH_TYPE_MD5;
7534 salt_type = SALT_TYPE_INTERN;
7535 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7536 opts_type = OPTS_TYPE_PT_GENERATE_LE
7537 | OPTS_TYPE_ST_ADD80
7538 | OPTS_TYPE_ST_ADDBITS14;
7539 kern_type = KERN_TYPE_MD5_PWSLT;
7540 dgst_size = DGST_SIZE_4_4;
7541 parse_func = joomla_parse_hash;
7542 sort_by_digest = sort_by_digest_4_4;
7543 opti_type = OPTI_TYPE_ZERO_BYTE
7544 | OPTI_TYPE_PRECOMPUTE_INIT
7545 | OPTI_TYPE_PRECOMPUTE_MERKLE
7546 | OPTI_TYPE_MEET_IN_MIDDLE
7547 | OPTI_TYPE_EARLY_SKIP
7548 | OPTI_TYPE_NOT_ITERATED
7549 | OPTI_TYPE_APPENDED_SALT
7550 | OPTI_TYPE_RAW_HASH;
7551 dgst_pos0 = 0;
7552 dgst_pos1 = 3;
7553 dgst_pos2 = 2;
7554 dgst_pos3 = 1;
7555 break;
7556
7557 case 12: hash_type = HASH_TYPE_MD5;
7558 salt_type = SALT_TYPE_INTERN;
7559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7560 opts_type = OPTS_TYPE_PT_GENERATE_LE
7561 | OPTS_TYPE_ST_ADD80
7562 | OPTS_TYPE_ST_ADDBITS14;
7563 kern_type = KERN_TYPE_MD5_PWSLT;
7564 dgst_size = DGST_SIZE_4_4;
7565 parse_func = postgresql_parse_hash;
7566 sort_by_digest = sort_by_digest_4_4;
7567 opti_type = OPTI_TYPE_ZERO_BYTE
7568 | OPTI_TYPE_PRECOMPUTE_INIT
7569 | OPTI_TYPE_PRECOMPUTE_MERKLE
7570 | OPTI_TYPE_MEET_IN_MIDDLE
7571 | OPTI_TYPE_EARLY_SKIP
7572 | OPTI_TYPE_NOT_ITERATED
7573 | OPTI_TYPE_APPENDED_SALT
7574 | OPTI_TYPE_RAW_HASH;
7575 dgst_pos0 = 0;
7576 dgst_pos1 = 3;
7577 dgst_pos2 = 2;
7578 dgst_pos3 = 1;
7579 break;
7580
7581 case 20: hash_type = HASH_TYPE_MD5;
7582 salt_type = SALT_TYPE_INTERN;
7583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7584 opts_type = OPTS_TYPE_PT_GENERATE_LE
7585 | OPTS_TYPE_PT_ADD80
7586 | OPTS_TYPE_PT_ADDBITS14;
7587 kern_type = KERN_TYPE_MD5_SLTPW;
7588 dgst_size = DGST_SIZE_4_4;
7589 parse_func = md5s_parse_hash;
7590 sort_by_digest = sort_by_digest_4_4;
7591 opti_type = OPTI_TYPE_ZERO_BYTE
7592 | OPTI_TYPE_PRECOMPUTE_INIT
7593 | OPTI_TYPE_PRECOMPUTE_MERKLE
7594 | OPTI_TYPE_EARLY_SKIP
7595 | OPTI_TYPE_NOT_ITERATED
7596 | OPTI_TYPE_PREPENDED_SALT
7597 | OPTI_TYPE_RAW_HASH;
7598 dgst_pos0 = 0;
7599 dgst_pos1 = 3;
7600 dgst_pos2 = 2;
7601 dgst_pos3 = 1;
7602 break;
7603
7604 case 21: hash_type = HASH_TYPE_MD5;
7605 salt_type = SALT_TYPE_INTERN;
7606 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7607 opts_type = OPTS_TYPE_PT_GENERATE_LE
7608 | OPTS_TYPE_PT_ADD80
7609 | OPTS_TYPE_PT_ADDBITS14;
7610 kern_type = KERN_TYPE_MD5_SLTPW;
7611 dgst_size = DGST_SIZE_4_4;
7612 parse_func = osc_parse_hash;
7613 sort_by_digest = sort_by_digest_4_4;
7614 opti_type = OPTI_TYPE_ZERO_BYTE
7615 | OPTI_TYPE_PRECOMPUTE_INIT
7616 | OPTI_TYPE_PRECOMPUTE_MERKLE
7617 | OPTI_TYPE_EARLY_SKIP
7618 | OPTI_TYPE_NOT_ITERATED
7619 | OPTI_TYPE_PREPENDED_SALT
7620 | OPTI_TYPE_RAW_HASH;
7621 dgst_pos0 = 0;
7622 dgst_pos1 = 3;
7623 dgst_pos2 = 2;
7624 dgst_pos3 = 1;
7625 break;
7626
7627 case 22: hash_type = HASH_TYPE_MD5;
7628 salt_type = SALT_TYPE_EMBEDDED;
7629 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7630 opts_type = OPTS_TYPE_PT_GENERATE_LE
7631 | OPTS_TYPE_PT_ADD80
7632 | OPTS_TYPE_PT_ADDBITS14;
7633 kern_type = KERN_TYPE_MD5_SLTPW;
7634 dgst_size = DGST_SIZE_4_4;
7635 parse_func = netscreen_parse_hash;
7636 sort_by_digest = sort_by_digest_4_4;
7637 opti_type = OPTI_TYPE_ZERO_BYTE
7638 | OPTI_TYPE_PRECOMPUTE_INIT
7639 | OPTI_TYPE_PRECOMPUTE_MERKLE
7640 | OPTI_TYPE_EARLY_SKIP
7641 | OPTI_TYPE_NOT_ITERATED
7642 | OPTI_TYPE_PREPENDED_SALT
7643 | OPTI_TYPE_RAW_HASH;
7644 dgst_pos0 = 0;
7645 dgst_pos1 = 3;
7646 dgst_pos2 = 2;
7647 dgst_pos3 = 1;
7648 break;
7649
7650 case 23: hash_type = HASH_TYPE_MD5;
7651 salt_type = SALT_TYPE_EMBEDDED;
7652 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7653 opts_type = OPTS_TYPE_PT_GENERATE_LE
7654 | OPTS_TYPE_PT_ADD80
7655 | OPTS_TYPE_PT_ADDBITS14;
7656 kern_type = KERN_TYPE_MD5_SLTPW;
7657 dgst_size = DGST_SIZE_4_4;
7658 parse_func = skype_parse_hash;
7659 sort_by_digest = sort_by_digest_4_4;
7660 opti_type = OPTI_TYPE_ZERO_BYTE
7661 | OPTI_TYPE_PRECOMPUTE_INIT
7662 | OPTI_TYPE_PRECOMPUTE_MERKLE
7663 | OPTI_TYPE_EARLY_SKIP
7664 | OPTI_TYPE_NOT_ITERATED
7665 | OPTI_TYPE_PREPENDED_SALT
7666 | OPTI_TYPE_RAW_HASH;
7667 dgst_pos0 = 0;
7668 dgst_pos1 = 3;
7669 dgst_pos2 = 2;
7670 dgst_pos3 = 1;
7671 break;
7672
7673 case 30: hash_type = HASH_TYPE_MD5;
7674 salt_type = SALT_TYPE_INTERN;
7675 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7676 opts_type = OPTS_TYPE_PT_GENERATE_LE
7677 | OPTS_TYPE_PT_UNICODE
7678 | OPTS_TYPE_ST_ADD80
7679 | OPTS_TYPE_ST_ADDBITS14;
7680 kern_type = KERN_TYPE_MD5_PWUSLT;
7681 dgst_size = DGST_SIZE_4_4;
7682 parse_func = md5s_parse_hash;
7683 sort_by_digest = sort_by_digest_4_4;
7684 opti_type = OPTI_TYPE_ZERO_BYTE
7685 | OPTI_TYPE_PRECOMPUTE_INIT
7686 | OPTI_TYPE_PRECOMPUTE_MERKLE
7687 | OPTI_TYPE_MEET_IN_MIDDLE
7688 | OPTI_TYPE_EARLY_SKIP
7689 | OPTI_TYPE_NOT_ITERATED
7690 | OPTI_TYPE_APPENDED_SALT
7691 | OPTI_TYPE_RAW_HASH;
7692 dgst_pos0 = 0;
7693 dgst_pos1 = 3;
7694 dgst_pos2 = 2;
7695 dgst_pos3 = 1;
7696 break;
7697
7698 case 40: hash_type = HASH_TYPE_MD5;
7699 salt_type = SALT_TYPE_INTERN;
7700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7701 opts_type = OPTS_TYPE_PT_GENERATE_LE
7702 | OPTS_TYPE_PT_ADD80
7703 | OPTS_TYPE_PT_ADDBITS14
7704 | OPTS_TYPE_PT_UNICODE;
7705 kern_type = KERN_TYPE_MD5_SLTPWU;
7706 dgst_size = DGST_SIZE_4_4;
7707 parse_func = md5s_parse_hash;
7708 sort_by_digest = sort_by_digest_4_4;
7709 opti_type = OPTI_TYPE_ZERO_BYTE
7710 | OPTI_TYPE_PRECOMPUTE_INIT
7711 | OPTI_TYPE_PRECOMPUTE_MERKLE
7712 | OPTI_TYPE_EARLY_SKIP
7713 | OPTI_TYPE_NOT_ITERATED
7714 | OPTI_TYPE_PREPENDED_SALT
7715 | OPTI_TYPE_RAW_HASH;
7716 dgst_pos0 = 0;
7717 dgst_pos1 = 3;
7718 dgst_pos2 = 2;
7719 dgst_pos3 = 1;
7720 break;
7721
7722 case 50: hash_type = HASH_TYPE_MD5;
7723 salt_type = SALT_TYPE_INTERN;
7724 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7725 opts_type = OPTS_TYPE_PT_GENERATE_LE
7726 | OPTS_TYPE_ST_ADD80
7727 | OPTS_TYPE_ST_ADDBITS14;
7728 kern_type = KERN_TYPE_HMACMD5_PW;
7729 dgst_size = DGST_SIZE_4_4;
7730 parse_func = hmacmd5_parse_hash;
7731 sort_by_digest = sort_by_digest_4_4;
7732 opti_type = OPTI_TYPE_ZERO_BYTE
7733 | OPTI_TYPE_NOT_ITERATED;
7734 dgst_pos0 = 0;
7735 dgst_pos1 = 3;
7736 dgst_pos2 = 2;
7737 dgst_pos3 = 1;
7738 break;
7739
7740 case 60: hash_type = HASH_TYPE_MD5;
7741 salt_type = SALT_TYPE_INTERN;
7742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7743 opts_type = OPTS_TYPE_PT_GENERATE_LE
7744 | OPTS_TYPE_PT_ADD80
7745 | OPTS_TYPE_PT_ADDBITS14;
7746 kern_type = KERN_TYPE_HMACMD5_SLT;
7747 dgst_size = DGST_SIZE_4_4;
7748 parse_func = hmacmd5_parse_hash;
7749 sort_by_digest = sort_by_digest_4_4;
7750 opti_type = OPTI_TYPE_ZERO_BYTE
7751 | OPTI_TYPE_NOT_ITERATED;
7752 dgst_pos0 = 0;
7753 dgst_pos1 = 3;
7754 dgst_pos2 = 2;
7755 dgst_pos3 = 1;
7756 break;
7757
7758 case 100: hash_type = HASH_TYPE_SHA1;
7759 salt_type = SALT_TYPE_NONE;
7760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7761 opts_type = OPTS_TYPE_PT_GENERATE_BE
7762 | OPTS_TYPE_PT_ADD80
7763 | OPTS_TYPE_PT_ADDBITS15;
7764 kern_type = KERN_TYPE_SHA1;
7765 dgst_size = DGST_SIZE_4_5;
7766 parse_func = sha1_parse_hash;
7767 sort_by_digest = sort_by_digest_4_5;
7768 opti_type = OPTI_TYPE_ZERO_BYTE
7769 | OPTI_TYPE_PRECOMPUTE_INIT
7770 | OPTI_TYPE_PRECOMPUTE_MERKLE
7771 | OPTI_TYPE_EARLY_SKIP
7772 | OPTI_TYPE_NOT_ITERATED
7773 | OPTI_TYPE_NOT_SALTED
7774 | OPTI_TYPE_RAW_HASH;
7775 dgst_pos0 = 3;
7776 dgst_pos1 = 4;
7777 dgst_pos2 = 2;
7778 dgst_pos3 = 1;
7779 break;
7780
7781 case 101: hash_type = HASH_TYPE_SHA1;
7782 salt_type = SALT_TYPE_NONE;
7783 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7784 opts_type = OPTS_TYPE_PT_GENERATE_BE
7785 | OPTS_TYPE_PT_ADD80
7786 | OPTS_TYPE_PT_ADDBITS15;
7787 kern_type = KERN_TYPE_SHA1;
7788 dgst_size = DGST_SIZE_4_5;
7789 parse_func = sha1b64_parse_hash;
7790 sort_by_digest = sort_by_digest_4_5;
7791 opti_type = OPTI_TYPE_ZERO_BYTE
7792 | OPTI_TYPE_PRECOMPUTE_INIT
7793 | OPTI_TYPE_PRECOMPUTE_MERKLE
7794 | OPTI_TYPE_EARLY_SKIP
7795 | OPTI_TYPE_NOT_ITERATED
7796 | OPTI_TYPE_NOT_SALTED
7797 | OPTI_TYPE_RAW_HASH;
7798 dgst_pos0 = 3;
7799 dgst_pos1 = 4;
7800 dgst_pos2 = 2;
7801 dgst_pos3 = 1;
7802 break;
7803
7804 case 110: hash_type = HASH_TYPE_SHA1;
7805 salt_type = SALT_TYPE_INTERN;
7806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7807 opts_type = OPTS_TYPE_PT_GENERATE_BE
7808 | OPTS_TYPE_ST_ADD80
7809 | OPTS_TYPE_ST_ADDBITS15;
7810 kern_type = KERN_TYPE_SHA1_PWSLT;
7811 dgst_size = DGST_SIZE_4_5;
7812 parse_func = sha1s_parse_hash;
7813 sort_by_digest = sort_by_digest_4_5;
7814 opti_type = OPTI_TYPE_ZERO_BYTE
7815 | OPTI_TYPE_PRECOMPUTE_INIT
7816 | OPTI_TYPE_PRECOMPUTE_MERKLE
7817 | OPTI_TYPE_EARLY_SKIP
7818 | OPTI_TYPE_NOT_ITERATED
7819 | OPTI_TYPE_APPENDED_SALT
7820 | OPTI_TYPE_RAW_HASH;
7821 dgst_pos0 = 3;
7822 dgst_pos1 = 4;
7823 dgst_pos2 = 2;
7824 dgst_pos3 = 1;
7825 break;
7826
7827 case 111: hash_type = HASH_TYPE_SHA1;
7828 salt_type = SALT_TYPE_EMBEDDED;
7829 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7830 opts_type = OPTS_TYPE_PT_GENERATE_BE
7831 | OPTS_TYPE_ST_ADD80
7832 | OPTS_TYPE_ST_ADDBITS15;
7833 kern_type = KERN_TYPE_SHA1_PWSLT;
7834 dgst_size = DGST_SIZE_4_5;
7835 parse_func = sha1b64s_parse_hash;
7836 sort_by_digest = sort_by_digest_4_5;
7837 opti_type = OPTI_TYPE_ZERO_BYTE
7838 | OPTI_TYPE_PRECOMPUTE_INIT
7839 | OPTI_TYPE_PRECOMPUTE_MERKLE
7840 | OPTI_TYPE_EARLY_SKIP
7841 | OPTI_TYPE_NOT_ITERATED
7842 | OPTI_TYPE_APPENDED_SALT
7843 | OPTI_TYPE_RAW_HASH;
7844 dgst_pos0 = 3;
7845 dgst_pos1 = 4;
7846 dgst_pos2 = 2;
7847 dgst_pos3 = 1;
7848 break;
7849
7850 case 112: hash_type = HASH_TYPE_SHA1;
7851 salt_type = SALT_TYPE_INTERN;
7852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7853 opts_type = OPTS_TYPE_PT_GENERATE_BE
7854 | OPTS_TYPE_ST_ADD80
7855 | OPTS_TYPE_ST_ADDBITS15
7856 | OPTS_TYPE_ST_HEX;
7857 kern_type = KERN_TYPE_SHA1_PWSLT;
7858 dgst_size = DGST_SIZE_4_5;
7859 parse_func = oracles_parse_hash;
7860 sort_by_digest = sort_by_digest_4_5;
7861 opti_type = OPTI_TYPE_ZERO_BYTE
7862 | OPTI_TYPE_PRECOMPUTE_INIT
7863 | OPTI_TYPE_PRECOMPUTE_MERKLE
7864 | OPTI_TYPE_EARLY_SKIP
7865 | OPTI_TYPE_NOT_ITERATED
7866 | OPTI_TYPE_APPENDED_SALT
7867 | OPTI_TYPE_RAW_HASH;
7868 dgst_pos0 = 3;
7869 dgst_pos1 = 4;
7870 dgst_pos2 = 2;
7871 dgst_pos3 = 1;
7872 break;
7873
7874 case 120: hash_type = HASH_TYPE_SHA1;
7875 salt_type = SALT_TYPE_INTERN;
7876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7877 opts_type = OPTS_TYPE_PT_GENERATE_BE
7878 | OPTS_TYPE_PT_ADD80
7879 | OPTS_TYPE_PT_ADDBITS15;
7880 kern_type = KERN_TYPE_SHA1_SLTPW;
7881 dgst_size = DGST_SIZE_4_5;
7882 parse_func = sha1s_parse_hash;
7883 sort_by_digest = sort_by_digest_4_5;
7884 opti_type = OPTI_TYPE_ZERO_BYTE
7885 | OPTI_TYPE_PRECOMPUTE_INIT
7886 | OPTI_TYPE_PRECOMPUTE_MERKLE
7887 | OPTI_TYPE_EARLY_SKIP
7888 | OPTI_TYPE_NOT_ITERATED
7889 | OPTI_TYPE_PREPENDED_SALT
7890 | OPTI_TYPE_RAW_HASH;
7891 dgst_pos0 = 3;
7892 dgst_pos1 = 4;
7893 dgst_pos2 = 2;
7894 dgst_pos3 = 1;
7895 break;
7896
7897 case 121: hash_type = HASH_TYPE_SHA1;
7898 salt_type = SALT_TYPE_INTERN;
7899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7900 opts_type = OPTS_TYPE_PT_GENERATE_BE
7901 | OPTS_TYPE_PT_ADD80
7902 | OPTS_TYPE_PT_ADDBITS15
7903 | OPTS_TYPE_ST_LOWER;
7904 kern_type = KERN_TYPE_SHA1_SLTPW;
7905 dgst_size = DGST_SIZE_4_5;
7906 parse_func = smf_parse_hash;
7907 sort_by_digest = sort_by_digest_4_5;
7908 opti_type = OPTI_TYPE_ZERO_BYTE
7909 | OPTI_TYPE_PRECOMPUTE_INIT
7910 | OPTI_TYPE_PRECOMPUTE_MERKLE
7911 | OPTI_TYPE_EARLY_SKIP
7912 | OPTI_TYPE_NOT_ITERATED
7913 | OPTI_TYPE_PREPENDED_SALT
7914 | OPTI_TYPE_RAW_HASH;
7915 dgst_pos0 = 3;
7916 dgst_pos1 = 4;
7917 dgst_pos2 = 2;
7918 dgst_pos3 = 1;
7919 break;
7920
7921 case 122: hash_type = HASH_TYPE_SHA1;
7922 salt_type = SALT_TYPE_EMBEDDED;
7923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7924 opts_type = OPTS_TYPE_PT_GENERATE_BE
7925 | OPTS_TYPE_PT_ADD80
7926 | OPTS_TYPE_PT_ADDBITS15
7927 | OPTS_TYPE_ST_HEX;
7928 kern_type = KERN_TYPE_SHA1_SLTPW;
7929 dgst_size = DGST_SIZE_4_5;
7930 parse_func = osx1_parse_hash;
7931 sort_by_digest = sort_by_digest_4_5;
7932 opti_type = OPTI_TYPE_ZERO_BYTE
7933 | OPTI_TYPE_PRECOMPUTE_INIT
7934 | OPTI_TYPE_PRECOMPUTE_MERKLE
7935 | OPTI_TYPE_EARLY_SKIP
7936 | OPTI_TYPE_NOT_ITERATED
7937 | OPTI_TYPE_PREPENDED_SALT
7938 | OPTI_TYPE_RAW_HASH;
7939 dgst_pos0 = 3;
7940 dgst_pos1 = 4;
7941 dgst_pos2 = 2;
7942 dgst_pos3 = 1;
7943 break;
7944
7945 case 124: hash_type = HASH_TYPE_SHA1;
7946 salt_type = SALT_TYPE_EMBEDDED;
7947 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7948 opts_type = OPTS_TYPE_PT_GENERATE_BE
7949 | OPTS_TYPE_PT_ADD80
7950 | OPTS_TYPE_PT_ADDBITS15;
7951 kern_type = KERN_TYPE_SHA1_SLTPW;
7952 dgst_size = DGST_SIZE_4_5;
7953 parse_func = djangosha1_parse_hash;
7954 sort_by_digest = sort_by_digest_4_5;
7955 opti_type = OPTI_TYPE_ZERO_BYTE
7956 | OPTI_TYPE_PRECOMPUTE_INIT
7957 | OPTI_TYPE_PRECOMPUTE_MERKLE
7958 | OPTI_TYPE_EARLY_SKIP
7959 | OPTI_TYPE_NOT_ITERATED
7960 | OPTI_TYPE_PREPENDED_SALT
7961 | OPTI_TYPE_RAW_HASH;
7962 dgst_pos0 = 3;
7963 dgst_pos1 = 4;
7964 dgst_pos2 = 2;
7965 dgst_pos3 = 1;
7966 break;
7967
7968 case 125: hash_type = HASH_TYPE_SHA1;
7969 salt_type = SALT_TYPE_EMBEDDED;
7970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7971 opts_type = OPTS_TYPE_PT_GENERATE_BE
7972 | OPTS_TYPE_PT_ADD80
7973 | OPTS_TYPE_PT_ADDBITS15
7974 | OPTS_TYPE_ST_HEX;
7975 kern_type = KERN_TYPE_SHA1_SLTPW;
7976 dgst_size = DGST_SIZE_4_5;
7977 parse_func = arubaos_parse_hash;
7978 sort_by_digest = sort_by_digest_4_5;
7979 opti_type = OPTI_TYPE_ZERO_BYTE
7980 | OPTI_TYPE_PRECOMPUTE_INIT
7981 | OPTI_TYPE_PRECOMPUTE_MERKLE
7982 | OPTI_TYPE_EARLY_SKIP
7983 | OPTI_TYPE_NOT_ITERATED
7984 | OPTI_TYPE_PREPENDED_SALT
7985 | OPTI_TYPE_RAW_HASH;
7986 dgst_pos0 = 3;
7987 dgst_pos1 = 4;
7988 dgst_pos2 = 2;
7989 dgst_pos3 = 1;
7990 break;
7991
7992 case 130: hash_type = HASH_TYPE_SHA1;
7993 salt_type = SALT_TYPE_INTERN;
7994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7995 opts_type = OPTS_TYPE_PT_GENERATE_BE
7996 | OPTS_TYPE_PT_UNICODE
7997 | OPTS_TYPE_ST_ADD80
7998 | OPTS_TYPE_ST_ADDBITS15;
7999 kern_type = KERN_TYPE_SHA1_PWUSLT;
8000 dgst_size = DGST_SIZE_4_5;
8001 parse_func = sha1s_parse_hash;
8002 sort_by_digest = sort_by_digest_4_5;
8003 opti_type = OPTI_TYPE_ZERO_BYTE
8004 | OPTI_TYPE_PRECOMPUTE_INIT
8005 | OPTI_TYPE_PRECOMPUTE_MERKLE
8006 | OPTI_TYPE_EARLY_SKIP
8007 | OPTI_TYPE_NOT_ITERATED
8008 | OPTI_TYPE_APPENDED_SALT
8009 | OPTI_TYPE_RAW_HASH;
8010 dgst_pos0 = 3;
8011 dgst_pos1 = 4;
8012 dgst_pos2 = 2;
8013 dgst_pos3 = 1;
8014 break;
8015
8016 case 131: hash_type = HASH_TYPE_SHA1;
8017 salt_type = SALT_TYPE_EMBEDDED;
8018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8019 opts_type = OPTS_TYPE_PT_GENERATE_BE
8020 | OPTS_TYPE_PT_UNICODE
8021 | OPTS_TYPE_PT_UPPER
8022 | OPTS_TYPE_ST_ADD80
8023 | OPTS_TYPE_ST_ADDBITS15
8024 | OPTS_TYPE_ST_HEX;
8025 kern_type = KERN_TYPE_SHA1_PWUSLT;
8026 dgst_size = DGST_SIZE_4_5;
8027 parse_func = mssql2000_parse_hash;
8028 sort_by_digest = sort_by_digest_4_5;
8029 opti_type = OPTI_TYPE_ZERO_BYTE
8030 | OPTI_TYPE_PRECOMPUTE_INIT
8031 | OPTI_TYPE_PRECOMPUTE_MERKLE
8032 | OPTI_TYPE_EARLY_SKIP
8033 | OPTI_TYPE_NOT_ITERATED
8034 | OPTI_TYPE_APPENDED_SALT
8035 | OPTI_TYPE_RAW_HASH;
8036 dgst_pos0 = 3;
8037 dgst_pos1 = 4;
8038 dgst_pos2 = 2;
8039 dgst_pos3 = 1;
8040 break;
8041
8042 case 132: hash_type = HASH_TYPE_SHA1;
8043 salt_type = SALT_TYPE_EMBEDDED;
8044 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8045 opts_type = OPTS_TYPE_PT_GENERATE_BE
8046 | OPTS_TYPE_PT_UNICODE
8047 | OPTS_TYPE_ST_ADD80
8048 | OPTS_TYPE_ST_ADDBITS15
8049 | OPTS_TYPE_ST_HEX;
8050 kern_type = KERN_TYPE_SHA1_PWUSLT;
8051 dgst_size = DGST_SIZE_4_5;
8052 parse_func = mssql2005_parse_hash;
8053 sort_by_digest = sort_by_digest_4_5;
8054 opti_type = OPTI_TYPE_ZERO_BYTE
8055 | OPTI_TYPE_PRECOMPUTE_INIT
8056 | OPTI_TYPE_PRECOMPUTE_MERKLE
8057 | OPTI_TYPE_EARLY_SKIP
8058 | OPTI_TYPE_NOT_ITERATED
8059 | OPTI_TYPE_APPENDED_SALT
8060 | OPTI_TYPE_RAW_HASH;
8061 dgst_pos0 = 3;
8062 dgst_pos1 = 4;
8063 dgst_pos2 = 2;
8064 dgst_pos3 = 1;
8065 break;
8066
8067 case 133: hash_type = HASH_TYPE_SHA1;
8068 salt_type = SALT_TYPE_EMBEDDED;
8069 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8070 opts_type = OPTS_TYPE_PT_GENERATE_BE
8071 | OPTS_TYPE_PT_UNICODE
8072 | OPTS_TYPE_ST_ADD80
8073 | OPTS_TYPE_ST_ADDBITS15;
8074 kern_type = KERN_TYPE_SHA1_PWUSLT;
8075 dgst_size = DGST_SIZE_4_5;
8076 parse_func = peoplesoft_parse_hash;
8077 sort_by_digest = sort_by_digest_4_5;
8078 opti_type = OPTI_TYPE_ZERO_BYTE
8079 | OPTI_TYPE_PRECOMPUTE_INIT
8080 | OPTI_TYPE_PRECOMPUTE_MERKLE
8081 | OPTI_TYPE_EARLY_SKIP
8082 | OPTI_TYPE_NOT_ITERATED
8083 | OPTI_TYPE_APPENDED_SALT
8084 | OPTI_TYPE_RAW_HASH;
8085 dgst_pos0 = 3;
8086 dgst_pos1 = 4;
8087 dgst_pos2 = 2;
8088 dgst_pos3 = 1;
8089 break;
8090
8091 case 140: hash_type = HASH_TYPE_SHA1;
8092 salt_type = SALT_TYPE_INTERN;
8093 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8094 opts_type = OPTS_TYPE_PT_GENERATE_BE
8095 | OPTS_TYPE_PT_ADD80
8096 | OPTS_TYPE_PT_ADDBITS15
8097 | OPTS_TYPE_PT_UNICODE;
8098 kern_type = KERN_TYPE_SHA1_SLTPWU;
8099 dgst_size = DGST_SIZE_4_5;
8100 parse_func = sha1s_parse_hash;
8101 sort_by_digest = sort_by_digest_4_5;
8102 opti_type = OPTI_TYPE_ZERO_BYTE
8103 | OPTI_TYPE_PRECOMPUTE_INIT
8104 | OPTI_TYPE_PRECOMPUTE_MERKLE
8105 | OPTI_TYPE_EARLY_SKIP
8106 | OPTI_TYPE_NOT_ITERATED
8107 | OPTI_TYPE_PREPENDED_SALT
8108 | OPTI_TYPE_RAW_HASH;
8109 dgst_pos0 = 3;
8110 dgst_pos1 = 4;
8111 dgst_pos2 = 2;
8112 dgst_pos3 = 1;
8113 break;
8114
8115 case 141: hash_type = HASH_TYPE_SHA1;
8116 salt_type = SALT_TYPE_EMBEDDED;
8117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8118 opts_type = OPTS_TYPE_PT_GENERATE_BE
8119 | OPTS_TYPE_PT_ADD80
8120 | OPTS_TYPE_PT_ADDBITS15
8121 | OPTS_TYPE_PT_UNICODE
8122 | OPTS_TYPE_ST_BASE64;
8123 kern_type = KERN_TYPE_SHA1_SLTPWU;
8124 dgst_size = DGST_SIZE_4_5;
8125 parse_func = episerver_parse_hash;
8126 sort_by_digest = sort_by_digest_4_5;
8127 opti_type = OPTI_TYPE_ZERO_BYTE
8128 | OPTI_TYPE_PRECOMPUTE_INIT
8129 | OPTI_TYPE_PRECOMPUTE_MERKLE
8130 | OPTI_TYPE_EARLY_SKIP
8131 | OPTI_TYPE_NOT_ITERATED
8132 | OPTI_TYPE_PREPENDED_SALT
8133 | OPTI_TYPE_RAW_HASH;
8134 dgst_pos0 = 3;
8135 dgst_pos1 = 4;
8136 dgst_pos2 = 2;
8137 dgst_pos3 = 1;
8138 break;
8139
8140 case 150: hash_type = HASH_TYPE_SHA1;
8141 salt_type = SALT_TYPE_INTERN;
8142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8143 opts_type = OPTS_TYPE_PT_GENERATE_BE
8144 | OPTS_TYPE_ST_ADD80
8145 | OPTS_TYPE_ST_ADDBITS15;
8146 kern_type = KERN_TYPE_HMACSHA1_PW;
8147 dgst_size = DGST_SIZE_4_5;
8148 parse_func = hmacsha1_parse_hash;
8149 sort_by_digest = sort_by_digest_4_5;
8150 opti_type = OPTI_TYPE_ZERO_BYTE
8151 | OPTI_TYPE_NOT_ITERATED;
8152 dgst_pos0 = 3;
8153 dgst_pos1 = 4;
8154 dgst_pos2 = 2;
8155 dgst_pos3 = 1;
8156 break;
8157
8158 case 160: hash_type = HASH_TYPE_SHA1;
8159 salt_type = SALT_TYPE_INTERN;
8160 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8161 opts_type = OPTS_TYPE_PT_GENERATE_BE
8162 | OPTS_TYPE_PT_ADD80
8163 | OPTS_TYPE_PT_ADDBITS15;
8164 kern_type = KERN_TYPE_HMACSHA1_SLT;
8165 dgst_size = DGST_SIZE_4_5;
8166 parse_func = hmacsha1_parse_hash;
8167 sort_by_digest = sort_by_digest_4_5;
8168 opti_type = OPTI_TYPE_ZERO_BYTE
8169 | OPTI_TYPE_NOT_ITERATED;
8170 dgst_pos0 = 3;
8171 dgst_pos1 = 4;
8172 dgst_pos2 = 2;
8173 dgst_pos3 = 1;
8174 break;
8175
8176 case 200: hash_type = HASH_TYPE_MYSQL;
8177 salt_type = SALT_TYPE_NONE;
8178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8179 opts_type = 0;
8180 kern_type = KERN_TYPE_MYSQL;
8181 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8182 parse_func = mysql323_parse_hash;
8183 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8184 opti_type = OPTI_TYPE_ZERO_BYTE;
8185 dgst_pos0 = 0;
8186 dgst_pos1 = 1;
8187 dgst_pos2 = 2;
8188 dgst_pos3 = 3;
8189 break;
8190
8191 case 300: hash_type = HASH_TYPE_SHA1;
8192 salt_type = SALT_TYPE_NONE;
8193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8194 opts_type = OPTS_TYPE_PT_GENERATE_BE
8195 | OPTS_TYPE_PT_ADD80
8196 | OPTS_TYPE_PT_ADDBITS15;
8197 kern_type = KERN_TYPE_MYSQL41;
8198 dgst_size = DGST_SIZE_4_5;
8199 parse_func = sha1_parse_hash;
8200 sort_by_digest = sort_by_digest_4_5;
8201 opti_type = OPTI_TYPE_ZERO_BYTE
8202 | OPTI_TYPE_PRECOMPUTE_INIT
8203 | OPTI_TYPE_PRECOMPUTE_MERKLE
8204 | OPTI_TYPE_EARLY_SKIP
8205 | OPTI_TYPE_NOT_ITERATED
8206 | OPTI_TYPE_NOT_SALTED;
8207 dgst_pos0 = 3;
8208 dgst_pos1 = 4;
8209 dgst_pos2 = 2;
8210 dgst_pos3 = 1;
8211 break;
8212
8213 case 400: hash_type = HASH_TYPE_MD5;
8214 salt_type = SALT_TYPE_EMBEDDED;
8215 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8216 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8217 kern_type = KERN_TYPE_PHPASS;
8218 dgst_size = DGST_SIZE_4_4;
8219 parse_func = phpass_parse_hash;
8220 sort_by_digest = sort_by_digest_4_4;
8221 opti_type = OPTI_TYPE_ZERO_BYTE
8222 | OPTI_TYPE_SLOW_HASH_SIMD;
8223 dgst_pos0 = 0;
8224 dgst_pos1 = 1;
8225 dgst_pos2 = 2;
8226 dgst_pos3 = 3;
8227 break;
8228
8229 case 500: hash_type = HASH_TYPE_MD5;
8230 salt_type = SALT_TYPE_EMBEDDED;
8231 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8232 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8233 kern_type = KERN_TYPE_MD5CRYPT;
8234 dgst_size = DGST_SIZE_4_4;
8235 parse_func = md5crypt_parse_hash;
8236 sort_by_digest = sort_by_digest_4_4;
8237 opti_type = OPTI_TYPE_ZERO_BYTE;
8238 dgst_pos0 = 0;
8239 dgst_pos1 = 1;
8240 dgst_pos2 = 2;
8241 dgst_pos3 = 3;
8242 break;
8243
8244 case 501: hash_type = HASH_TYPE_MD5;
8245 salt_type = SALT_TYPE_EMBEDDED;
8246 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8247 opts_type = OPTS_TYPE_PT_GENERATE_LE
8248 | OPTS_TYPE_HASH_COPY;
8249 kern_type = KERN_TYPE_MD5CRYPT;
8250 dgst_size = DGST_SIZE_4_4;
8251 parse_func = juniper_parse_hash;
8252 sort_by_digest = sort_by_digest_4_4;
8253 opti_type = OPTI_TYPE_ZERO_BYTE;
8254 dgst_pos0 = 0;
8255 dgst_pos1 = 1;
8256 dgst_pos2 = 2;
8257 dgst_pos3 = 3;
8258 break;
8259
8260 case 900: hash_type = HASH_TYPE_MD4;
8261 salt_type = SALT_TYPE_NONE;
8262 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8263 opts_type = OPTS_TYPE_PT_GENERATE_LE
8264 | OPTS_TYPE_PT_ADD80
8265 | OPTS_TYPE_PT_ADDBITS14;
8266 kern_type = KERN_TYPE_MD4;
8267 dgst_size = DGST_SIZE_4_4;
8268 parse_func = md4_parse_hash;
8269 sort_by_digest = sort_by_digest_4_4;
8270 opti_type = OPTI_TYPE_ZERO_BYTE
8271 | OPTI_TYPE_PRECOMPUTE_INIT
8272 | OPTI_TYPE_PRECOMPUTE_MERKLE
8273 | OPTI_TYPE_MEET_IN_MIDDLE
8274 | OPTI_TYPE_EARLY_SKIP
8275 | OPTI_TYPE_NOT_ITERATED
8276 | OPTI_TYPE_NOT_SALTED
8277 | OPTI_TYPE_RAW_HASH;
8278 dgst_pos0 = 0;
8279 dgst_pos1 = 3;
8280 dgst_pos2 = 2;
8281 dgst_pos3 = 1;
8282 break;
8283
8284 case 1000: hash_type = HASH_TYPE_MD4;
8285 salt_type = SALT_TYPE_NONE;
8286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8287 opts_type = OPTS_TYPE_PT_GENERATE_LE
8288 | OPTS_TYPE_PT_ADD80
8289 | OPTS_TYPE_PT_ADDBITS14
8290 | OPTS_TYPE_PT_UNICODE;
8291 kern_type = KERN_TYPE_MD4_PWU;
8292 dgst_size = DGST_SIZE_4_4;
8293 parse_func = md4_parse_hash;
8294 sort_by_digest = sort_by_digest_4_4;
8295 opti_type = OPTI_TYPE_ZERO_BYTE
8296 | OPTI_TYPE_PRECOMPUTE_INIT
8297 | OPTI_TYPE_PRECOMPUTE_MERKLE
8298 | OPTI_TYPE_MEET_IN_MIDDLE
8299 | OPTI_TYPE_EARLY_SKIP
8300 | OPTI_TYPE_NOT_ITERATED
8301 | OPTI_TYPE_NOT_SALTED
8302 | OPTI_TYPE_RAW_HASH;
8303 dgst_pos0 = 0;
8304 dgst_pos1 = 3;
8305 dgst_pos2 = 2;
8306 dgst_pos3 = 1;
8307 break;
8308
8309 case 1100: hash_type = HASH_TYPE_MD4;
8310 salt_type = SALT_TYPE_INTERN;
8311 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8312 opts_type = OPTS_TYPE_PT_GENERATE_LE
8313 | OPTS_TYPE_PT_ADD80
8314 | OPTS_TYPE_PT_ADDBITS14
8315 | OPTS_TYPE_PT_UNICODE
8316 | OPTS_TYPE_ST_ADD80
8317 | OPTS_TYPE_ST_UNICODE
8318 | OPTS_TYPE_ST_LOWER;
8319 kern_type = KERN_TYPE_MD44_PWUSLT;
8320 dgst_size = DGST_SIZE_4_4;
8321 parse_func = dcc_parse_hash;
8322 sort_by_digest = sort_by_digest_4_4;
8323 opti_type = OPTI_TYPE_ZERO_BYTE
8324 | OPTI_TYPE_PRECOMPUTE_INIT
8325 | OPTI_TYPE_PRECOMPUTE_MERKLE
8326 | OPTI_TYPE_EARLY_SKIP
8327 | OPTI_TYPE_NOT_ITERATED;
8328 dgst_pos0 = 0;
8329 dgst_pos1 = 3;
8330 dgst_pos2 = 2;
8331 dgst_pos3 = 1;
8332 break;
8333
8334 case 1400: hash_type = HASH_TYPE_SHA256;
8335 salt_type = SALT_TYPE_NONE;
8336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8337 opts_type = OPTS_TYPE_PT_GENERATE_BE
8338 | OPTS_TYPE_PT_ADD80
8339 | OPTS_TYPE_PT_ADDBITS15;
8340 kern_type = KERN_TYPE_SHA256;
8341 dgst_size = DGST_SIZE_4_8;
8342 parse_func = sha256_parse_hash;
8343 sort_by_digest = sort_by_digest_4_8;
8344 opti_type = OPTI_TYPE_ZERO_BYTE
8345 | OPTI_TYPE_PRECOMPUTE_INIT
8346 | OPTI_TYPE_PRECOMPUTE_MERKLE
8347 | OPTI_TYPE_EARLY_SKIP
8348 | OPTI_TYPE_NOT_ITERATED
8349 | OPTI_TYPE_NOT_SALTED
8350 | OPTI_TYPE_RAW_HASH;
8351 dgst_pos0 = 3;
8352 dgst_pos1 = 7;
8353 dgst_pos2 = 2;
8354 dgst_pos3 = 6;
8355 break;
8356
8357 case 1410: hash_type = HASH_TYPE_SHA256;
8358 salt_type = SALT_TYPE_INTERN;
8359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8360 opts_type = OPTS_TYPE_PT_GENERATE_BE
8361 | OPTS_TYPE_ST_ADD80
8362 | OPTS_TYPE_ST_ADDBITS15;
8363 kern_type = KERN_TYPE_SHA256_PWSLT;
8364 dgst_size = DGST_SIZE_4_8;
8365 parse_func = sha256s_parse_hash;
8366 sort_by_digest = sort_by_digest_4_8;
8367 opti_type = OPTI_TYPE_ZERO_BYTE
8368 | OPTI_TYPE_PRECOMPUTE_INIT
8369 | OPTI_TYPE_PRECOMPUTE_MERKLE
8370 | OPTI_TYPE_EARLY_SKIP
8371 | OPTI_TYPE_NOT_ITERATED
8372 | OPTI_TYPE_APPENDED_SALT
8373 | OPTI_TYPE_RAW_HASH;
8374 dgst_pos0 = 3;
8375 dgst_pos1 = 7;
8376 dgst_pos2 = 2;
8377 dgst_pos3 = 6;
8378 break;
8379
8380 case 1420: hash_type = HASH_TYPE_SHA256;
8381 salt_type = SALT_TYPE_INTERN;
8382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8383 opts_type = OPTS_TYPE_PT_GENERATE_BE
8384 | OPTS_TYPE_PT_ADD80
8385 | OPTS_TYPE_PT_ADDBITS15;
8386 kern_type = KERN_TYPE_SHA256_SLTPW;
8387 dgst_size = DGST_SIZE_4_8;
8388 parse_func = sha256s_parse_hash;
8389 sort_by_digest = sort_by_digest_4_8;
8390 opti_type = OPTI_TYPE_ZERO_BYTE
8391 | OPTI_TYPE_PRECOMPUTE_INIT
8392 | OPTI_TYPE_PRECOMPUTE_MERKLE
8393 | OPTI_TYPE_EARLY_SKIP
8394 | OPTI_TYPE_NOT_ITERATED
8395 | OPTI_TYPE_PREPENDED_SALT
8396 | OPTI_TYPE_RAW_HASH;
8397 dgst_pos0 = 3;
8398 dgst_pos1 = 7;
8399 dgst_pos2 = 2;
8400 dgst_pos3 = 6;
8401 break;
8402
8403 case 1421: hash_type = HASH_TYPE_SHA256;
8404 salt_type = SALT_TYPE_EMBEDDED;
8405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8406 opts_type = OPTS_TYPE_PT_GENERATE_BE
8407 | OPTS_TYPE_PT_ADD80
8408 | OPTS_TYPE_PT_ADDBITS15;
8409 kern_type = KERN_TYPE_SHA256_SLTPW;
8410 dgst_size = DGST_SIZE_4_8;
8411 parse_func = hmailserver_parse_hash;
8412 sort_by_digest = sort_by_digest_4_8;
8413 opti_type = OPTI_TYPE_ZERO_BYTE
8414 | OPTI_TYPE_PRECOMPUTE_INIT
8415 | OPTI_TYPE_PRECOMPUTE_MERKLE
8416 | OPTI_TYPE_EARLY_SKIP
8417 | OPTI_TYPE_NOT_ITERATED
8418 | OPTI_TYPE_PREPENDED_SALT
8419 | OPTI_TYPE_RAW_HASH;
8420 dgst_pos0 = 3;
8421 dgst_pos1 = 7;
8422 dgst_pos2 = 2;
8423 dgst_pos3 = 6;
8424 break;
8425
8426 case 1430: hash_type = HASH_TYPE_SHA256;
8427 salt_type = SALT_TYPE_INTERN;
8428 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8429 opts_type = OPTS_TYPE_PT_GENERATE_BE
8430 | OPTS_TYPE_PT_UNICODE
8431 | OPTS_TYPE_ST_ADD80
8432 | OPTS_TYPE_ST_ADDBITS15;
8433 kern_type = KERN_TYPE_SHA256_PWUSLT;
8434 dgst_size = DGST_SIZE_4_8;
8435 parse_func = sha256s_parse_hash;
8436 sort_by_digest = sort_by_digest_4_8;
8437 opti_type = OPTI_TYPE_ZERO_BYTE
8438 | OPTI_TYPE_PRECOMPUTE_INIT
8439 | OPTI_TYPE_PRECOMPUTE_MERKLE
8440 | OPTI_TYPE_EARLY_SKIP
8441 | OPTI_TYPE_NOT_ITERATED
8442 | OPTI_TYPE_APPENDED_SALT
8443 | OPTI_TYPE_RAW_HASH;
8444 dgst_pos0 = 3;
8445 dgst_pos1 = 7;
8446 dgst_pos2 = 2;
8447 dgst_pos3 = 6;
8448 break;
8449
8450 case 1440: hash_type = HASH_TYPE_SHA256;
8451 salt_type = SALT_TYPE_INTERN;
8452 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8453 opts_type = OPTS_TYPE_PT_GENERATE_BE
8454 | OPTS_TYPE_PT_ADD80
8455 | OPTS_TYPE_PT_ADDBITS15
8456 | OPTS_TYPE_PT_UNICODE;
8457 kern_type = KERN_TYPE_SHA256_SLTPWU;
8458 dgst_size = DGST_SIZE_4_8;
8459 parse_func = sha256s_parse_hash;
8460 sort_by_digest = sort_by_digest_4_8;
8461 opti_type = OPTI_TYPE_ZERO_BYTE
8462 | OPTI_TYPE_PRECOMPUTE_INIT
8463 | OPTI_TYPE_PRECOMPUTE_MERKLE
8464 | OPTI_TYPE_EARLY_SKIP
8465 | OPTI_TYPE_NOT_ITERATED
8466 | OPTI_TYPE_PREPENDED_SALT
8467 | OPTI_TYPE_RAW_HASH;
8468 dgst_pos0 = 3;
8469 dgst_pos1 = 7;
8470 dgst_pos2 = 2;
8471 dgst_pos3 = 6;
8472 break;
8473
8474 case 1441: hash_type = HASH_TYPE_SHA256;
8475 salt_type = SALT_TYPE_EMBEDDED;
8476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8477 opts_type = OPTS_TYPE_PT_GENERATE_BE
8478 | OPTS_TYPE_PT_ADD80
8479 | OPTS_TYPE_PT_ADDBITS15
8480 | OPTS_TYPE_PT_UNICODE
8481 | OPTS_TYPE_ST_BASE64;
8482 kern_type = KERN_TYPE_SHA256_SLTPWU;
8483 dgst_size = DGST_SIZE_4_8;
8484 parse_func = episerver4_parse_hash;
8485 sort_by_digest = sort_by_digest_4_8;
8486 opti_type = OPTI_TYPE_ZERO_BYTE
8487 | OPTI_TYPE_PRECOMPUTE_INIT
8488 | OPTI_TYPE_PRECOMPUTE_MERKLE
8489 | OPTI_TYPE_EARLY_SKIP
8490 | OPTI_TYPE_NOT_ITERATED
8491 | OPTI_TYPE_PREPENDED_SALT
8492 | OPTI_TYPE_RAW_HASH;
8493 dgst_pos0 = 3;
8494 dgst_pos1 = 7;
8495 dgst_pos2 = 2;
8496 dgst_pos3 = 6;
8497 break;
8498
8499 case 1450: hash_type = HASH_TYPE_SHA256;
8500 salt_type = SALT_TYPE_INTERN;
8501 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8502 opts_type = OPTS_TYPE_PT_GENERATE_BE
8503 | OPTS_TYPE_ST_ADD80;
8504 kern_type = KERN_TYPE_HMACSHA256_PW;
8505 dgst_size = DGST_SIZE_4_8;
8506 parse_func = hmacsha256_parse_hash;
8507 sort_by_digest = sort_by_digest_4_8;
8508 opti_type = OPTI_TYPE_ZERO_BYTE
8509 | OPTI_TYPE_NOT_ITERATED;
8510 dgst_pos0 = 3;
8511 dgst_pos1 = 7;
8512 dgst_pos2 = 2;
8513 dgst_pos3 = 6;
8514 break;
8515
8516 case 1460: hash_type = HASH_TYPE_SHA256;
8517 salt_type = SALT_TYPE_INTERN;
8518 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8519 opts_type = OPTS_TYPE_PT_GENERATE_BE
8520 | OPTS_TYPE_PT_ADD80
8521 | OPTS_TYPE_PT_ADDBITS15;
8522 kern_type = KERN_TYPE_HMACSHA256_SLT;
8523 dgst_size = DGST_SIZE_4_8;
8524 parse_func = hmacsha256_parse_hash;
8525 sort_by_digest = sort_by_digest_4_8;
8526 opti_type = OPTI_TYPE_ZERO_BYTE
8527 | OPTI_TYPE_NOT_ITERATED;
8528 dgst_pos0 = 3;
8529 dgst_pos1 = 7;
8530 dgst_pos2 = 2;
8531 dgst_pos3 = 6;
8532 break;
8533
8534 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8535 salt_type = SALT_TYPE_EMBEDDED;
8536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8537 opts_type = OPTS_TYPE_PT_GENERATE_LE
8538 | OPTS_TYPE_PT_BITSLICE;
8539 kern_type = KERN_TYPE_DESCRYPT;
8540 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8541 parse_func = descrypt_parse_hash;
8542 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8543 opti_type = OPTI_TYPE_ZERO_BYTE
8544 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8545 dgst_pos0 = 0;
8546 dgst_pos1 = 1;
8547 dgst_pos2 = 2;
8548 dgst_pos3 = 3;
8549 break;
8550
8551 case 1600: hash_type = HASH_TYPE_MD5;
8552 salt_type = SALT_TYPE_EMBEDDED;
8553 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8554 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8555 kern_type = KERN_TYPE_APR1CRYPT;
8556 dgst_size = DGST_SIZE_4_4;
8557 parse_func = md5apr1_parse_hash;
8558 sort_by_digest = sort_by_digest_4_4;
8559 opti_type = OPTI_TYPE_ZERO_BYTE;
8560 dgst_pos0 = 0;
8561 dgst_pos1 = 1;
8562 dgst_pos2 = 2;
8563 dgst_pos3 = 3;
8564 break;
8565
8566 case 1700: hash_type = HASH_TYPE_SHA512;
8567 salt_type = SALT_TYPE_NONE;
8568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8569 opts_type = OPTS_TYPE_PT_GENERATE_BE
8570 | OPTS_TYPE_PT_ADD80
8571 | OPTS_TYPE_PT_ADDBITS15;
8572 kern_type = KERN_TYPE_SHA512;
8573 dgst_size = DGST_SIZE_8_8;
8574 parse_func = sha512_parse_hash;
8575 sort_by_digest = sort_by_digest_8_8;
8576 opti_type = OPTI_TYPE_ZERO_BYTE
8577 | OPTI_TYPE_PRECOMPUTE_INIT
8578 | OPTI_TYPE_PRECOMPUTE_MERKLE
8579 | OPTI_TYPE_EARLY_SKIP
8580 | OPTI_TYPE_NOT_ITERATED
8581 | OPTI_TYPE_NOT_SALTED
8582 | OPTI_TYPE_USES_BITS_64
8583 | OPTI_TYPE_RAW_HASH;
8584 dgst_pos0 = 14;
8585 dgst_pos1 = 15;
8586 dgst_pos2 = 6;
8587 dgst_pos3 = 7;
8588 break;
8589
8590 case 1710: hash_type = HASH_TYPE_SHA512;
8591 salt_type = SALT_TYPE_INTERN;
8592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8593 opts_type = OPTS_TYPE_PT_GENERATE_BE
8594 | OPTS_TYPE_ST_ADD80
8595 | OPTS_TYPE_ST_ADDBITS15;
8596 kern_type = KERN_TYPE_SHA512_PWSLT;
8597 dgst_size = DGST_SIZE_8_8;
8598 parse_func = sha512s_parse_hash;
8599 sort_by_digest = sort_by_digest_8_8;
8600 opti_type = OPTI_TYPE_ZERO_BYTE
8601 | OPTI_TYPE_PRECOMPUTE_INIT
8602 | OPTI_TYPE_PRECOMPUTE_MERKLE
8603 | OPTI_TYPE_EARLY_SKIP
8604 | OPTI_TYPE_NOT_ITERATED
8605 | OPTI_TYPE_APPENDED_SALT
8606 | OPTI_TYPE_USES_BITS_64
8607 | OPTI_TYPE_RAW_HASH;
8608 dgst_pos0 = 14;
8609 dgst_pos1 = 15;
8610 dgst_pos2 = 6;
8611 dgst_pos3 = 7;
8612 break;
8613
8614 case 1711: hash_type = HASH_TYPE_SHA512;
8615 salt_type = SALT_TYPE_EMBEDDED;
8616 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8617 opts_type = OPTS_TYPE_PT_GENERATE_BE
8618 | OPTS_TYPE_ST_ADD80
8619 | OPTS_TYPE_ST_ADDBITS15;
8620 kern_type = KERN_TYPE_SHA512_PWSLT;
8621 dgst_size = DGST_SIZE_8_8;
8622 parse_func = sha512b64s_parse_hash;
8623 sort_by_digest = sort_by_digest_8_8;
8624 opti_type = OPTI_TYPE_ZERO_BYTE
8625 | OPTI_TYPE_PRECOMPUTE_INIT
8626 | OPTI_TYPE_PRECOMPUTE_MERKLE
8627 | OPTI_TYPE_EARLY_SKIP
8628 | OPTI_TYPE_NOT_ITERATED
8629 | OPTI_TYPE_APPENDED_SALT
8630 | OPTI_TYPE_USES_BITS_64
8631 | OPTI_TYPE_RAW_HASH;
8632 dgst_pos0 = 14;
8633 dgst_pos1 = 15;
8634 dgst_pos2 = 6;
8635 dgst_pos3 = 7;
8636 break;
8637
8638 case 1720: hash_type = HASH_TYPE_SHA512;
8639 salt_type = SALT_TYPE_INTERN;
8640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8641 opts_type = OPTS_TYPE_PT_GENERATE_BE
8642 | OPTS_TYPE_PT_ADD80
8643 | OPTS_TYPE_PT_ADDBITS15;
8644 kern_type = KERN_TYPE_SHA512_SLTPW;
8645 dgst_size = DGST_SIZE_8_8;
8646 parse_func = sha512s_parse_hash;
8647 sort_by_digest = sort_by_digest_8_8;
8648 opti_type = OPTI_TYPE_ZERO_BYTE
8649 | OPTI_TYPE_PRECOMPUTE_INIT
8650 | OPTI_TYPE_PRECOMPUTE_MERKLE
8651 | OPTI_TYPE_EARLY_SKIP
8652 | OPTI_TYPE_NOT_ITERATED
8653 | OPTI_TYPE_PREPENDED_SALT
8654 | OPTI_TYPE_USES_BITS_64
8655 | OPTI_TYPE_RAW_HASH;
8656 dgst_pos0 = 14;
8657 dgst_pos1 = 15;
8658 dgst_pos2 = 6;
8659 dgst_pos3 = 7;
8660 break;
8661
8662 case 1722: hash_type = HASH_TYPE_SHA512;
8663 salt_type = SALT_TYPE_EMBEDDED;
8664 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8665 opts_type = OPTS_TYPE_PT_GENERATE_BE
8666 | OPTS_TYPE_PT_ADD80
8667 | OPTS_TYPE_PT_ADDBITS15
8668 | OPTS_TYPE_ST_HEX;
8669 kern_type = KERN_TYPE_SHA512_SLTPW;
8670 dgst_size = DGST_SIZE_8_8;
8671 parse_func = osx512_parse_hash;
8672 sort_by_digest = sort_by_digest_8_8;
8673 opti_type = OPTI_TYPE_ZERO_BYTE
8674 | OPTI_TYPE_PRECOMPUTE_INIT
8675 | OPTI_TYPE_PRECOMPUTE_MERKLE
8676 | OPTI_TYPE_EARLY_SKIP
8677 | OPTI_TYPE_NOT_ITERATED
8678 | OPTI_TYPE_PREPENDED_SALT
8679 | OPTI_TYPE_USES_BITS_64
8680 | OPTI_TYPE_RAW_HASH;
8681 dgst_pos0 = 14;
8682 dgst_pos1 = 15;
8683 dgst_pos2 = 6;
8684 dgst_pos3 = 7;
8685 break;
8686
8687 case 1730: hash_type = HASH_TYPE_SHA512;
8688 salt_type = SALT_TYPE_INTERN;
8689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8690 opts_type = OPTS_TYPE_PT_GENERATE_BE
8691 | OPTS_TYPE_PT_UNICODE
8692 | OPTS_TYPE_ST_ADD80
8693 | OPTS_TYPE_ST_ADDBITS15;
8694 kern_type = KERN_TYPE_SHA512_PWSLTU;
8695 dgst_size = DGST_SIZE_8_8;
8696 parse_func = sha512s_parse_hash;
8697 sort_by_digest = sort_by_digest_8_8;
8698 opti_type = OPTI_TYPE_ZERO_BYTE
8699 | OPTI_TYPE_PRECOMPUTE_INIT
8700 | OPTI_TYPE_PRECOMPUTE_MERKLE
8701 | OPTI_TYPE_EARLY_SKIP
8702 | OPTI_TYPE_NOT_ITERATED
8703 | OPTI_TYPE_APPENDED_SALT
8704 | OPTI_TYPE_USES_BITS_64
8705 | OPTI_TYPE_RAW_HASH;
8706 dgst_pos0 = 14;
8707 dgst_pos1 = 15;
8708 dgst_pos2 = 6;
8709 dgst_pos3 = 7;
8710 break;
8711
8712 case 1731: hash_type = HASH_TYPE_SHA512;
8713 salt_type = SALT_TYPE_EMBEDDED;
8714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8715 opts_type = OPTS_TYPE_PT_GENERATE_BE
8716 | OPTS_TYPE_PT_UNICODE
8717 | OPTS_TYPE_ST_ADD80
8718 | OPTS_TYPE_ST_ADDBITS15
8719 | OPTS_TYPE_ST_HEX;
8720 kern_type = KERN_TYPE_SHA512_PWSLTU;
8721 dgst_size = DGST_SIZE_8_8;
8722 parse_func = mssql2012_parse_hash;
8723 sort_by_digest = sort_by_digest_8_8;
8724 opti_type = OPTI_TYPE_ZERO_BYTE
8725 | OPTI_TYPE_PRECOMPUTE_INIT
8726 | OPTI_TYPE_PRECOMPUTE_MERKLE
8727 | OPTI_TYPE_EARLY_SKIP
8728 | OPTI_TYPE_NOT_ITERATED
8729 | OPTI_TYPE_APPENDED_SALT
8730 | OPTI_TYPE_USES_BITS_64
8731 | OPTI_TYPE_RAW_HASH;
8732 dgst_pos0 = 14;
8733 dgst_pos1 = 15;
8734 dgst_pos2 = 6;
8735 dgst_pos3 = 7;
8736 break;
8737
8738 case 1740: hash_type = HASH_TYPE_SHA512;
8739 salt_type = SALT_TYPE_INTERN;
8740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8741 opts_type = OPTS_TYPE_PT_GENERATE_BE
8742 | OPTS_TYPE_PT_ADD80
8743 | OPTS_TYPE_PT_ADDBITS15
8744 | OPTS_TYPE_PT_UNICODE;
8745 kern_type = KERN_TYPE_SHA512_SLTPWU;
8746 dgst_size = DGST_SIZE_8_8;
8747 parse_func = sha512s_parse_hash;
8748 sort_by_digest = sort_by_digest_8_8;
8749 opti_type = OPTI_TYPE_ZERO_BYTE
8750 | OPTI_TYPE_PRECOMPUTE_INIT
8751 | OPTI_TYPE_PRECOMPUTE_MERKLE
8752 | OPTI_TYPE_EARLY_SKIP
8753 | OPTI_TYPE_NOT_ITERATED
8754 | OPTI_TYPE_PREPENDED_SALT
8755 | OPTI_TYPE_USES_BITS_64
8756 | OPTI_TYPE_RAW_HASH;
8757 dgst_pos0 = 14;
8758 dgst_pos1 = 15;
8759 dgst_pos2 = 6;
8760 dgst_pos3 = 7;
8761 break;
8762
8763 case 1750: hash_type = HASH_TYPE_SHA512;
8764 salt_type = SALT_TYPE_INTERN;
8765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8766 opts_type = OPTS_TYPE_PT_GENERATE_BE
8767 | OPTS_TYPE_ST_ADD80;
8768 kern_type = KERN_TYPE_HMACSHA512_PW;
8769 dgst_size = DGST_SIZE_8_8;
8770 parse_func = hmacsha512_parse_hash;
8771 sort_by_digest = sort_by_digest_8_8;
8772 opti_type = OPTI_TYPE_ZERO_BYTE
8773 | OPTI_TYPE_USES_BITS_64
8774 | OPTI_TYPE_NOT_ITERATED;
8775 dgst_pos0 = 14;
8776 dgst_pos1 = 15;
8777 dgst_pos2 = 6;
8778 dgst_pos3 = 7;
8779 break;
8780
8781 case 1760: hash_type = HASH_TYPE_SHA512;
8782 salt_type = SALT_TYPE_INTERN;
8783 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8784 opts_type = OPTS_TYPE_PT_GENERATE_BE
8785 | OPTS_TYPE_PT_ADD80
8786 | OPTS_TYPE_PT_ADDBITS15;
8787 kern_type = KERN_TYPE_HMACSHA512_SLT;
8788 dgst_size = DGST_SIZE_8_8;
8789 parse_func = hmacsha512_parse_hash;
8790 sort_by_digest = sort_by_digest_8_8;
8791 opti_type = OPTI_TYPE_ZERO_BYTE
8792 | OPTI_TYPE_USES_BITS_64
8793 | OPTI_TYPE_NOT_ITERATED;
8794 dgst_pos0 = 14;
8795 dgst_pos1 = 15;
8796 dgst_pos2 = 6;
8797 dgst_pos3 = 7;
8798 break;
8799
8800 case 1800: hash_type = HASH_TYPE_SHA512;
8801 salt_type = SALT_TYPE_EMBEDDED;
8802 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8803 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8804 kern_type = KERN_TYPE_SHA512CRYPT;
8805 dgst_size = DGST_SIZE_8_8;
8806 parse_func = sha512crypt_parse_hash;
8807 sort_by_digest = sort_by_digest_8_8;
8808 opti_type = OPTI_TYPE_ZERO_BYTE
8809 | OPTI_TYPE_USES_BITS_64;
8810 dgst_pos0 = 0;
8811 dgst_pos1 = 1;
8812 dgst_pos2 = 2;
8813 dgst_pos3 = 3;
8814 break;
8815
8816 case 2000: hash_type = HASH_TYPE_STDOUT;
8817 salt_type = SALT_TYPE_NONE;
8818 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8819 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8820 kern_type = KERN_TYPE_STDOUT;
8821 dgst_size = DGST_SIZE_4_4;
8822 parse_func = NULL;
8823 sort_by_digest = NULL;
8824 opti_type = 0;
8825 dgst_pos0 = 0;
8826 dgst_pos1 = 0;
8827 dgst_pos2 = 0;
8828 dgst_pos3 = 0;
8829 break;
8830
8831 case 2100: hash_type = HASH_TYPE_DCC2;
8832 salt_type = SALT_TYPE_EMBEDDED;
8833 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8834 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8835 | OPTS_TYPE_ST_LOWER
8836 | OPTS_TYPE_ST_UNICODE;
8837 kern_type = KERN_TYPE_DCC2;
8838 dgst_size = DGST_SIZE_4_4;
8839 parse_func = dcc2_parse_hash;
8840 sort_by_digest = sort_by_digest_4_4;
8841 opti_type = OPTI_TYPE_ZERO_BYTE
8842 | OPTI_TYPE_SLOW_HASH_SIMD;
8843 dgst_pos0 = 0;
8844 dgst_pos1 = 1;
8845 dgst_pos2 = 2;
8846 dgst_pos3 = 3;
8847 break;
8848
8849 case 2400: hash_type = HASH_TYPE_MD5;
8850 salt_type = SALT_TYPE_NONE;
8851 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8852 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8853 kern_type = KERN_TYPE_MD5PIX;
8854 dgst_size = DGST_SIZE_4_4;
8855 parse_func = md5pix_parse_hash;
8856 sort_by_digest = sort_by_digest_4_4;
8857 opti_type = OPTI_TYPE_ZERO_BYTE
8858 | OPTI_TYPE_PRECOMPUTE_INIT
8859 | OPTI_TYPE_PRECOMPUTE_MERKLE
8860 | OPTI_TYPE_EARLY_SKIP
8861 | OPTI_TYPE_NOT_ITERATED
8862 | OPTI_TYPE_NOT_SALTED;
8863 dgst_pos0 = 0;
8864 dgst_pos1 = 3;
8865 dgst_pos2 = 2;
8866 dgst_pos3 = 1;
8867 break;
8868
8869 case 2410: hash_type = HASH_TYPE_MD5;
8870 salt_type = SALT_TYPE_INTERN;
8871 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8872 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8873 kern_type = KERN_TYPE_MD5ASA;
8874 dgst_size = DGST_SIZE_4_4;
8875 parse_func = md5asa_parse_hash;
8876 sort_by_digest = sort_by_digest_4_4;
8877 opti_type = OPTI_TYPE_ZERO_BYTE
8878 | OPTI_TYPE_PRECOMPUTE_INIT
8879 | OPTI_TYPE_PRECOMPUTE_MERKLE
8880 | OPTI_TYPE_EARLY_SKIP
8881 | OPTI_TYPE_NOT_ITERATED;
8882 dgst_pos0 = 0;
8883 dgst_pos1 = 3;
8884 dgst_pos2 = 2;
8885 dgst_pos3 = 1;
8886 break;
8887
8888 case 2500: hash_type = HASH_TYPE_WPA;
8889 salt_type = SALT_TYPE_EMBEDDED;
8890 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8891 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8892 kern_type = KERN_TYPE_WPA;
8893 dgst_size = DGST_SIZE_4_4;
8894 parse_func = wpa_parse_hash;
8895 sort_by_digest = sort_by_digest_4_4;
8896 opti_type = OPTI_TYPE_ZERO_BYTE
8897 | OPTI_TYPE_SLOW_HASH_SIMD;
8898 dgst_pos0 = 0;
8899 dgst_pos1 = 1;
8900 dgst_pos2 = 2;
8901 dgst_pos3 = 3;
8902 break;
8903
8904 case 2600: hash_type = HASH_TYPE_MD5;
8905 salt_type = SALT_TYPE_VIRTUAL;
8906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8907 opts_type = OPTS_TYPE_PT_GENERATE_LE
8908 | OPTS_TYPE_PT_ADD80
8909 | OPTS_TYPE_PT_ADDBITS14
8910 | OPTS_TYPE_ST_ADD80;
8911 kern_type = KERN_TYPE_MD55_PWSLT1;
8912 dgst_size = DGST_SIZE_4_4;
8913 parse_func = md5md5_parse_hash;
8914 sort_by_digest = sort_by_digest_4_4;
8915 opti_type = OPTI_TYPE_ZERO_BYTE
8916 | OPTI_TYPE_PRECOMPUTE_INIT
8917 | OPTI_TYPE_PRECOMPUTE_MERKLE
8918 | OPTI_TYPE_EARLY_SKIP;
8919 dgst_pos0 = 0;
8920 dgst_pos1 = 3;
8921 dgst_pos2 = 2;
8922 dgst_pos3 = 1;
8923 break;
8924
8925 case 2611: hash_type = HASH_TYPE_MD5;
8926 salt_type = SALT_TYPE_INTERN;
8927 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8928 opts_type = OPTS_TYPE_PT_GENERATE_LE
8929 | OPTS_TYPE_PT_ADD80
8930 | OPTS_TYPE_PT_ADDBITS14
8931 | OPTS_TYPE_ST_ADD80;
8932 kern_type = KERN_TYPE_MD55_PWSLT1;
8933 dgst_size = DGST_SIZE_4_4;
8934 parse_func = vb3_parse_hash;
8935 sort_by_digest = sort_by_digest_4_4;
8936 opti_type = OPTI_TYPE_ZERO_BYTE
8937 | OPTI_TYPE_PRECOMPUTE_INIT
8938 | OPTI_TYPE_PRECOMPUTE_MERKLE
8939 | OPTI_TYPE_EARLY_SKIP;
8940 dgst_pos0 = 0;
8941 dgst_pos1 = 3;
8942 dgst_pos2 = 2;
8943 dgst_pos3 = 1;
8944 break;
8945
8946 case 2612: hash_type = HASH_TYPE_MD5;
8947 salt_type = SALT_TYPE_EMBEDDED;
8948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8949 opts_type = OPTS_TYPE_PT_GENERATE_LE
8950 | OPTS_TYPE_PT_ADD80
8951 | OPTS_TYPE_PT_ADDBITS14
8952 | OPTS_TYPE_ST_ADD80
8953 | OPTS_TYPE_ST_HEX;
8954 kern_type = KERN_TYPE_MD55_PWSLT1;
8955 dgst_size = DGST_SIZE_4_4;
8956 parse_func = phps_parse_hash;
8957 sort_by_digest = sort_by_digest_4_4;
8958 opti_type = OPTI_TYPE_ZERO_BYTE
8959 | OPTI_TYPE_PRECOMPUTE_INIT
8960 | OPTI_TYPE_PRECOMPUTE_MERKLE
8961 | OPTI_TYPE_EARLY_SKIP;
8962 dgst_pos0 = 0;
8963 dgst_pos1 = 3;
8964 dgst_pos2 = 2;
8965 dgst_pos3 = 1;
8966 break;
8967
8968 case 2711: hash_type = HASH_TYPE_MD5;
8969 salt_type = SALT_TYPE_INTERN;
8970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8971 opts_type = OPTS_TYPE_PT_GENERATE_LE
8972 | OPTS_TYPE_PT_ADD80
8973 | OPTS_TYPE_PT_ADDBITS14
8974 | OPTS_TYPE_ST_ADD80;
8975 kern_type = KERN_TYPE_MD55_PWSLT2;
8976 dgst_size = DGST_SIZE_4_4;
8977 parse_func = vb30_parse_hash;
8978 sort_by_digest = sort_by_digest_4_4;
8979 opti_type = OPTI_TYPE_ZERO_BYTE
8980 | OPTI_TYPE_PRECOMPUTE_INIT
8981 | OPTI_TYPE_EARLY_SKIP;
8982 dgst_pos0 = 0;
8983 dgst_pos1 = 3;
8984 dgst_pos2 = 2;
8985 dgst_pos3 = 1;
8986 break;
8987
8988 case 2811: hash_type = HASH_TYPE_MD5;
8989 salt_type = SALT_TYPE_INTERN;
8990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8991 opts_type = OPTS_TYPE_PT_GENERATE_LE
8992 | OPTS_TYPE_PT_ADD80
8993 | OPTS_TYPE_PT_ADDBITS14;
8994 kern_type = KERN_TYPE_MD55_SLTPW;
8995 dgst_size = DGST_SIZE_4_4;
8996 parse_func = ipb2_parse_hash;
8997 sort_by_digest = sort_by_digest_4_4;
8998 opti_type = OPTI_TYPE_ZERO_BYTE
8999 | OPTI_TYPE_PRECOMPUTE_INIT
9000 | OPTI_TYPE_EARLY_SKIP;
9001 dgst_pos0 = 0;
9002 dgst_pos1 = 3;
9003 dgst_pos2 = 2;
9004 dgst_pos3 = 1;
9005 break;
9006
9007 case 3000: hash_type = HASH_TYPE_LM;
9008 salt_type = SALT_TYPE_NONE;
9009 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9010 opts_type = OPTS_TYPE_PT_GENERATE_LE
9011 | OPTS_TYPE_PT_UPPER
9012 | OPTS_TYPE_PT_BITSLICE;
9013 kern_type = KERN_TYPE_LM;
9014 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9015 parse_func = lm_parse_hash;
9016 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9017 opti_type = OPTI_TYPE_ZERO_BYTE
9018 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9019 dgst_pos0 = 0;
9020 dgst_pos1 = 1;
9021 dgst_pos2 = 2;
9022 dgst_pos3 = 3;
9023 break;
9024
9025 case 3100: hash_type = HASH_TYPE_ORACLEH;
9026 salt_type = SALT_TYPE_INTERN;
9027 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9028 opts_type = OPTS_TYPE_PT_GENERATE_LE
9029 | OPTS_TYPE_PT_UPPER
9030 | OPTS_TYPE_ST_UPPER;
9031 kern_type = KERN_TYPE_ORACLEH;
9032 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9033 parse_func = oracleh_parse_hash;
9034 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9035 opti_type = OPTI_TYPE_ZERO_BYTE;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 3200: hash_type = HASH_TYPE_BCRYPT;
9043 salt_type = SALT_TYPE_EMBEDDED;
9044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9045 opts_type = OPTS_TYPE_PT_GENERATE_LE
9046 | OPTS_TYPE_ST_GENERATE_LE;
9047 kern_type = KERN_TYPE_BCRYPT;
9048 dgst_size = DGST_SIZE_4_6;
9049 parse_func = bcrypt_parse_hash;
9050 sort_by_digest = sort_by_digest_4_6;
9051 opti_type = OPTI_TYPE_ZERO_BYTE;
9052 dgst_pos0 = 0;
9053 dgst_pos1 = 1;
9054 dgst_pos2 = 2;
9055 dgst_pos3 = 3;
9056 break;
9057
9058 case 3710: hash_type = HASH_TYPE_MD5;
9059 salt_type = SALT_TYPE_INTERN;
9060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9061 opts_type = OPTS_TYPE_PT_GENERATE_LE
9062 | OPTS_TYPE_PT_ADD80
9063 | OPTS_TYPE_PT_ADDBITS14;
9064 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9065 dgst_size = DGST_SIZE_4_4;
9066 parse_func = md5s_parse_hash;
9067 sort_by_digest = sort_by_digest_4_4;
9068 opti_type = OPTI_TYPE_ZERO_BYTE
9069 | OPTI_TYPE_PRECOMPUTE_INIT
9070 | OPTI_TYPE_PRECOMPUTE_MERKLE
9071 | OPTI_TYPE_EARLY_SKIP;
9072 dgst_pos0 = 0;
9073 dgst_pos1 = 3;
9074 dgst_pos2 = 2;
9075 dgst_pos3 = 1;
9076 break;
9077
9078 case 3711: hash_type = HASH_TYPE_MD5;
9079 salt_type = SALT_TYPE_EMBEDDED;
9080 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9081 opts_type = OPTS_TYPE_PT_GENERATE_LE
9082 | OPTS_TYPE_PT_ADD80
9083 | OPTS_TYPE_PT_ADDBITS14;
9084 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9085 dgst_size = DGST_SIZE_4_4;
9086 parse_func = mediawiki_b_parse_hash;
9087 sort_by_digest = sort_by_digest_4_4;
9088 opti_type = OPTI_TYPE_ZERO_BYTE
9089 | OPTI_TYPE_PRECOMPUTE_INIT
9090 | OPTI_TYPE_PRECOMPUTE_MERKLE
9091 | OPTI_TYPE_EARLY_SKIP;
9092 dgst_pos0 = 0;
9093 dgst_pos1 = 3;
9094 dgst_pos2 = 2;
9095 dgst_pos3 = 1;
9096 break;
9097
9098 case 3800: hash_type = HASH_TYPE_MD5;
9099 salt_type = SALT_TYPE_INTERN;
9100 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9101 opts_type = OPTS_TYPE_PT_GENERATE_LE
9102 | OPTS_TYPE_ST_ADDBITS14;
9103 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9104 dgst_size = DGST_SIZE_4_4;
9105 parse_func = md5s_parse_hash;
9106 sort_by_digest = sort_by_digest_4_4;
9107 opti_type = OPTI_TYPE_ZERO_BYTE
9108 | OPTI_TYPE_PRECOMPUTE_INIT
9109 | OPTI_TYPE_PRECOMPUTE_MERKLE
9110 | OPTI_TYPE_EARLY_SKIP
9111 | OPTI_TYPE_NOT_ITERATED
9112 | OPTI_TYPE_RAW_HASH;
9113 dgst_pos0 = 0;
9114 dgst_pos1 = 3;
9115 dgst_pos2 = 2;
9116 dgst_pos3 = 1;
9117 break;
9118
9119 case 4300: hash_type = HASH_TYPE_MD5;
9120 salt_type = SALT_TYPE_VIRTUAL;
9121 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9122 opts_type = OPTS_TYPE_PT_GENERATE_LE
9123 | OPTS_TYPE_PT_ADD80
9124 | OPTS_TYPE_PT_ADDBITS14
9125 | OPTS_TYPE_ST_ADD80;
9126 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9127 dgst_size = DGST_SIZE_4_4;
9128 parse_func = md5md5_parse_hash;
9129 sort_by_digest = sort_by_digest_4_4;
9130 opti_type = OPTI_TYPE_ZERO_BYTE
9131 | OPTI_TYPE_PRECOMPUTE_INIT
9132 | OPTI_TYPE_PRECOMPUTE_MERKLE
9133 | OPTI_TYPE_EARLY_SKIP;
9134 dgst_pos0 = 0;
9135 dgst_pos1 = 3;
9136 dgst_pos2 = 2;
9137 dgst_pos3 = 1;
9138 break;
9139
9140
9141 case 4400: hash_type = HASH_TYPE_MD5;
9142 salt_type = SALT_TYPE_NONE;
9143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9144 opts_type = OPTS_TYPE_PT_GENERATE_BE
9145 | OPTS_TYPE_PT_ADD80
9146 | OPTS_TYPE_PT_ADDBITS15;
9147 kern_type = KERN_TYPE_MD5_SHA1;
9148 dgst_size = DGST_SIZE_4_4;
9149 parse_func = md5_parse_hash;
9150 sort_by_digest = sort_by_digest_4_4;
9151 opti_type = OPTI_TYPE_ZERO_BYTE
9152 | OPTI_TYPE_PRECOMPUTE_INIT
9153 | OPTI_TYPE_PRECOMPUTE_MERKLE
9154 | OPTI_TYPE_EARLY_SKIP
9155 | OPTI_TYPE_NOT_ITERATED
9156 | OPTI_TYPE_NOT_SALTED
9157 | OPTI_TYPE_RAW_HASH;
9158 dgst_pos0 = 0;
9159 dgst_pos1 = 3;
9160 dgst_pos2 = 2;
9161 dgst_pos3 = 1;
9162 break;
9163
9164 case 4500: hash_type = HASH_TYPE_SHA1;
9165 salt_type = SALT_TYPE_NONE;
9166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9167 opts_type = OPTS_TYPE_PT_GENERATE_BE
9168 | OPTS_TYPE_PT_ADD80
9169 | OPTS_TYPE_PT_ADDBITS15;
9170 kern_type = KERN_TYPE_SHA11;
9171 dgst_size = DGST_SIZE_4_5;
9172 parse_func = sha1_parse_hash;
9173 sort_by_digest = sort_by_digest_4_5;
9174 opti_type = OPTI_TYPE_ZERO_BYTE
9175 | OPTI_TYPE_PRECOMPUTE_INIT
9176 | OPTI_TYPE_PRECOMPUTE_MERKLE
9177 | OPTI_TYPE_EARLY_SKIP
9178 | OPTI_TYPE_NOT_SALTED;
9179 dgst_pos0 = 3;
9180 dgst_pos1 = 4;
9181 dgst_pos2 = 2;
9182 dgst_pos3 = 1;
9183 break;
9184
9185 case 4700: hash_type = HASH_TYPE_SHA1;
9186 salt_type = SALT_TYPE_NONE;
9187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9188 opts_type = OPTS_TYPE_PT_GENERATE_LE
9189 | OPTS_TYPE_PT_ADD80
9190 | OPTS_TYPE_PT_ADDBITS14;
9191 kern_type = KERN_TYPE_SHA1_MD5;
9192 dgst_size = DGST_SIZE_4_5;
9193 parse_func = sha1_parse_hash;
9194 sort_by_digest = sort_by_digest_4_5;
9195 opti_type = OPTI_TYPE_ZERO_BYTE
9196 | OPTI_TYPE_PRECOMPUTE_INIT
9197 | OPTI_TYPE_PRECOMPUTE_MERKLE
9198 | OPTI_TYPE_EARLY_SKIP
9199 | OPTI_TYPE_NOT_ITERATED
9200 | OPTI_TYPE_NOT_SALTED
9201 | OPTI_TYPE_RAW_HASH;
9202 dgst_pos0 = 3;
9203 dgst_pos1 = 4;
9204 dgst_pos2 = 2;
9205 dgst_pos3 = 1;
9206 break;
9207
9208 case 4800: hash_type = HASH_TYPE_MD5;
9209 salt_type = SALT_TYPE_EMBEDDED;
9210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9211 opts_type = OPTS_TYPE_PT_GENERATE_LE
9212 | OPTS_TYPE_PT_ADDBITS14;
9213 kern_type = KERN_TYPE_MD5_CHAP;
9214 dgst_size = DGST_SIZE_4_4;
9215 parse_func = chap_parse_hash;
9216 sort_by_digest = sort_by_digest_4_4;
9217 opti_type = OPTI_TYPE_ZERO_BYTE
9218 | OPTI_TYPE_PRECOMPUTE_INIT
9219 | OPTI_TYPE_PRECOMPUTE_MERKLE
9220 | OPTI_TYPE_MEET_IN_MIDDLE
9221 | OPTI_TYPE_EARLY_SKIP
9222 | OPTI_TYPE_NOT_ITERATED
9223 | OPTI_TYPE_RAW_HASH;
9224 dgst_pos0 = 0;
9225 dgst_pos1 = 3;
9226 dgst_pos2 = 2;
9227 dgst_pos3 = 1;
9228 break;
9229
9230 case 4900: hash_type = HASH_TYPE_SHA1;
9231 salt_type = SALT_TYPE_INTERN;
9232 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9233 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9234 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9235 dgst_size = DGST_SIZE_4_5;
9236 parse_func = sha1s_parse_hash;
9237 sort_by_digest = sort_by_digest_4_5;
9238 opti_type = OPTI_TYPE_ZERO_BYTE
9239 | OPTI_TYPE_PRECOMPUTE_INIT
9240 | OPTI_TYPE_PRECOMPUTE_MERKLE
9241 | OPTI_TYPE_EARLY_SKIP;
9242 dgst_pos0 = 3;
9243 dgst_pos1 = 4;
9244 dgst_pos2 = 2;
9245 dgst_pos3 = 1;
9246 break;
9247
9248 case 5000: hash_type = HASH_TYPE_KECCAK;
9249 salt_type = SALT_TYPE_EMBEDDED;
9250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9251 opts_type = OPTS_TYPE_PT_GENERATE_LE
9252 | OPTS_TYPE_PT_ADD01;
9253 kern_type = KERN_TYPE_KECCAK;
9254 dgst_size = DGST_SIZE_8_25;
9255 parse_func = keccak_parse_hash;
9256 sort_by_digest = sort_by_digest_8_25;
9257 opti_type = OPTI_TYPE_ZERO_BYTE
9258 | OPTI_TYPE_USES_BITS_64
9259 | OPTI_TYPE_RAW_HASH;
9260 dgst_pos0 = 2;
9261 dgst_pos1 = 3;
9262 dgst_pos2 = 4;
9263 dgst_pos3 = 5;
9264 break;
9265
9266 case 5100: hash_type = HASH_TYPE_MD5H;
9267 salt_type = SALT_TYPE_NONE;
9268 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9269 opts_type = OPTS_TYPE_PT_GENERATE_LE
9270 | OPTS_TYPE_PT_ADD80
9271 | OPTS_TYPE_PT_ADDBITS14;
9272 kern_type = KERN_TYPE_MD5H;
9273 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9274 parse_func = md5half_parse_hash;
9275 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9276 opti_type = OPTI_TYPE_ZERO_BYTE
9277 | OPTI_TYPE_RAW_HASH;
9278 dgst_pos0 = 0;
9279 dgst_pos1 = 1;
9280 dgst_pos2 = 2;
9281 dgst_pos3 = 3;
9282 break;
9283
9284 case 5200: hash_type = HASH_TYPE_SHA256;
9285 salt_type = SALT_TYPE_EMBEDDED;
9286 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9287 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9288 kern_type = KERN_TYPE_PSAFE3;
9289 dgst_size = DGST_SIZE_4_8;
9290 parse_func = psafe3_parse_hash;
9291 sort_by_digest = sort_by_digest_4_8;
9292 opti_type = OPTI_TYPE_ZERO_BYTE;
9293 dgst_pos0 = 0;
9294 dgst_pos1 = 1;
9295 dgst_pos2 = 2;
9296 dgst_pos3 = 3;
9297 break;
9298
9299 case 5300: hash_type = HASH_TYPE_MD5;
9300 salt_type = SALT_TYPE_EMBEDDED;
9301 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9302 opts_type = OPTS_TYPE_PT_GENERATE_LE
9303 | OPTS_TYPE_ST_ADD80;
9304 kern_type = KERN_TYPE_IKEPSK_MD5;
9305 dgst_size = DGST_SIZE_4_4;
9306 parse_func = ikepsk_md5_parse_hash;
9307 sort_by_digest = sort_by_digest_4_4;
9308 opti_type = OPTI_TYPE_ZERO_BYTE;
9309 dgst_pos0 = 0;
9310 dgst_pos1 = 3;
9311 dgst_pos2 = 2;
9312 dgst_pos3 = 1;
9313 break;
9314
9315 case 5400: hash_type = HASH_TYPE_SHA1;
9316 salt_type = SALT_TYPE_EMBEDDED;
9317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9318 opts_type = OPTS_TYPE_PT_GENERATE_BE
9319 | OPTS_TYPE_ST_ADD80;
9320 kern_type = KERN_TYPE_IKEPSK_SHA1;
9321 dgst_size = DGST_SIZE_4_5;
9322 parse_func = ikepsk_sha1_parse_hash;
9323 sort_by_digest = sort_by_digest_4_5;
9324 opti_type = OPTI_TYPE_ZERO_BYTE;
9325 dgst_pos0 = 3;
9326 dgst_pos1 = 4;
9327 dgst_pos2 = 2;
9328 dgst_pos3 = 1;
9329 break;
9330
9331 case 5500: hash_type = HASH_TYPE_NETNTLM;
9332 salt_type = SALT_TYPE_EMBEDDED;
9333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9334 opts_type = OPTS_TYPE_PT_GENERATE_LE
9335 | OPTS_TYPE_PT_ADD80
9336 | OPTS_TYPE_PT_ADDBITS14
9337 | OPTS_TYPE_PT_UNICODE
9338 | OPTS_TYPE_ST_HEX;
9339 kern_type = KERN_TYPE_NETNTLMv1;
9340 dgst_size = DGST_SIZE_4_4;
9341 parse_func = netntlmv1_parse_hash;
9342 sort_by_digest = sort_by_digest_4_4;
9343 opti_type = OPTI_TYPE_ZERO_BYTE
9344 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9345 dgst_pos0 = 0;
9346 dgst_pos1 = 1;
9347 dgst_pos2 = 2;
9348 dgst_pos3 = 3;
9349 break;
9350
9351 case 5600: hash_type = HASH_TYPE_MD5;
9352 salt_type = SALT_TYPE_EMBEDDED;
9353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9354 opts_type = OPTS_TYPE_PT_GENERATE_LE
9355 | OPTS_TYPE_PT_ADD80
9356 | OPTS_TYPE_PT_ADDBITS14
9357 | OPTS_TYPE_PT_UNICODE;
9358 kern_type = KERN_TYPE_NETNTLMv2;
9359 dgst_size = DGST_SIZE_4_4;
9360 parse_func = netntlmv2_parse_hash;
9361 sort_by_digest = sort_by_digest_4_4;
9362 opti_type = OPTI_TYPE_ZERO_BYTE;
9363 dgst_pos0 = 0;
9364 dgst_pos1 = 3;
9365 dgst_pos2 = 2;
9366 dgst_pos3 = 1;
9367 break;
9368
9369 case 5700: hash_type = HASH_TYPE_SHA256;
9370 salt_type = SALT_TYPE_NONE;
9371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9372 opts_type = OPTS_TYPE_PT_GENERATE_BE
9373 | OPTS_TYPE_PT_ADD80
9374 | OPTS_TYPE_PT_ADDBITS15;
9375 kern_type = KERN_TYPE_SHA256;
9376 dgst_size = DGST_SIZE_4_8;
9377 parse_func = cisco4_parse_hash;
9378 sort_by_digest = sort_by_digest_4_8;
9379 opti_type = OPTI_TYPE_ZERO_BYTE
9380 | OPTI_TYPE_PRECOMPUTE_INIT
9381 | OPTI_TYPE_PRECOMPUTE_MERKLE
9382 | OPTI_TYPE_EARLY_SKIP
9383 | OPTI_TYPE_NOT_ITERATED
9384 | OPTI_TYPE_NOT_SALTED
9385 | OPTI_TYPE_RAW_HASH;
9386 dgst_pos0 = 3;
9387 dgst_pos1 = 7;
9388 dgst_pos2 = 2;
9389 dgst_pos3 = 6;
9390 break;
9391
9392 case 5800: hash_type = HASH_TYPE_SHA1;
9393 salt_type = SALT_TYPE_INTERN;
9394 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9395 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9396 | OPTS_TYPE_ST_ADD80;
9397 kern_type = KERN_TYPE_ANDROIDPIN;
9398 dgst_size = DGST_SIZE_4_5;
9399 parse_func = androidpin_parse_hash;
9400 sort_by_digest = sort_by_digest_4_5;
9401 opti_type = OPTI_TYPE_ZERO_BYTE;
9402 dgst_pos0 = 0;
9403 dgst_pos1 = 1;
9404 dgst_pos2 = 2;
9405 dgst_pos3 = 3;
9406 break;
9407
9408 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9409 salt_type = SALT_TYPE_NONE;
9410 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9411 opts_type = OPTS_TYPE_PT_GENERATE_LE
9412 | OPTS_TYPE_PT_ADD80;
9413 kern_type = KERN_TYPE_RIPEMD160;
9414 dgst_size = DGST_SIZE_4_5;
9415 parse_func = ripemd160_parse_hash;
9416 sort_by_digest = sort_by_digest_4_5;
9417 opti_type = OPTI_TYPE_ZERO_BYTE;
9418 dgst_pos0 = 0;
9419 dgst_pos1 = 1;
9420 dgst_pos2 = 2;
9421 dgst_pos3 = 3;
9422 break;
9423
9424 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9425 salt_type = SALT_TYPE_NONE;
9426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9427 opts_type = OPTS_TYPE_PT_GENERATE_BE
9428 | OPTS_TYPE_PT_ADD80;
9429 kern_type = KERN_TYPE_WHIRLPOOL;
9430 dgst_size = DGST_SIZE_4_16;
9431 parse_func = whirlpool_parse_hash;
9432 sort_by_digest = sort_by_digest_4_16;
9433 opti_type = OPTI_TYPE_ZERO_BYTE;
9434 dgst_pos0 = 0;
9435 dgst_pos1 = 1;
9436 dgst_pos2 = 2;
9437 dgst_pos3 = 3;
9438 break;
9439
9440 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9441 salt_type = SALT_TYPE_EMBEDDED;
9442 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9443 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9444 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9445 dgst_size = DGST_SIZE_4_5;
9446 parse_func = truecrypt_parse_hash_2k;
9447 sort_by_digest = sort_by_digest_4_5;
9448 opti_type = OPTI_TYPE_ZERO_BYTE;
9449 dgst_pos0 = 0;
9450 dgst_pos1 = 1;
9451 dgst_pos2 = 2;
9452 dgst_pos3 = 3;
9453 break;
9454
9455 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9456 salt_type = SALT_TYPE_EMBEDDED;
9457 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9458 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9459 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9460 dgst_size = DGST_SIZE_4_5;
9461 parse_func = truecrypt_parse_hash_2k;
9462 sort_by_digest = sort_by_digest_4_5;
9463 opti_type = OPTI_TYPE_ZERO_BYTE;
9464 dgst_pos0 = 0;
9465 dgst_pos1 = 1;
9466 dgst_pos2 = 2;
9467 dgst_pos3 = 3;
9468 break;
9469
9470 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9471 salt_type = SALT_TYPE_EMBEDDED;
9472 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9473 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9474 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9475 dgst_size = DGST_SIZE_4_5;
9476 parse_func = truecrypt_parse_hash_2k;
9477 sort_by_digest = sort_by_digest_4_5;
9478 opti_type = OPTI_TYPE_ZERO_BYTE;
9479 dgst_pos0 = 0;
9480 dgst_pos1 = 1;
9481 dgst_pos2 = 2;
9482 dgst_pos3 = 3;
9483 break;
9484
9485 case 6221: hash_type = HASH_TYPE_SHA512;
9486 salt_type = SALT_TYPE_EMBEDDED;
9487 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9488 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9489 kern_type = KERN_TYPE_TCSHA512_XTS512;
9490 dgst_size = DGST_SIZE_8_8;
9491 parse_func = truecrypt_parse_hash_1k;
9492 sort_by_digest = sort_by_digest_8_8;
9493 opti_type = OPTI_TYPE_ZERO_BYTE
9494 | OPTI_TYPE_USES_BITS_64;
9495 dgst_pos0 = 0;
9496 dgst_pos1 = 1;
9497 dgst_pos2 = 2;
9498 dgst_pos3 = 3;
9499 break;
9500
9501 case 6222: hash_type = HASH_TYPE_SHA512;
9502 salt_type = SALT_TYPE_EMBEDDED;
9503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9504 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9505 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9506 dgst_size = DGST_SIZE_8_8;
9507 parse_func = truecrypt_parse_hash_1k;
9508 sort_by_digest = sort_by_digest_8_8;
9509 opti_type = OPTI_TYPE_ZERO_BYTE
9510 | OPTI_TYPE_USES_BITS_64;
9511 dgst_pos0 = 0;
9512 dgst_pos1 = 1;
9513 dgst_pos2 = 2;
9514 dgst_pos3 = 3;
9515 break;
9516
9517 case 6223: hash_type = HASH_TYPE_SHA512;
9518 salt_type = SALT_TYPE_EMBEDDED;
9519 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9520 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9521 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9522 dgst_size = DGST_SIZE_8_8;
9523 parse_func = truecrypt_parse_hash_1k;
9524 sort_by_digest = sort_by_digest_8_8;
9525 opti_type = OPTI_TYPE_ZERO_BYTE
9526 | OPTI_TYPE_USES_BITS_64;
9527 dgst_pos0 = 0;
9528 dgst_pos1 = 1;
9529 dgst_pos2 = 2;
9530 dgst_pos3 = 3;
9531 break;
9532
9533 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9534 salt_type = SALT_TYPE_EMBEDDED;
9535 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9536 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9537 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9538 dgst_size = DGST_SIZE_4_8;
9539 parse_func = truecrypt_parse_hash_1k;
9540 sort_by_digest = sort_by_digest_4_8;
9541 opti_type = OPTI_TYPE_ZERO_BYTE;
9542 dgst_pos0 = 0;
9543 dgst_pos1 = 1;
9544 dgst_pos2 = 2;
9545 dgst_pos3 = 3;
9546 break;
9547
9548 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9549 salt_type = SALT_TYPE_EMBEDDED;
9550 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9551 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9552 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9553 dgst_size = DGST_SIZE_4_8;
9554 parse_func = truecrypt_parse_hash_1k;
9555 sort_by_digest = sort_by_digest_4_8;
9556 opti_type = OPTI_TYPE_ZERO_BYTE;
9557 dgst_pos0 = 0;
9558 dgst_pos1 = 1;
9559 dgst_pos2 = 2;
9560 dgst_pos3 = 3;
9561 break;
9562
9563 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9564 salt_type = SALT_TYPE_EMBEDDED;
9565 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9566 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9567 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9568 dgst_size = DGST_SIZE_4_8;
9569 parse_func = truecrypt_parse_hash_1k;
9570 sort_by_digest = sort_by_digest_4_8;
9571 opti_type = OPTI_TYPE_ZERO_BYTE;
9572 dgst_pos0 = 0;
9573 dgst_pos1 = 1;
9574 dgst_pos2 = 2;
9575 dgst_pos3 = 3;
9576 break;
9577
9578 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9579 salt_type = SALT_TYPE_EMBEDDED;
9580 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9581 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9582 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9583 dgst_size = DGST_SIZE_4_5;
9584 parse_func = truecrypt_parse_hash_1k;
9585 sort_by_digest = sort_by_digest_4_5;
9586 opti_type = OPTI_TYPE_ZERO_BYTE;
9587 dgst_pos0 = 0;
9588 dgst_pos1 = 1;
9589 dgst_pos2 = 2;
9590 dgst_pos3 = 3;
9591 break;
9592
9593 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9594 salt_type = SALT_TYPE_EMBEDDED;
9595 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9596 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9597 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9598 dgst_size = DGST_SIZE_4_5;
9599 parse_func = truecrypt_parse_hash_1k;
9600 sort_by_digest = sort_by_digest_4_5;
9601 opti_type = OPTI_TYPE_ZERO_BYTE;
9602 dgst_pos0 = 0;
9603 dgst_pos1 = 1;
9604 dgst_pos2 = 2;
9605 dgst_pos3 = 3;
9606 break;
9607
9608 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9609 salt_type = SALT_TYPE_EMBEDDED;
9610 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9611 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9612 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9613 dgst_size = DGST_SIZE_4_5;
9614 parse_func = truecrypt_parse_hash_1k;
9615 sort_by_digest = sort_by_digest_4_5;
9616 opti_type = OPTI_TYPE_ZERO_BYTE;
9617 dgst_pos0 = 0;
9618 dgst_pos1 = 1;
9619 dgst_pos2 = 2;
9620 dgst_pos3 = 3;
9621 break;
9622
9623 case 6300: hash_type = HASH_TYPE_MD5;
9624 salt_type = SALT_TYPE_EMBEDDED;
9625 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9626 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9627 kern_type = KERN_TYPE_MD5AIX;
9628 dgst_size = DGST_SIZE_4_4;
9629 parse_func = md5aix_parse_hash;
9630 sort_by_digest = sort_by_digest_4_4;
9631 opti_type = OPTI_TYPE_ZERO_BYTE;
9632 dgst_pos0 = 0;
9633 dgst_pos1 = 1;
9634 dgst_pos2 = 2;
9635 dgst_pos3 = 3;
9636 break;
9637
9638 case 6400: hash_type = HASH_TYPE_SHA256;
9639 salt_type = SALT_TYPE_EMBEDDED;
9640 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9641 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9642 kern_type = KERN_TYPE_SHA256AIX;
9643 dgst_size = DGST_SIZE_4_8;
9644 parse_func = sha256aix_parse_hash;
9645 sort_by_digest = sort_by_digest_4_8;
9646 opti_type = OPTI_TYPE_ZERO_BYTE;
9647 dgst_pos0 = 0;
9648 dgst_pos1 = 1;
9649 dgst_pos2 = 2;
9650 dgst_pos3 = 3;
9651 break;
9652
9653 case 6500: hash_type = HASH_TYPE_SHA512;
9654 salt_type = SALT_TYPE_EMBEDDED;
9655 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9656 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9657 kern_type = KERN_TYPE_SHA512AIX;
9658 dgst_size = DGST_SIZE_8_8;
9659 parse_func = sha512aix_parse_hash;
9660 sort_by_digest = sort_by_digest_8_8;
9661 opti_type = OPTI_TYPE_ZERO_BYTE
9662 | OPTI_TYPE_USES_BITS_64;
9663 dgst_pos0 = 0;
9664 dgst_pos1 = 1;
9665 dgst_pos2 = 2;
9666 dgst_pos3 = 3;
9667 break;
9668
9669 case 6600: hash_type = HASH_TYPE_AES;
9670 salt_type = SALT_TYPE_EMBEDDED;
9671 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9672 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9673 kern_type = KERN_TYPE_AGILEKEY;
9674 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9675 parse_func = agilekey_parse_hash;
9676 sort_by_digest = sort_by_digest_4_5;
9677 opti_type = OPTI_TYPE_ZERO_BYTE;
9678 dgst_pos0 = 0;
9679 dgst_pos1 = 1;
9680 dgst_pos2 = 2;
9681 dgst_pos3 = 3;
9682 break;
9683
9684 case 6700: hash_type = HASH_TYPE_SHA1;
9685 salt_type = SALT_TYPE_EMBEDDED;
9686 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9687 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9688 kern_type = KERN_TYPE_SHA1AIX;
9689 dgst_size = DGST_SIZE_4_5;
9690 parse_func = sha1aix_parse_hash;
9691 sort_by_digest = sort_by_digest_4_5;
9692 opti_type = OPTI_TYPE_ZERO_BYTE;
9693 dgst_pos0 = 0;
9694 dgst_pos1 = 1;
9695 dgst_pos2 = 2;
9696 dgst_pos3 = 3;
9697 break;
9698
9699 case 6800: hash_type = HASH_TYPE_AES;
9700 salt_type = SALT_TYPE_EMBEDDED;
9701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9702 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9703 kern_type = KERN_TYPE_LASTPASS;
9704 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9705 parse_func = lastpass_parse_hash;
9706 sort_by_digest = sort_by_digest_4_8;
9707 opti_type = OPTI_TYPE_ZERO_BYTE;
9708 dgst_pos0 = 0;
9709 dgst_pos1 = 1;
9710 dgst_pos2 = 2;
9711 dgst_pos3 = 3;
9712 break;
9713
9714 case 6900: hash_type = HASH_TYPE_GOST;
9715 salt_type = SALT_TYPE_NONE;
9716 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9717 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9718 kern_type = KERN_TYPE_GOST;
9719 dgst_size = DGST_SIZE_4_8;
9720 parse_func = gost_parse_hash;
9721 sort_by_digest = sort_by_digest_4_8;
9722 opti_type = OPTI_TYPE_ZERO_BYTE;
9723 dgst_pos0 = 0;
9724 dgst_pos1 = 1;
9725 dgst_pos2 = 2;
9726 dgst_pos3 = 3;
9727 break;
9728
9729 case 7100: hash_type = HASH_TYPE_SHA512;
9730 salt_type = SALT_TYPE_EMBEDDED;
9731 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9732 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9733 kern_type = KERN_TYPE_PBKDF2_SHA512;
9734 dgst_size = DGST_SIZE_8_16;
9735 parse_func = sha512osx_parse_hash;
9736 sort_by_digest = sort_by_digest_8_16;
9737 opti_type = OPTI_TYPE_ZERO_BYTE
9738 | OPTI_TYPE_USES_BITS_64
9739 | OPTI_TYPE_SLOW_HASH_SIMD;
9740 dgst_pos0 = 0;
9741 dgst_pos1 = 1;
9742 dgst_pos2 = 2;
9743 dgst_pos3 = 3;
9744 break;
9745
9746 case 7200: hash_type = HASH_TYPE_SHA512;
9747 salt_type = SALT_TYPE_EMBEDDED;
9748 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9749 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9750 kern_type = KERN_TYPE_PBKDF2_SHA512;
9751 dgst_size = DGST_SIZE_8_16;
9752 parse_func = sha512grub_parse_hash;
9753 sort_by_digest = sort_by_digest_8_16;
9754 opti_type = OPTI_TYPE_ZERO_BYTE
9755 | OPTI_TYPE_USES_BITS_64
9756 | OPTI_TYPE_SLOW_HASH_SIMD;
9757 dgst_pos0 = 0;
9758 dgst_pos1 = 1;
9759 dgst_pos2 = 2;
9760 dgst_pos3 = 3;
9761 break;
9762
9763 case 7300: hash_type = HASH_TYPE_SHA1;
9764 salt_type = SALT_TYPE_EMBEDDED;
9765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9766 opts_type = OPTS_TYPE_PT_GENERATE_BE
9767 | OPTS_TYPE_ST_ADD80
9768 | OPTS_TYPE_ST_ADDBITS15;
9769 kern_type = KERN_TYPE_RAKP;
9770 dgst_size = DGST_SIZE_4_5;
9771 parse_func = rakp_parse_hash;
9772 sort_by_digest = sort_by_digest_4_5;
9773 opti_type = OPTI_TYPE_ZERO_BYTE
9774 | OPTI_TYPE_NOT_ITERATED;
9775 dgst_pos0 = 3;
9776 dgst_pos1 = 4;
9777 dgst_pos2 = 2;
9778 dgst_pos3 = 1;
9779 break;
9780
9781 case 7400: hash_type = HASH_TYPE_SHA256;
9782 salt_type = SALT_TYPE_EMBEDDED;
9783 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9784 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9785 kern_type = KERN_TYPE_SHA256CRYPT;
9786 dgst_size = DGST_SIZE_4_8;
9787 parse_func = sha256crypt_parse_hash;
9788 sort_by_digest = sort_by_digest_4_8;
9789 opti_type = OPTI_TYPE_ZERO_BYTE;
9790 dgst_pos0 = 0;
9791 dgst_pos1 = 1;
9792 dgst_pos2 = 2;
9793 dgst_pos3 = 3;
9794 break;
9795
9796 case 7500: hash_type = HASH_TYPE_KRB5PA;
9797 salt_type = SALT_TYPE_EMBEDDED;
9798 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9799 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9800 kern_type = KERN_TYPE_KRB5PA;
9801 dgst_size = DGST_SIZE_4_4;
9802 parse_func = krb5pa_parse_hash;
9803 sort_by_digest = sort_by_digest_4_4;
9804 opti_type = OPTI_TYPE_ZERO_BYTE
9805 | OPTI_TYPE_NOT_ITERATED;
9806 dgst_pos0 = 0;
9807 dgst_pos1 = 1;
9808 dgst_pos2 = 2;
9809 dgst_pos3 = 3;
9810 break;
9811
9812 case 7600: hash_type = HASH_TYPE_SHA1;
9813 salt_type = SALT_TYPE_INTERN;
9814 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9815 opts_type = OPTS_TYPE_PT_GENERATE_BE
9816 | OPTS_TYPE_PT_ADD80
9817 | OPTS_TYPE_PT_ADDBITS15;
9818 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9819 dgst_size = DGST_SIZE_4_5;
9820 parse_func = redmine_parse_hash;
9821 sort_by_digest = sort_by_digest_4_5;
9822 opti_type = OPTI_TYPE_ZERO_BYTE
9823 | OPTI_TYPE_PRECOMPUTE_INIT
9824 | OPTI_TYPE_EARLY_SKIP
9825 | OPTI_TYPE_NOT_ITERATED
9826 | OPTI_TYPE_PREPENDED_SALT;
9827 dgst_pos0 = 3;
9828 dgst_pos1 = 4;
9829 dgst_pos2 = 2;
9830 dgst_pos3 = 1;
9831 break;
9832
9833 case 7700: hash_type = HASH_TYPE_SAPB;
9834 salt_type = SALT_TYPE_EMBEDDED;
9835 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9836 opts_type = OPTS_TYPE_PT_GENERATE_LE
9837 | OPTS_TYPE_PT_UPPER
9838 | OPTS_TYPE_ST_UPPER;
9839 kern_type = KERN_TYPE_SAPB;
9840 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9841 parse_func = sapb_parse_hash;
9842 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9843 opti_type = OPTI_TYPE_ZERO_BYTE
9844 | OPTI_TYPE_PRECOMPUTE_INIT
9845 | OPTI_TYPE_NOT_ITERATED;
9846 dgst_pos0 = 0;
9847 dgst_pos1 = 1;
9848 dgst_pos2 = 2;
9849 dgst_pos3 = 3;
9850 break;
9851
9852 case 7800: hash_type = HASH_TYPE_SAPG;
9853 salt_type = SALT_TYPE_EMBEDDED;
9854 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9855 opts_type = OPTS_TYPE_PT_GENERATE_BE
9856 | OPTS_TYPE_ST_ADD80
9857 | OPTS_TYPE_ST_UPPER;
9858 kern_type = KERN_TYPE_SAPG;
9859 dgst_size = DGST_SIZE_4_5;
9860 parse_func = sapg_parse_hash;
9861 sort_by_digest = sort_by_digest_4_5;
9862 opti_type = OPTI_TYPE_ZERO_BYTE
9863 | OPTI_TYPE_PRECOMPUTE_INIT
9864 | OPTI_TYPE_NOT_ITERATED;
9865 dgst_pos0 = 3;
9866 dgst_pos1 = 4;
9867 dgst_pos2 = 2;
9868 dgst_pos3 = 1;
9869 break;
9870
9871 case 7900: hash_type = HASH_TYPE_SHA512;
9872 salt_type = SALT_TYPE_EMBEDDED;
9873 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9874 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9875 kern_type = KERN_TYPE_DRUPAL7;
9876 dgst_size = DGST_SIZE_8_8;
9877 parse_func = drupal7_parse_hash;
9878 sort_by_digest = sort_by_digest_8_8;
9879 opti_type = OPTI_TYPE_ZERO_BYTE
9880 | OPTI_TYPE_USES_BITS_64;
9881 dgst_pos0 = 0;
9882 dgst_pos1 = 1;
9883 dgst_pos2 = 2;
9884 dgst_pos3 = 3;
9885 break;
9886
9887 case 8000: hash_type = HASH_TYPE_SHA256;
9888 salt_type = SALT_TYPE_EMBEDDED;
9889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9890 opts_type = OPTS_TYPE_PT_GENERATE_BE
9891 | OPTS_TYPE_PT_UNICODE
9892 | OPTS_TYPE_ST_ADD80
9893 | OPTS_TYPE_ST_HEX;
9894 kern_type = KERN_TYPE_SYBASEASE;
9895 dgst_size = DGST_SIZE_4_8;
9896 parse_func = sybasease_parse_hash;
9897 sort_by_digest = sort_by_digest_4_8;
9898 opti_type = OPTI_TYPE_ZERO_BYTE
9899 | OPTI_TYPE_PRECOMPUTE_INIT
9900 | OPTI_TYPE_EARLY_SKIP
9901 | OPTI_TYPE_NOT_ITERATED
9902 | OPTI_TYPE_RAW_HASH;
9903 dgst_pos0 = 3;
9904 dgst_pos1 = 7;
9905 dgst_pos2 = 2;
9906 dgst_pos3 = 6;
9907 break;
9908
9909 case 8100: hash_type = HASH_TYPE_SHA1;
9910 salt_type = SALT_TYPE_EMBEDDED;
9911 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9912 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9913 kern_type = KERN_TYPE_NETSCALER;
9914 dgst_size = DGST_SIZE_4_5;
9915 parse_func = netscaler_parse_hash;
9916 sort_by_digest = sort_by_digest_4_5;
9917 opti_type = OPTI_TYPE_ZERO_BYTE
9918 | OPTI_TYPE_PRECOMPUTE_INIT
9919 | OPTI_TYPE_PRECOMPUTE_MERKLE
9920 | OPTI_TYPE_EARLY_SKIP
9921 | OPTI_TYPE_NOT_ITERATED
9922 | OPTI_TYPE_PREPENDED_SALT
9923 | OPTI_TYPE_RAW_HASH;
9924 dgst_pos0 = 3;
9925 dgst_pos1 = 4;
9926 dgst_pos2 = 2;
9927 dgst_pos3 = 1;
9928 break;
9929
9930 case 8200: hash_type = HASH_TYPE_SHA256;
9931 salt_type = SALT_TYPE_EMBEDDED;
9932 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9933 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9934 kern_type = KERN_TYPE_CLOUDKEY;
9935 dgst_size = DGST_SIZE_4_8;
9936 parse_func = cloudkey_parse_hash;
9937 sort_by_digest = sort_by_digest_4_8;
9938 opti_type = OPTI_TYPE_ZERO_BYTE;
9939 dgst_pos0 = 0;
9940 dgst_pos1 = 1;
9941 dgst_pos2 = 2;
9942 dgst_pos3 = 3;
9943 break;
9944
9945 case 8300: hash_type = HASH_TYPE_SHA1;
9946 salt_type = SALT_TYPE_EMBEDDED;
9947 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9948 opts_type = OPTS_TYPE_PT_GENERATE_BE
9949 | OPTS_TYPE_ST_HEX
9950 | OPTS_TYPE_ST_ADD80;
9951 kern_type = KERN_TYPE_NSEC3;
9952 dgst_size = DGST_SIZE_4_5;
9953 parse_func = nsec3_parse_hash;
9954 sort_by_digest = sort_by_digest_4_5;
9955 opti_type = OPTI_TYPE_ZERO_BYTE;
9956 dgst_pos0 = 3;
9957 dgst_pos1 = 4;
9958 dgst_pos2 = 2;
9959 dgst_pos3 = 1;
9960 break;
9961
9962 case 8400: hash_type = HASH_TYPE_SHA1;
9963 salt_type = SALT_TYPE_INTERN;
9964 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9965 opts_type = OPTS_TYPE_PT_GENERATE_BE
9966 | OPTS_TYPE_PT_ADD80
9967 | OPTS_TYPE_PT_ADDBITS15;
9968 kern_type = KERN_TYPE_WBB3;
9969 dgst_size = DGST_SIZE_4_5;
9970 parse_func = wbb3_parse_hash;
9971 sort_by_digest = sort_by_digest_4_5;
9972 opti_type = OPTI_TYPE_ZERO_BYTE
9973 | OPTI_TYPE_PRECOMPUTE_INIT
9974 | OPTI_TYPE_NOT_ITERATED;
9975 dgst_pos0 = 3;
9976 dgst_pos1 = 4;
9977 dgst_pos2 = 2;
9978 dgst_pos3 = 1;
9979 break;
9980
9981 case 8500: hash_type = HASH_TYPE_DESRACF;
9982 salt_type = SALT_TYPE_EMBEDDED;
9983 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9984 opts_type = OPTS_TYPE_PT_GENERATE_LE
9985 | OPTS_TYPE_ST_UPPER;
9986 kern_type = KERN_TYPE_RACF;
9987 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9988 parse_func = racf_parse_hash;
9989 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9990 opti_type = OPTI_TYPE_ZERO_BYTE
9991 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9992 dgst_pos0 = 0;
9993 dgst_pos1 = 1;
9994 dgst_pos2 = 2;
9995 dgst_pos3 = 3;
9996 break;
9997
9998 case 8600: hash_type = HASH_TYPE_LOTUS5;
9999 salt_type = SALT_TYPE_NONE;
10000 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10001 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10002 kern_type = KERN_TYPE_LOTUS5;
10003 dgst_size = DGST_SIZE_4_4;
10004 parse_func = lotus5_parse_hash;
10005 sort_by_digest = sort_by_digest_4_4;
10006 opti_type = OPTI_TYPE_EARLY_SKIP
10007 | OPTI_TYPE_NOT_ITERATED
10008 | OPTI_TYPE_NOT_SALTED
10009 | OPTI_TYPE_RAW_HASH;
10010 dgst_pos0 = 0;
10011 dgst_pos1 = 1;
10012 dgst_pos2 = 2;
10013 dgst_pos3 = 3;
10014 break;
10015
10016 case 8700: hash_type = HASH_TYPE_LOTUS6;
10017 salt_type = SALT_TYPE_EMBEDDED;
10018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10019 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10020 kern_type = KERN_TYPE_LOTUS6;
10021 dgst_size = DGST_SIZE_4_4;
10022 parse_func = lotus6_parse_hash;
10023 sort_by_digest = sort_by_digest_4_4;
10024 opti_type = OPTI_TYPE_EARLY_SKIP
10025 | OPTI_TYPE_NOT_ITERATED
10026 | OPTI_TYPE_RAW_HASH;
10027 dgst_pos0 = 0;
10028 dgst_pos1 = 1;
10029 dgst_pos2 = 2;
10030 dgst_pos3 = 3;
10031 break;
10032
10033 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
10034 salt_type = SALT_TYPE_EMBEDDED;
10035 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10036 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10037 kern_type = KERN_TYPE_ANDROIDFDE;
10038 dgst_size = DGST_SIZE_4_4;
10039 parse_func = androidfde_parse_hash;
10040 sort_by_digest = sort_by_digest_4_4;
10041 opti_type = OPTI_TYPE_ZERO_BYTE;
10042 dgst_pos0 = 0;
10043 dgst_pos1 = 1;
10044 dgst_pos2 = 2;
10045 dgst_pos3 = 3;
10046 break;
10047
10048 case 8900: hash_type = HASH_TYPE_SCRYPT;
10049 salt_type = SALT_TYPE_EMBEDDED;
10050 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10051 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10052 kern_type = KERN_TYPE_SCRYPT;
10053 dgst_size = DGST_SIZE_4_8;
10054 parse_func = scrypt_parse_hash;
10055 sort_by_digest = sort_by_digest_4_8;
10056 opti_type = OPTI_TYPE_ZERO_BYTE;
10057 dgst_pos0 = 0;
10058 dgst_pos1 = 1;
10059 dgst_pos2 = 2;
10060 dgst_pos3 = 3;
10061 break;
10062
10063 case 9000: hash_type = HASH_TYPE_SHA1;
10064 salt_type = SALT_TYPE_EMBEDDED;
10065 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10066 opts_type = OPTS_TYPE_PT_GENERATE_LE
10067 | OPTS_TYPE_ST_GENERATE_LE;
10068 kern_type = KERN_TYPE_PSAFE2;
10069 dgst_size = DGST_SIZE_4_5;
10070 parse_func = psafe2_parse_hash;
10071 sort_by_digest = sort_by_digest_4_5;
10072 opti_type = OPTI_TYPE_ZERO_BYTE;
10073 dgst_pos0 = 0;
10074 dgst_pos1 = 1;
10075 dgst_pos2 = 2;
10076 dgst_pos3 = 3;
10077 break;
10078
10079 case 9100: hash_type = HASH_TYPE_LOTUS8;
10080 salt_type = SALT_TYPE_EMBEDDED;
10081 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10082 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10083 kern_type = KERN_TYPE_LOTUS8;
10084 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10085 parse_func = lotus8_parse_hash;
10086 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10087 opti_type = OPTI_TYPE_ZERO_BYTE;
10088 dgst_pos0 = 0;
10089 dgst_pos1 = 1;
10090 dgst_pos2 = 2;
10091 dgst_pos3 = 3;
10092 break;
10093
10094 case 9200: hash_type = HASH_TYPE_SHA256;
10095 salt_type = SALT_TYPE_EMBEDDED;
10096 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10097 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10098 kern_type = KERN_TYPE_PBKDF2_SHA256;
10099 dgst_size = DGST_SIZE_4_32;
10100 parse_func = cisco8_parse_hash;
10101 sort_by_digest = sort_by_digest_4_32;
10102 opti_type = OPTI_TYPE_ZERO_BYTE
10103 | OPTI_TYPE_SLOW_HASH_SIMD;
10104 dgst_pos0 = 0;
10105 dgst_pos1 = 1;
10106 dgst_pos2 = 2;
10107 dgst_pos3 = 3;
10108 break;
10109
10110 case 9300: hash_type = HASH_TYPE_SCRYPT;
10111 salt_type = SALT_TYPE_EMBEDDED;
10112 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10113 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10114 kern_type = KERN_TYPE_SCRYPT;
10115 dgst_size = DGST_SIZE_4_8;
10116 parse_func = cisco9_parse_hash;
10117 sort_by_digest = sort_by_digest_4_8;
10118 opti_type = OPTI_TYPE_ZERO_BYTE;
10119 dgst_pos0 = 0;
10120 dgst_pos1 = 1;
10121 dgst_pos2 = 2;
10122 dgst_pos3 = 3;
10123 break;
10124
10125 case 9400: hash_type = HASH_TYPE_OFFICE2007;
10126 salt_type = SALT_TYPE_EMBEDDED;
10127 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10128 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10129 kern_type = KERN_TYPE_OFFICE2007;
10130 dgst_size = DGST_SIZE_4_4;
10131 parse_func = office2007_parse_hash;
10132 sort_by_digest = sort_by_digest_4_4;
10133 opti_type = OPTI_TYPE_ZERO_BYTE;
10134 dgst_pos0 = 0;
10135 dgst_pos1 = 1;
10136 dgst_pos2 = 2;
10137 dgst_pos3 = 3;
10138 break;
10139
10140 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10141 salt_type = SALT_TYPE_EMBEDDED;
10142 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10143 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10144 kern_type = KERN_TYPE_OFFICE2010;
10145 dgst_size = DGST_SIZE_4_4;
10146 parse_func = office2010_parse_hash;
10147 sort_by_digest = sort_by_digest_4_4;
10148 opti_type = OPTI_TYPE_ZERO_BYTE;
10149 dgst_pos0 = 0;
10150 dgst_pos1 = 1;
10151 dgst_pos2 = 2;
10152 dgst_pos3 = 3;
10153 break;
10154
10155 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10156 salt_type = SALT_TYPE_EMBEDDED;
10157 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10158 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10159 kern_type = KERN_TYPE_OFFICE2013;
10160 dgst_size = DGST_SIZE_4_4;
10161 parse_func = office2013_parse_hash;
10162 sort_by_digest = sort_by_digest_4_4;
10163 opti_type = OPTI_TYPE_ZERO_BYTE;
10164 dgst_pos0 = 0;
10165 dgst_pos1 = 1;
10166 dgst_pos2 = 2;
10167 dgst_pos3 = 3;
10168 break;
10169
10170 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10171 salt_type = SALT_TYPE_EMBEDDED;
10172 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10173 opts_type = OPTS_TYPE_PT_GENERATE_LE
10174 | OPTS_TYPE_PT_ADD80
10175 | OPTS_TYPE_PT_UNICODE;
10176 kern_type = KERN_TYPE_OLDOFFICE01;
10177 dgst_size = DGST_SIZE_4_4;
10178 parse_func = oldoffice01_parse_hash;
10179 sort_by_digest = sort_by_digest_4_4;
10180 opti_type = OPTI_TYPE_ZERO_BYTE
10181 | OPTI_TYPE_PRECOMPUTE_INIT
10182 | OPTI_TYPE_NOT_ITERATED;
10183 dgst_pos0 = 0;
10184 dgst_pos1 = 1;
10185 dgst_pos2 = 2;
10186 dgst_pos3 = 3;
10187 break;
10188
10189 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10190 salt_type = SALT_TYPE_EMBEDDED;
10191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10192 opts_type = OPTS_TYPE_PT_GENERATE_LE
10193 | OPTS_TYPE_PT_ADD80;
10194 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10195 dgst_size = DGST_SIZE_4_4;
10196 parse_func = oldoffice01cm1_parse_hash;
10197 sort_by_digest = sort_by_digest_4_4;
10198 opti_type = OPTI_TYPE_ZERO_BYTE
10199 | OPTI_TYPE_PRECOMPUTE_INIT
10200 | OPTI_TYPE_NOT_ITERATED;
10201 dgst_pos0 = 0;
10202 dgst_pos1 = 1;
10203 dgst_pos2 = 2;
10204 dgst_pos3 = 3;
10205 break;
10206
10207 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10208 salt_type = SALT_TYPE_EMBEDDED;
10209 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10210 opts_type = OPTS_TYPE_PT_GENERATE_LE
10211 | OPTS_TYPE_PT_ADD80
10212 | OPTS_TYPE_PT_UNICODE
10213 | OPTS_TYPE_PT_NEVERCRACK;
10214 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10215 dgst_size = DGST_SIZE_4_4;
10216 parse_func = oldoffice01cm2_parse_hash;
10217 sort_by_digest = sort_by_digest_4_4;
10218 opti_type = OPTI_TYPE_ZERO_BYTE
10219 | OPTI_TYPE_PRECOMPUTE_INIT
10220 | OPTI_TYPE_NOT_ITERATED;
10221 dgst_pos0 = 0;
10222 dgst_pos1 = 1;
10223 dgst_pos2 = 2;
10224 dgst_pos3 = 3;
10225 break;
10226
10227 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10228 salt_type = SALT_TYPE_EMBEDDED;
10229 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10230 opts_type = OPTS_TYPE_PT_GENERATE_BE
10231 | OPTS_TYPE_PT_ADD80
10232 | OPTS_TYPE_PT_UNICODE;
10233 kern_type = KERN_TYPE_OLDOFFICE34;
10234 dgst_size = DGST_SIZE_4_4;
10235 parse_func = oldoffice34_parse_hash;
10236 sort_by_digest = sort_by_digest_4_4;
10237 opti_type = OPTI_TYPE_ZERO_BYTE
10238 | OPTI_TYPE_PRECOMPUTE_INIT
10239 | OPTI_TYPE_NOT_ITERATED;
10240 dgst_pos0 = 0;
10241 dgst_pos1 = 1;
10242 dgst_pos2 = 2;
10243 dgst_pos3 = 3;
10244 break;
10245
10246 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10247 salt_type = SALT_TYPE_EMBEDDED;
10248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10249 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10250 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10251 dgst_size = DGST_SIZE_4_4;
10252 parse_func = oldoffice34cm1_parse_hash;
10253 sort_by_digest = sort_by_digest_4_4;
10254 opti_type = OPTI_TYPE_ZERO_BYTE
10255 | OPTI_TYPE_PRECOMPUTE_INIT
10256 | OPTI_TYPE_NOT_ITERATED;
10257 dgst_pos0 = 0;
10258 dgst_pos1 = 1;
10259 dgst_pos2 = 2;
10260 dgst_pos3 = 3;
10261 break;
10262
10263 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10264 salt_type = SALT_TYPE_EMBEDDED;
10265 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10266 opts_type = OPTS_TYPE_PT_GENERATE_BE
10267 | OPTS_TYPE_PT_ADD80
10268 | OPTS_TYPE_PT_UNICODE
10269 | OPTS_TYPE_PT_NEVERCRACK;
10270 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10271 dgst_size = DGST_SIZE_4_4;
10272 parse_func = oldoffice34cm2_parse_hash;
10273 sort_by_digest = sort_by_digest_4_4;
10274 opti_type = OPTI_TYPE_ZERO_BYTE
10275 | OPTI_TYPE_PRECOMPUTE_INIT
10276 | OPTI_TYPE_NOT_ITERATED;
10277 dgst_pos0 = 0;
10278 dgst_pos1 = 1;
10279 dgst_pos2 = 2;
10280 dgst_pos3 = 3;
10281 break;
10282
10283 case 9900: hash_type = HASH_TYPE_MD5;
10284 salt_type = SALT_TYPE_NONE;
10285 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10286 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10287 kern_type = KERN_TYPE_RADMIN2;
10288 dgst_size = DGST_SIZE_4_4;
10289 parse_func = radmin2_parse_hash;
10290 sort_by_digest = sort_by_digest_4_4;
10291 opti_type = OPTI_TYPE_ZERO_BYTE
10292 | OPTI_TYPE_PRECOMPUTE_INIT
10293 | OPTI_TYPE_EARLY_SKIP
10294 | OPTI_TYPE_NOT_ITERATED
10295 | OPTI_TYPE_NOT_SALTED;
10296 dgst_pos0 = 0;
10297 dgst_pos1 = 3;
10298 dgst_pos2 = 2;
10299 dgst_pos3 = 1;
10300 break;
10301
10302 case 10000: hash_type = HASH_TYPE_SHA256;
10303 salt_type = SALT_TYPE_EMBEDDED;
10304 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10305 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10306 kern_type = KERN_TYPE_PBKDF2_SHA256;
10307 dgst_size = DGST_SIZE_4_32;
10308 parse_func = djangopbkdf2_parse_hash;
10309 sort_by_digest = sort_by_digest_4_32;
10310 opti_type = OPTI_TYPE_ZERO_BYTE
10311 | OPTI_TYPE_SLOW_HASH_SIMD;
10312 dgst_pos0 = 0;
10313 dgst_pos1 = 1;
10314 dgst_pos2 = 2;
10315 dgst_pos3 = 3;
10316 break;
10317
10318 case 10100: hash_type = HASH_TYPE_SIPHASH;
10319 salt_type = SALT_TYPE_EMBEDDED;
10320 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10321 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10322 kern_type = KERN_TYPE_SIPHASH;
10323 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10324 parse_func = siphash_parse_hash;
10325 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10326 opti_type = OPTI_TYPE_ZERO_BYTE
10327 | OPTI_TYPE_NOT_ITERATED
10328 | OPTI_TYPE_RAW_HASH;
10329 dgst_pos0 = 0;
10330 dgst_pos1 = 1;
10331 dgst_pos2 = 2;
10332 dgst_pos3 = 3;
10333 break;
10334
10335 case 10200: hash_type = HASH_TYPE_MD5;
10336 salt_type = SALT_TYPE_EMBEDDED;
10337 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10338 opts_type = OPTS_TYPE_PT_GENERATE_LE
10339 | OPTS_TYPE_ST_ADD80
10340 | OPTS_TYPE_ST_ADDBITS14;
10341 kern_type = KERN_TYPE_HMACMD5_PW;
10342 dgst_size = DGST_SIZE_4_4;
10343 parse_func = crammd5_parse_hash;
10344 sort_by_digest = sort_by_digest_4_4;
10345 opti_type = OPTI_TYPE_ZERO_BYTE
10346 | OPTI_TYPE_NOT_ITERATED;
10347 dgst_pos0 = 0;
10348 dgst_pos1 = 3;
10349 dgst_pos2 = 2;
10350 dgst_pos3 = 1;
10351 break;
10352
10353 case 10300: hash_type = HASH_TYPE_SHA1;
10354 salt_type = SALT_TYPE_EMBEDDED;
10355 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10356 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10357 kern_type = KERN_TYPE_SAPH_SHA1;
10358 dgst_size = DGST_SIZE_4_5;
10359 parse_func = saph_sha1_parse_hash;
10360 sort_by_digest = sort_by_digest_4_5;
10361 opti_type = OPTI_TYPE_ZERO_BYTE;
10362 dgst_pos0 = 0;
10363 dgst_pos1 = 1;
10364 dgst_pos2 = 2;
10365 dgst_pos3 = 3;
10366 break;
10367
10368 case 10400: hash_type = HASH_TYPE_PDFU16;
10369 salt_type = SALT_TYPE_EMBEDDED;
10370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10371 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10372 kern_type = KERN_TYPE_PDF11;
10373 dgst_size = DGST_SIZE_4_4;
10374 parse_func = pdf11_parse_hash;
10375 sort_by_digest = sort_by_digest_4_4;
10376 opti_type = OPTI_TYPE_ZERO_BYTE
10377 | OPTI_TYPE_NOT_ITERATED;
10378 dgst_pos0 = 0;
10379 dgst_pos1 = 1;
10380 dgst_pos2 = 2;
10381 dgst_pos3 = 3;
10382 break;
10383
10384 case 10410: hash_type = HASH_TYPE_PDFU16;
10385 salt_type = SALT_TYPE_EMBEDDED;
10386 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10387 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10388 kern_type = KERN_TYPE_PDF11CM1;
10389 dgst_size = DGST_SIZE_4_4;
10390 parse_func = pdf11cm1_parse_hash;
10391 sort_by_digest = sort_by_digest_4_4;
10392 opti_type = OPTI_TYPE_ZERO_BYTE
10393 | OPTI_TYPE_NOT_ITERATED;
10394 dgst_pos0 = 0;
10395 dgst_pos1 = 1;
10396 dgst_pos2 = 2;
10397 dgst_pos3 = 3;
10398 break;
10399
10400 case 10420: hash_type = HASH_TYPE_PDFU16;
10401 salt_type = SALT_TYPE_EMBEDDED;
10402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10403 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10404 kern_type = KERN_TYPE_PDF11CM2;
10405 dgst_size = DGST_SIZE_4_4;
10406 parse_func = pdf11cm2_parse_hash;
10407 sort_by_digest = sort_by_digest_4_4;
10408 opti_type = OPTI_TYPE_ZERO_BYTE
10409 | OPTI_TYPE_NOT_ITERATED;
10410 dgst_pos0 = 0;
10411 dgst_pos1 = 1;
10412 dgst_pos2 = 2;
10413 dgst_pos3 = 3;
10414 break;
10415
10416 case 10500: hash_type = HASH_TYPE_PDFU16;
10417 salt_type = SALT_TYPE_EMBEDDED;
10418 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10419 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10420 kern_type = KERN_TYPE_PDF14;
10421 dgst_size = DGST_SIZE_4_4;
10422 parse_func = pdf14_parse_hash;
10423 sort_by_digest = sort_by_digest_4_4;
10424 opti_type = OPTI_TYPE_ZERO_BYTE
10425 | OPTI_TYPE_NOT_ITERATED;
10426 dgst_pos0 = 0;
10427 dgst_pos1 = 1;
10428 dgst_pos2 = 2;
10429 dgst_pos3 = 3;
10430 break;
10431
10432 case 10600: hash_type = HASH_TYPE_SHA256;
10433 salt_type = SALT_TYPE_EMBEDDED;
10434 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10435 opts_type = OPTS_TYPE_PT_GENERATE_BE
10436 | OPTS_TYPE_ST_ADD80
10437 | OPTS_TYPE_ST_ADDBITS15
10438 | OPTS_TYPE_HASH_COPY;
10439 kern_type = KERN_TYPE_SHA256_PWSLT;
10440 dgst_size = DGST_SIZE_4_8;
10441 parse_func = pdf17l3_parse_hash;
10442 sort_by_digest = sort_by_digest_4_8;
10443 opti_type = OPTI_TYPE_ZERO_BYTE
10444 | OPTI_TYPE_PRECOMPUTE_INIT
10445 | OPTI_TYPE_PRECOMPUTE_MERKLE
10446 | OPTI_TYPE_EARLY_SKIP
10447 | OPTI_TYPE_NOT_ITERATED
10448 | OPTI_TYPE_APPENDED_SALT
10449 | OPTI_TYPE_RAW_HASH;
10450 dgst_pos0 = 3;
10451 dgst_pos1 = 7;
10452 dgst_pos2 = 2;
10453 dgst_pos3 = 6;
10454 break;
10455
10456 case 10700: hash_type = HASH_TYPE_PDFU32;
10457 salt_type = SALT_TYPE_EMBEDDED;
10458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10459 opts_type = OPTS_TYPE_PT_GENERATE_LE
10460 | OPTS_TYPE_HASH_COPY;
10461 kern_type = KERN_TYPE_PDF17L8;
10462 dgst_size = DGST_SIZE_4_8;
10463 parse_func = pdf17l8_parse_hash;
10464 sort_by_digest = sort_by_digest_4_8;
10465 opti_type = OPTI_TYPE_ZERO_BYTE
10466 | OPTI_TYPE_NOT_ITERATED;
10467 dgst_pos0 = 0;
10468 dgst_pos1 = 1;
10469 dgst_pos2 = 2;
10470 dgst_pos3 = 3;
10471 break;
10472
10473 case 10800: hash_type = HASH_TYPE_SHA384;
10474 salt_type = SALT_TYPE_NONE;
10475 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10476 opts_type = OPTS_TYPE_PT_GENERATE_BE
10477 | OPTS_TYPE_PT_ADD80
10478 | OPTS_TYPE_PT_ADDBITS15;
10479 kern_type = KERN_TYPE_SHA384;
10480 dgst_size = DGST_SIZE_8_8;
10481 parse_func = sha384_parse_hash;
10482 sort_by_digest = sort_by_digest_8_8;
10483 opti_type = OPTI_TYPE_ZERO_BYTE
10484 | OPTI_TYPE_PRECOMPUTE_INIT
10485 | OPTI_TYPE_PRECOMPUTE_MERKLE
10486 | OPTI_TYPE_EARLY_SKIP
10487 | OPTI_TYPE_NOT_ITERATED
10488 | OPTI_TYPE_NOT_SALTED
10489 | OPTI_TYPE_USES_BITS_64
10490 | OPTI_TYPE_RAW_HASH;
10491 dgst_pos0 = 6;
10492 dgst_pos1 = 7;
10493 dgst_pos2 = 4;
10494 dgst_pos3 = 5;
10495 break;
10496
10497 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10498 salt_type = SALT_TYPE_EMBEDDED;
10499 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10500 opts_type = OPTS_TYPE_PT_GENERATE_LE
10501 | OPTS_TYPE_ST_BASE64
10502 | OPTS_TYPE_HASH_COPY;
10503 kern_type = KERN_TYPE_PBKDF2_SHA256;
10504 dgst_size = DGST_SIZE_4_32;
10505 parse_func = pbkdf2_sha256_parse_hash;
10506 sort_by_digest = sort_by_digest_4_32;
10507 opti_type = OPTI_TYPE_ZERO_BYTE
10508 | OPTI_TYPE_SLOW_HASH_SIMD;
10509 dgst_pos0 = 0;
10510 dgst_pos1 = 1;
10511 dgst_pos2 = 2;
10512 dgst_pos3 = 3;
10513 break;
10514
10515 case 11000: hash_type = HASH_TYPE_MD5;
10516 salt_type = SALT_TYPE_INTERN;
10517 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10518 opts_type = OPTS_TYPE_PT_GENERATE_LE
10519 | OPTS_TYPE_PT_ADD80;
10520 kern_type = KERN_TYPE_PRESTASHOP;
10521 dgst_size = DGST_SIZE_4_4;
10522 parse_func = prestashop_parse_hash;
10523 sort_by_digest = sort_by_digest_4_4;
10524 opti_type = OPTI_TYPE_ZERO_BYTE
10525 | OPTI_TYPE_PRECOMPUTE_INIT
10526 | OPTI_TYPE_NOT_ITERATED
10527 | OPTI_TYPE_PREPENDED_SALT;
10528 dgst_pos0 = 0;
10529 dgst_pos1 = 3;
10530 dgst_pos2 = 2;
10531 dgst_pos3 = 1;
10532 break;
10533
10534 case 11100: hash_type = HASH_TYPE_MD5;
10535 salt_type = SALT_TYPE_EMBEDDED;
10536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10537 opts_type = OPTS_TYPE_PT_GENERATE_LE
10538 | OPTS_TYPE_ST_ADD80;
10539 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10540 dgst_size = DGST_SIZE_4_4;
10541 parse_func = postgresql_auth_parse_hash;
10542 sort_by_digest = sort_by_digest_4_4;
10543 opti_type = OPTI_TYPE_ZERO_BYTE
10544 | OPTI_TYPE_PRECOMPUTE_INIT
10545 | OPTI_TYPE_PRECOMPUTE_MERKLE
10546 | OPTI_TYPE_EARLY_SKIP;
10547 dgst_pos0 = 0;
10548 dgst_pos1 = 3;
10549 dgst_pos2 = 2;
10550 dgst_pos3 = 1;
10551 break;
10552
10553 case 11200: hash_type = HASH_TYPE_SHA1;
10554 salt_type = SALT_TYPE_EMBEDDED;
10555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10556 opts_type = OPTS_TYPE_PT_GENERATE_BE
10557 | OPTS_TYPE_PT_ADD80
10558 | OPTS_TYPE_ST_HEX;
10559 kern_type = KERN_TYPE_MYSQL_AUTH;
10560 dgst_size = DGST_SIZE_4_5;
10561 parse_func = mysql_auth_parse_hash;
10562 sort_by_digest = sort_by_digest_4_5;
10563 opti_type = OPTI_TYPE_ZERO_BYTE
10564 | OPTI_TYPE_EARLY_SKIP;
10565 dgst_pos0 = 3;
10566 dgst_pos1 = 4;
10567 dgst_pos2 = 2;
10568 dgst_pos3 = 1;
10569 break;
10570
10571 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10572 salt_type = SALT_TYPE_EMBEDDED;
10573 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10574 opts_type = OPTS_TYPE_PT_GENERATE_LE
10575 | OPTS_TYPE_ST_HEX
10576 | OPTS_TYPE_ST_ADD80;
10577 kern_type = KERN_TYPE_BITCOIN_WALLET;
10578 dgst_size = DGST_SIZE_4_4;
10579 parse_func = bitcoin_wallet_parse_hash;
10580 sort_by_digest = sort_by_digest_4_4;
10581 opti_type = OPTI_TYPE_ZERO_BYTE;
10582 dgst_pos0 = 0;
10583 dgst_pos1 = 1;
10584 dgst_pos2 = 2;
10585 dgst_pos3 = 3;
10586 break;
10587
10588 case 11400: hash_type = HASH_TYPE_MD5;
10589 salt_type = SALT_TYPE_EMBEDDED;
10590 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10591 opts_type = OPTS_TYPE_PT_GENERATE_LE
10592 | OPTS_TYPE_PT_ADD80
10593 | OPTS_TYPE_HASH_COPY;
10594 kern_type = KERN_TYPE_SIP_AUTH;
10595 dgst_size = DGST_SIZE_4_4;
10596 parse_func = sip_auth_parse_hash;
10597 sort_by_digest = sort_by_digest_4_4;
10598 opti_type = OPTI_TYPE_ZERO_BYTE;
10599 dgst_pos0 = 0;
10600 dgst_pos1 = 3;
10601 dgst_pos2 = 2;
10602 dgst_pos3 = 1;
10603 break;
10604
10605 case 11500: hash_type = HASH_TYPE_CRC32;
10606 salt_type = SALT_TYPE_INTERN;
10607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10608 opts_type = OPTS_TYPE_PT_GENERATE_LE
10609 | OPTS_TYPE_ST_GENERATE_LE
10610 | OPTS_TYPE_ST_HEX;
10611 kern_type = KERN_TYPE_CRC32;
10612 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10613 parse_func = crc32_parse_hash;
10614 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10615 opti_type = OPTI_TYPE_ZERO_BYTE;
10616 dgst_pos0 = 0;
10617 dgst_pos1 = 1;
10618 dgst_pos2 = 2;
10619 dgst_pos3 = 3;
10620 break;
10621
10622 case 11600: hash_type = HASH_TYPE_AES;
10623 salt_type = SALT_TYPE_EMBEDDED;
10624 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10625 opts_type = OPTS_TYPE_PT_GENERATE_LE
10626 | OPTS_TYPE_PT_NEVERCRACK;
10627 kern_type = KERN_TYPE_SEVEN_ZIP;
10628 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10629 parse_func = seven_zip_parse_hash;
10630 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10631 opti_type = OPTI_TYPE_ZERO_BYTE;
10632 dgst_pos0 = 0;
10633 dgst_pos1 = 1;
10634 dgst_pos2 = 2;
10635 dgst_pos3 = 3;
10636 break;
10637
10638 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10639 salt_type = SALT_TYPE_NONE;
10640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10641 opts_type = OPTS_TYPE_PT_GENERATE_LE
10642 | OPTS_TYPE_PT_ADD01;
10643 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10644 dgst_size = DGST_SIZE_4_8;
10645 parse_func = gost2012sbog_256_parse_hash;
10646 sort_by_digest = sort_by_digest_4_8;
10647 opti_type = OPTI_TYPE_ZERO_BYTE;
10648 dgst_pos0 = 0;
10649 dgst_pos1 = 1;
10650 dgst_pos2 = 2;
10651 dgst_pos3 = 3;
10652 break;
10653
10654 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10655 salt_type = SALT_TYPE_NONE;
10656 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10657 opts_type = OPTS_TYPE_PT_GENERATE_LE
10658 | OPTS_TYPE_PT_ADD01;
10659 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10660 dgst_size = DGST_SIZE_4_16;
10661 parse_func = gost2012sbog_512_parse_hash;
10662 sort_by_digest = sort_by_digest_4_16;
10663 opti_type = OPTI_TYPE_ZERO_BYTE;
10664 dgst_pos0 = 0;
10665 dgst_pos1 = 1;
10666 dgst_pos2 = 2;
10667 dgst_pos3 = 3;
10668 break;
10669
10670 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10671 salt_type = SALT_TYPE_EMBEDDED;
10672 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10673 opts_type = OPTS_TYPE_PT_GENERATE_LE
10674 | OPTS_TYPE_ST_BASE64
10675 | OPTS_TYPE_HASH_COPY;
10676 kern_type = KERN_TYPE_PBKDF2_MD5;
10677 dgst_size = DGST_SIZE_4_32;
10678 parse_func = pbkdf2_md5_parse_hash;
10679 sort_by_digest = sort_by_digest_4_32;
10680 opti_type = OPTI_TYPE_ZERO_BYTE
10681 | OPTI_TYPE_SLOW_HASH_SIMD;
10682 dgst_pos0 = 0;
10683 dgst_pos1 = 1;
10684 dgst_pos2 = 2;
10685 dgst_pos3 = 3;
10686 break;
10687
10688 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10689 salt_type = SALT_TYPE_EMBEDDED;
10690 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10691 opts_type = OPTS_TYPE_PT_GENERATE_LE
10692 | OPTS_TYPE_ST_BASE64
10693 | OPTS_TYPE_HASH_COPY;
10694 kern_type = KERN_TYPE_PBKDF2_SHA1;
10695 dgst_size = DGST_SIZE_4_32;
10696 parse_func = pbkdf2_sha1_parse_hash;
10697 sort_by_digest = sort_by_digest_4_32;
10698 opti_type = OPTI_TYPE_ZERO_BYTE
10699 | OPTI_TYPE_SLOW_HASH_SIMD;
10700 dgst_pos0 = 0;
10701 dgst_pos1 = 1;
10702 dgst_pos2 = 2;
10703 dgst_pos3 = 3;
10704 break;
10705
10706 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10707 salt_type = SALT_TYPE_EMBEDDED;
10708 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10709 opts_type = OPTS_TYPE_PT_GENERATE_LE
10710 | OPTS_TYPE_ST_BASE64
10711 | OPTS_TYPE_HASH_COPY;
10712 kern_type = KERN_TYPE_PBKDF2_SHA512;
10713 dgst_size = DGST_SIZE_8_16;
10714 parse_func = pbkdf2_sha512_parse_hash;
10715 sort_by_digest = sort_by_digest_8_16;
10716 opti_type = OPTI_TYPE_ZERO_BYTE
10717 | OPTI_TYPE_USES_BITS_64
10718 | OPTI_TYPE_SLOW_HASH_SIMD;
10719 dgst_pos0 = 0;
10720 dgst_pos1 = 1;
10721 dgst_pos2 = 2;
10722 dgst_pos3 = 3;
10723 break;
10724
10725 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10726 salt_type = SALT_TYPE_EMBEDDED;
10727 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10728 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10729 kern_type = KERN_TYPE_ECRYPTFS;
10730 dgst_size = DGST_SIZE_8_8;
10731 parse_func = ecryptfs_parse_hash;
10732 sort_by_digest = sort_by_digest_8_8;
10733 opti_type = OPTI_TYPE_ZERO_BYTE
10734 | OPTI_TYPE_USES_BITS_64;
10735 dgst_pos0 = 0;
10736 dgst_pos1 = 1;
10737 dgst_pos2 = 2;
10738 dgst_pos3 = 3;
10739 break;
10740
10741 case 12300: hash_type = HASH_TYPE_ORACLET;
10742 salt_type = SALT_TYPE_EMBEDDED;
10743 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10744 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10745 kern_type = KERN_TYPE_ORACLET;
10746 dgst_size = DGST_SIZE_8_16;
10747 parse_func = oraclet_parse_hash;
10748 sort_by_digest = sort_by_digest_8_16;
10749 opti_type = OPTI_TYPE_ZERO_BYTE
10750 | OPTI_TYPE_USES_BITS_64;
10751 dgst_pos0 = 0;
10752 dgst_pos1 = 1;
10753 dgst_pos2 = 2;
10754 dgst_pos3 = 3;
10755 break;
10756
10757 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10758 salt_type = SALT_TYPE_EMBEDDED;
10759 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10760 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10761 kern_type = KERN_TYPE_BSDICRYPT;
10762 dgst_size = DGST_SIZE_4_4;
10763 parse_func = bsdicrypt_parse_hash;
10764 sort_by_digest = sort_by_digest_4_4;
10765 opti_type = OPTI_TYPE_ZERO_BYTE
10766 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10767 dgst_pos0 = 0;
10768 dgst_pos1 = 1;
10769 dgst_pos2 = 2;
10770 dgst_pos3 = 3;
10771 break;
10772
10773 case 12500: hash_type = HASH_TYPE_RAR3HP;
10774 salt_type = SALT_TYPE_EMBEDDED;
10775 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10776 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10777 kern_type = KERN_TYPE_RAR3;
10778 dgst_size = DGST_SIZE_4_4;
10779 parse_func = rar3hp_parse_hash;
10780 sort_by_digest = sort_by_digest_4_4;
10781 opti_type = OPTI_TYPE_ZERO_BYTE;
10782 dgst_pos0 = 0;
10783 dgst_pos1 = 1;
10784 dgst_pos2 = 2;
10785 dgst_pos3 = 3;
10786 break;
10787
10788 case 12600: hash_type = HASH_TYPE_SHA256;
10789 salt_type = SALT_TYPE_INTERN;
10790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10791 opts_type = OPTS_TYPE_PT_GENERATE_BE
10792 | OPTS_TYPE_PT_ADD80;
10793 kern_type = KERN_TYPE_CF10;
10794 dgst_size = DGST_SIZE_4_8;
10795 parse_func = cf10_parse_hash;
10796 sort_by_digest = sort_by_digest_4_8;
10797 opti_type = OPTI_TYPE_ZERO_BYTE
10798 | OPTI_TYPE_PRECOMPUTE_INIT
10799 | OPTI_TYPE_EARLY_SKIP
10800 | OPTI_TYPE_NOT_ITERATED;
10801 dgst_pos0 = 3;
10802 dgst_pos1 = 7;
10803 dgst_pos2 = 2;
10804 dgst_pos3 = 6;
10805 break;
10806
10807 case 12700: hash_type = HASH_TYPE_AES;
10808 salt_type = SALT_TYPE_EMBEDDED;
10809 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10810 opts_type = OPTS_TYPE_PT_GENERATE_LE
10811 | OPTS_TYPE_HASH_COPY;
10812 kern_type = KERN_TYPE_MYWALLET;
10813 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10814 parse_func = mywallet_parse_hash;
10815 sort_by_digest = sort_by_digest_4_5;
10816 opti_type = OPTI_TYPE_ZERO_BYTE;
10817 dgst_pos0 = 0;
10818 dgst_pos1 = 1;
10819 dgst_pos2 = 2;
10820 dgst_pos3 = 3;
10821 break;
10822
10823 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10824 salt_type = SALT_TYPE_EMBEDDED;
10825 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10826 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10827 kern_type = KERN_TYPE_MS_DRSR;
10828 dgst_size = DGST_SIZE_4_8;
10829 parse_func = ms_drsr_parse_hash;
10830 sort_by_digest = sort_by_digest_4_8;
10831 opti_type = OPTI_TYPE_ZERO_BYTE;
10832 dgst_pos0 = 0;
10833 dgst_pos1 = 1;
10834 dgst_pos2 = 2;
10835 dgst_pos3 = 3;
10836 break;
10837
10838 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10839 salt_type = SALT_TYPE_EMBEDDED;
10840 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10841 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10842 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10843 dgst_size = DGST_SIZE_4_8;
10844 parse_func = androidfde_samsung_parse_hash;
10845 sort_by_digest = sort_by_digest_4_8;
10846 opti_type = OPTI_TYPE_ZERO_BYTE;
10847 dgst_pos0 = 0;
10848 dgst_pos1 = 1;
10849 dgst_pos2 = 2;
10850 dgst_pos3 = 3;
10851 break;
10852
10853 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10854 salt_type = SALT_TYPE_EMBEDDED;
10855 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10856 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10857 kern_type = KERN_TYPE_RAR5;
10858 dgst_size = DGST_SIZE_4_4;
10859 parse_func = rar5_parse_hash;
10860 sort_by_digest = sort_by_digest_4_4;
10861 opti_type = OPTI_TYPE_ZERO_BYTE;
10862 dgst_pos0 = 0;
10863 dgst_pos1 = 1;
10864 dgst_pos2 = 2;
10865 dgst_pos3 = 3;
10866 break;
10867
10868 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10869 salt_type = SALT_TYPE_EMBEDDED;
10870 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10871 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10872 kern_type = KERN_TYPE_KRB5TGS;
10873 dgst_size = DGST_SIZE_4_4;
10874 parse_func = krb5tgs_parse_hash;
10875 sort_by_digest = sort_by_digest_4_4;
10876 opti_type = OPTI_TYPE_ZERO_BYTE
10877 | OPTI_TYPE_NOT_ITERATED;
10878 dgst_pos0 = 0;
10879 dgst_pos1 = 1;
10880 dgst_pos2 = 2;
10881 dgst_pos3 = 3;
10882 break;
10883
10884 case 13200: hash_type = HASH_TYPE_AES;
10885 salt_type = SALT_TYPE_EMBEDDED;
10886 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10887 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10888 kern_type = KERN_TYPE_AXCRYPT;
10889 dgst_size = DGST_SIZE_4_4;
10890 parse_func = axcrypt_parse_hash;
10891 sort_by_digest = sort_by_digest_4_4;
10892 opti_type = OPTI_TYPE_ZERO_BYTE;
10893 dgst_pos0 = 0;
10894 dgst_pos1 = 1;
10895 dgst_pos2 = 2;
10896 dgst_pos3 = 3;
10897 break;
10898
10899 case 13300: hash_type = HASH_TYPE_SHA1;
10900 salt_type = SALT_TYPE_NONE;
10901 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10902 opts_type = OPTS_TYPE_PT_GENERATE_BE
10903 | OPTS_TYPE_PT_ADD80
10904 | OPTS_TYPE_PT_ADDBITS15;
10905 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10906 dgst_size = DGST_SIZE_4_5;
10907 parse_func = sha1axcrypt_parse_hash;
10908 sort_by_digest = sort_by_digest_4_5;
10909 opti_type = OPTI_TYPE_ZERO_BYTE
10910 | OPTI_TYPE_PRECOMPUTE_INIT
10911 | OPTI_TYPE_EARLY_SKIP
10912 | OPTI_TYPE_NOT_ITERATED
10913 | OPTI_TYPE_NOT_SALTED;
10914 dgst_pos0 = 0;
10915 dgst_pos1 = 4;
10916 dgst_pos2 = 3;
10917 dgst_pos3 = 2;
10918 break;
10919
10920 case 13400: hash_type = HASH_TYPE_AES;
10921 salt_type = SALT_TYPE_EMBEDDED;
10922 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10923 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10924 kern_type = KERN_TYPE_KEEPASS;
10925 dgst_size = DGST_SIZE_4_4;
10926 parse_func = keepass_parse_hash;
10927 sort_by_digest = sort_by_digest_4_4;
10928 opti_type = OPTI_TYPE_ZERO_BYTE;
10929 dgst_pos0 = 0;
10930 dgst_pos1 = 1;
10931 dgst_pos2 = 2;
10932 dgst_pos3 = 3;
10933 break;
10934
10935 case 13500: hash_type = HASH_TYPE_SHA1;
10936 salt_type = SALT_TYPE_EMBEDDED;
10937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10938 opts_type = OPTS_TYPE_PT_GENERATE_BE
10939 | OPTS_TYPE_PT_UNICODE
10940 | OPTS_TYPE_PT_ADD80;
10941 kern_type = KERN_TYPE_PSTOKEN;
10942 dgst_size = DGST_SIZE_4_5;
10943 parse_func = pstoken_parse_hash;
10944 sort_by_digest = sort_by_digest_4_5;
10945 opti_type = OPTI_TYPE_ZERO_BYTE
10946 | OPTI_TYPE_PRECOMPUTE_INIT
10947 | OPTI_TYPE_EARLY_SKIP
10948 | OPTI_TYPE_NOT_ITERATED
10949 | OPTI_TYPE_PREPENDED_SALT
10950 | OPTI_TYPE_RAW_HASH;
10951 dgst_pos0 = 3;
10952 dgst_pos1 = 4;
10953 dgst_pos2 = 2;
10954 dgst_pos3 = 1;
10955 break;
10956
10957 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10958 salt_type = SALT_TYPE_EMBEDDED;
10959 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10960 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10961 kern_type = KERN_TYPE_ZIP2;
10962 dgst_size = DGST_SIZE_4_4;
10963 parse_func = zip2_parse_hash;
10964 sort_by_digest = sort_by_digest_4_4;
10965 opti_type = OPTI_TYPE_ZERO_BYTE;
10966 dgst_pos0 = 0;
10967 dgst_pos1 = 1;
10968 dgst_pos2 = 2;
10969 dgst_pos3 = 3;
10970 break;
10971
10972 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10973 salt_type = SALT_TYPE_EMBEDDED;
10974 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10975 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10976 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10977 dgst_size = DGST_SIZE_4_5;
10978 parse_func = veracrypt_parse_hash_655331;
10979 sort_by_digest = sort_by_digest_4_5;
10980 opti_type = OPTI_TYPE_ZERO_BYTE;
10981 dgst_pos0 = 0;
10982 dgst_pos1 = 1;
10983 dgst_pos2 = 2;
10984 dgst_pos3 = 3;
10985 break;
10986
10987 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10988 salt_type = SALT_TYPE_EMBEDDED;
10989 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10990 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10991 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10992 dgst_size = DGST_SIZE_4_5;
10993 parse_func = veracrypt_parse_hash_655331;
10994 sort_by_digest = sort_by_digest_4_5;
10995 opti_type = OPTI_TYPE_ZERO_BYTE;
10996 dgst_pos0 = 0;
10997 dgst_pos1 = 1;
10998 dgst_pos2 = 2;
10999 dgst_pos3 = 3;
11000 break;
11001
11002 case 13713: hash_type = HASH_TYPE_RIPEMD160;
11003 salt_type = SALT_TYPE_EMBEDDED;
11004 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11005 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11006 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11007 dgst_size = DGST_SIZE_4_5;
11008 parse_func = veracrypt_parse_hash_655331;
11009 sort_by_digest = sort_by_digest_4_5;
11010 opti_type = OPTI_TYPE_ZERO_BYTE;
11011 dgst_pos0 = 0;
11012 dgst_pos1 = 1;
11013 dgst_pos2 = 2;
11014 dgst_pos3 = 3;
11015 break;
11016
11017 case 13721: hash_type = HASH_TYPE_SHA512;
11018 salt_type = SALT_TYPE_EMBEDDED;
11019 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11020 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11021 kern_type = KERN_TYPE_TCSHA512_XTS512;
11022 dgst_size = DGST_SIZE_8_8;
11023 parse_func = veracrypt_parse_hash_500000;
11024 sort_by_digest = sort_by_digest_8_8;
11025 opti_type = OPTI_TYPE_ZERO_BYTE
11026 | OPTI_TYPE_USES_BITS_64;
11027 dgst_pos0 = 0;
11028 dgst_pos1 = 1;
11029 dgst_pos2 = 2;
11030 dgst_pos3 = 3;
11031 break;
11032
11033 case 13722: hash_type = HASH_TYPE_SHA512;
11034 salt_type = SALT_TYPE_EMBEDDED;
11035 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11036 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11037 kern_type = KERN_TYPE_TCSHA512_XTS1024;
11038 dgst_size = DGST_SIZE_8_8;
11039 parse_func = veracrypt_parse_hash_500000;
11040 sort_by_digest = sort_by_digest_8_8;
11041 opti_type = OPTI_TYPE_ZERO_BYTE
11042 | OPTI_TYPE_USES_BITS_64;
11043 dgst_pos0 = 0;
11044 dgst_pos1 = 1;
11045 dgst_pos2 = 2;
11046 dgst_pos3 = 3;
11047 break;
11048
11049 case 13723: hash_type = HASH_TYPE_SHA512;
11050 salt_type = SALT_TYPE_EMBEDDED;
11051 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11052 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11053 kern_type = KERN_TYPE_TCSHA512_XTS1536;
11054 dgst_size = DGST_SIZE_8_8;
11055 parse_func = veracrypt_parse_hash_500000;
11056 sort_by_digest = sort_by_digest_8_8;
11057 opti_type = OPTI_TYPE_ZERO_BYTE
11058 | OPTI_TYPE_USES_BITS_64;
11059 dgst_pos0 = 0;
11060 dgst_pos1 = 1;
11061 dgst_pos2 = 2;
11062 dgst_pos3 = 3;
11063 break;
11064
11065 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
11066 salt_type = SALT_TYPE_EMBEDDED;
11067 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11068 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11069 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
11070 dgst_size = DGST_SIZE_4_8;
11071 parse_func = veracrypt_parse_hash_500000;
11072 sort_by_digest = sort_by_digest_4_8;
11073 opti_type = OPTI_TYPE_ZERO_BYTE;
11074 dgst_pos0 = 0;
11075 dgst_pos1 = 1;
11076 dgst_pos2 = 2;
11077 dgst_pos3 = 3;
11078 break;
11079
11080 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
11081 salt_type = SALT_TYPE_EMBEDDED;
11082 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11083 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11084 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
11085 dgst_size = DGST_SIZE_4_8;
11086 parse_func = veracrypt_parse_hash_500000;
11087 sort_by_digest = sort_by_digest_4_8;
11088 opti_type = OPTI_TYPE_ZERO_BYTE;
11089 dgst_pos0 = 0;
11090 dgst_pos1 = 1;
11091 dgst_pos2 = 2;
11092 dgst_pos3 = 3;
11093 break;
11094
11095 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
11096 salt_type = SALT_TYPE_EMBEDDED;
11097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11098 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11099 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11100 dgst_size = DGST_SIZE_4_8;
11101 parse_func = veracrypt_parse_hash_500000;
11102 sort_by_digest = sort_by_digest_4_8;
11103 opti_type = OPTI_TYPE_ZERO_BYTE;
11104 dgst_pos0 = 0;
11105 dgst_pos1 = 1;
11106 dgst_pos2 = 2;
11107 dgst_pos3 = 3;
11108 break;
11109
11110 case 13741: hash_type = HASH_TYPE_RIPEMD160;
11111 salt_type = SALT_TYPE_EMBEDDED;
11112 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11113 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11114 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11115 dgst_size = DGST_SIZE_4_5;
11116 parse_func = veracrypt_parse_hash_327661;
11117 sort_by_digest = sort_by_digest_4_5;
11118 opti_type = OPTI_TYPE_ZERO_BYTE;
11119 dgst_pos0 = 0;
11120 dgst_pos1 = 1;
11121 dgst_pos2 = 2;
11122 dgst_pos3 = 3;
11123 break;
11124
11125 case 13742: hash_type = HASH_TYPE_RIPEMD160;
11126 salt_type = SALT_TYPE_EMBEDDED;
11127 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11128 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11129 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11130 dgst_size = DGST_SIZE_4_5;
11131 parse_func = veracrypt_parse_hash_327661;
11132 sort_by_digest = sort_by_digest_4_5;
11133 opti_type = OPTI_TYPE_ZERO_BYTE;
11134 dgst_pos0 = 0;
11135 dgst_pos1 = 1;
11136 dgst_pos2 = 2;
11137 dgst_pos3 = 3;
11138 break;
11139
11140 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11141 salt_type = SALT_TYPE_EMBEDDED;
11142 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11143 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11144 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11145 dgst_size = DGST_SIZE_4_5;
11146 parse_func = veracrypt_parse_hash_327661;
11147 sort_by_digest = sort_by_digest_4_5;
11148 opti_type = OPTI_TYPE_ZERO_BYTE;
11149 dgst_pos0 = 0;
11150 dgst_pos1 = 1;
11151 dgst_pos2 = 2;
11152 dgst_pos3 = 3;
11153 break;
11154
11155 case 13751: hash_type = HASH_TYPE_SHA256;
11156 salt_type = SALT_TYPE_EMBEDDED;
11157 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11158 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11159 kern_type = KERN_TYPE_VCSHA256_XTS512;
11160 dgst_size = DGST_SIZE_4_8;
11161 parse_func = veracrypt_parse_hash_500000;
11162 sort_by_digest = sort_by_digest_4_8;
11163 opti_type = OPTI_TYPE_ZERO_BYTE;
11164 dgst_pos0 = 0;
11165 dgst_pos1 = 1;
11166 dgst_pos2 = 2;
11167 dgst_pos3 = 3;
11168 break;
11169
11170 case 13752: hash_type = HASH_TYPE_SHA256;
11171 salt_type = SALT_TYPE_EMBEDDED;
11172 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11173 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11174 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11175 dgst_size = DGST_SIZE_4_8;
11176 parse_func = veracrypt_parse_hash_500000;
11177 sort_by_digest = sort_by_digest_4_8;
11178 opti_type = OPTI_TYPE_ZERO_BYTE;
11179 dgst_pos0 = 0;
11180 dgst_pos1 = 1;
11181 dgst_pos2 = 2;
11182 dgst_pos3 = 3;
11183 break;
11184
11185 case 13753: hash_type = HASH_TYPE_SHA256;
11186 salt_type = SALT_TYPE_EMBEDDED;
11187 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11188 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11189 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11190 dgst_size = DGST_SIZE_4_8;
11191 parse_func = veracrypt_parse_hash_500000;
11192 sort_by_digest = sort_by_digest_4_8;
11193 opti_type = OPTI_TYPE_ZERO_BYTE;
11194 dgst_pos0 = 0;
11195 dgst_pos1 = 1;
11196 dgst_pos2 = 2;
11197 dgst_pos3 = 3;
11198 break;
11199
11200 case 13761: hash_type = HASH_TYPE_SHA256;
11201 salt_type = SALT_TYPE_EMBEDDED;
11202 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11203 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11204 kern_type = KERN_TYPE_VCSHA256_XTS512;
11205 dgst_size = DGST_SIZE_4_8;
11206 parse_func = veracrypt_parse_hash_200000;
11207 sort_by_digest = sort_by_digest_4_8;
11208 opti_type = OPTI_TYPE_ZERO_BYTE;
11209 dgst_pos0 = 0;
11210 dgst_pos1 = 1;
11211 dgst_pos2 = 2;
11212 dgst_pos3 = 3;
11213 break;
11214
11215 case 13762: hash_type = HASH_TYPE_SHA256;
11216 salt_type = SALT_TYPE_EMBEDDED;
11217 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11218 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11219 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11220 dgst_size = DGST_SIZE_4_8;
11221 parse_func = veracrypt_parse_hash_200000;
11222 sort_by_digest = sort_by_digest_4_8;
11223 opti_type = OPTI_TYPE_ZERO_BYTE;
11224 dgst_pos0 = 0;
11225 dgst_pos1 = 1;
11226 dgst_pos2 = 2;
11227 dgst_pos3 = 3;
11228 break;
11229
11230 case 13763: hash_type = HASH_TYPE_SHA256;
11231 salt_type = SALT_TYPE_EMBEDDED;
11232 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11233 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11234 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11235 dgst_size = DGST_SIZE_4_8;
11236 parse_func = veracrypt_parse_hash_200000;
11237 sort_by_digest = sort_by_digest_4_8;
11238 opti_type = OPTI_TYPE_ZERO_BYTE;
11239 dgst_pos0 = 0;
11240 dgst_pos1 = 1;
11241 dgst_pos2 = 2;
11242 dgst_pos3 = 3;
11243 break;
11244
11245 case 13800: hash_type = HASH_TYPE_SHA256;
11246 salt_type = SALT_TYPE_EMBEDDED;
11247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11248 opts_type = OPTS_TYPE_PT_GENERATE_BE
11249 | OPTS_TYPE_PT_UNICODE;
11250 kern_type = KERN_TYPE_WIN8PHONE;
11251 dgst_size = DGST_SIZE_4_8;
11252 parse_func = win8phone_parse_hash;
11253 sort_by_digest = sort_by_digest_4_8;
11254 opti_type = OPTI_TYPE_ZERO_BYTE
11255 | OPTI_TYPE_PRECOMPUTE_INIT
11256 | OPTI_TYPE_EARLY_SKIP
11257 | OPTI_TYPE_NOT_ITERATED
11258 | OPTI_TYPE_RAW_HASH;
11259 dgst_pos0 = 3;
11260 dgst_pos1 = 7;
11261 dgst_pos2 = 2;
11262 dgst_pos3 = 6;
11263 break;
11264
11265 default: usage_mini_print (PROGNAME); return (-1);
11266 }
11267
11268 /**
11269 * parser
11270 */
11271
11272 data.parse_func = parse_func;
11273
11274 /**
11275 * misc stuff
11276 */
11277
11278 if (hex_salt)
11279 {
11280 if (salt_type == SALT_TYPE_INTERN)
11281 {
11282 opts_type |= OPTS_TYPE_ST_HEX;
11283 }
11284 else
11285 {
11286 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11287
11288 return (-1);
11289 }
11290 }
11291
11292 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11293 | (salt_type == SALT_TYPE_EXTERN)
11294 | (salt_type == SALT_TYPE_EMBEDDED)
11295 | (salt_type == SALT_TYPE_VIRTUAL));
11296
11297 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11298
11299 data.hash_type = hash_type;
11300 data.attack_mode = attack_mode;
11301 data.attack_kern = attack_kern;
11302 data.attack_exec = attack_exec;
11303 data.kern_type = kern_type;
11304 data.opts_type = opts_type;
11305 data.dgst_size = dgst_size;
11306 data.salt_type = salt_type;
11307 data.isSalted = isSalted;
11308 data.sort_by_digest = sort_by_digest;
11309 data.dgst_pos0 = dgst_pos0;
11310 data.dgst_pos1 = dgst_pos1;
11311 data.dgst_pos2 = dgst_pos2;
11312 data.dgst_pos3 = dgst_pos3;
11313
11314 esalt_size = 0;
11315
11316 switch (hash_mode)
11317 {
11318 case 2500: esalt_size = sizeof (wpa_t); break;
11319 case 5300: esalt_size = sizeof (ikepsk_t); break;
11320 case 5400: esalt_size = sizeof (ikepsk_t); break;
11321 case 5500: esalt_size = sizeof (netntlm_t); break;
11322 case 5600: esalt_size = sizeof (netntlm_t); break;
11323 case 6211: esalt_size = sizeof (tc_t); break;
11324 case 6212: esalt_size = sizeof (tc_t); break;
11325 case 6213: esalt_size = sizeof (tc_t); break;
11326 case 6221: esalt_size = sizeof (tc_t); break;
11327 case 6222: esalt_size = sizeof (tc_t); break;
11328 case 6223: esalt_size = sizeof (tc_t); break;
11329 case 6231: esalt_size = sizeof (tc_t); break;
11330 case 6232: esalt_size = sizeof (tc_t); break;
11331 case 6233: esalt_size = sizeof (tc_t); break;
11332 case 6241: esalt_size = sizeof (tc_t); break;
11333 case 6242: esalt_size = sizeof (tc_t); break;
11334 case 6243: esalt_size = sizeof (tc_t); break;
11335 case 6600: esalt_size = sizeof (agilekey_t); break;
11336 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11337 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11338 case 7300: esalt_size = sizeof (rakp_t); break;
11339 case 7500: esalt_size = sizeof (krb5pa_t); break;
11340 case 8200: esalt_size = sizeof (cloudkey_t); break;
11341 case 8800: esalt_size = sizeof (androidfde_t); break;
11342 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11343 case 9400: esalt_size = sizeof (office2007_t); break;
11344 case 9500: esalt_size = sizeof (office2010_t); break;
11345 case 9600: esalt_size = sizeof (office2013_t); break;
11346 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11347 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11348 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11349 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11350 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11351 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11352 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11353 case 10200: esalt_size = sizeof (cram_md5_t); break;
11354 case 10400: esalt_size = sizeof (pdf_t); break;
11355 case 10410: esalt_size = sizeof (pdf_t); break;
11356 case 10420: esalt_size = sizeof (pdf_t); break;
11357 case 10500: esalt_size = sizeof (pdf_t); break;
11358 case 10600: esalt_size = sizeof (pdf_t); break;
11359 case 10700: esalt_size = sizeof (pdf_t); break;
11360 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11361 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11362 case 11400: esalt_size = sizeof (sip_t); break;
11363 case 11600: esalt_size = sizeof (seven_zip_t); break;
11364 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11365 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11366 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11367 case 13000: esalt_size = sizeof (rar5_t); break;
11368 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11369 case 13400: esalt_size = sizeof (keepass_t); break;
11370 case 13500: esalt_size = sizeof (pstoken_t); break;
11371 case 13600: esalt_size = sizeof (zip2_t); break;
11372 case 13711: esalt_size = sizeof (tc_t); break;
11373 case 13712: esalt_size = sizeof (tc_t); break;
11374 case 13713: esalt_size = sizeof (tc_t); break;
11375 case 13721: esalt_size = sizeof (tc_t); break;
11376 case 13722: esalt_size = sizeof (tc_t); break;
11377 case 13723: esalt_size = sizeof (tc_t); break;
11378 case 13731: esalt_size = sizeof (tc_t); break;
11379 case 13732: esalt_size = sizeof (tc_t); break;
11380 case 13733: esalt_size = sizeof (tc_t); break;
11381 case 13741: esalt_size = sizeof (tc_t); break;
11382 case 13742: esalt_size = sizeof (tc_t); break;
11383 case 13743: esalt_size = sizeof (tc_t); break;
11384 case 13751: esalt_size = sizeof (tc_t); break;
11385 case 13752: esalt_size = sizeof (tc_t); break;
11386 case 13753: esalt_size = sizeof (tc_t); break;
11387 case 13761: esalt_size = sizeof (tc_t); break;
11388 case 13762: esalt_size = sizeof (tc_t); break;
11389 case 13763: esalt_size = sizeof (tc_t); break;
11390 case 13800: esalt_size = sizeof (win8phone_t); break;
11391 }
11392
11393 data.esalt_size = esalt_size;
11394
11395 /**
11396 * choose dictionary parser
11397 */
11398
11399 if (hash_type == HASH_TYPE_LM)
11400 {
11401 get_next_word_func = get_next_word_lm;
11402 }
11403 else if (opts_type & OPTS_TYPE_PT_UPPER)
11404 {
11405 get_next_word_func = get_next_word_uc;
11406 }
11407 else
11408 {
11409 get_next_word_func = get_next_word_std;
11410 }
11411
11412 /**
11413 * dictstat
11414 */
11415
11416 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11417
11418 #ifdef _POSIX
11419 size_t dictstat_nmemb = 0;
11420 #endif
11421
11422 #ifdef _WIN
11423 uint dictstat_nmemb = 0;
11424 #endif
11425
11426 char dictstat[256] = { 0 };
11427
11428 FILE *dictstat_fp = NULL;
11429
11430 if (keyspace == 0)
11431 {
11432 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11433
11434 dictstat_fp = fopen (dictstat, "rb");
11435
11436 if (dictstat_fp)
11437 {
11438 #ifdef _POSIX
11439 struct stat tmpstat;
11440
11441 fstat (fileno (dictstat_fp), &tmpstat);
11442 #endif
11443
11444 #ifdef _WIN
11445 struct stat64 tmpstat;
11446
11447 _fstat64 (fileno (dictstat_fp), &tmpstat);
11448 #endif
11449
11450 if (tmpstat.st_mtime < COMPTIME)
11451 {
11452 /* with v0.15 the format changed so we have to ensure user is using a good version
11453 since there is no version-header in the dictstat file */
11454
11455 fclose (dictstat_fp);
11456
11457 unlink (dictstat);
11458 }
11459 else
11460 {
11461 while (!feof (dictstat_fp))
11462 {
11463 dictstat_t d;
11464
11465 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11466
11467 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11468
11469 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11470 {
11471 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11472
11473 return -1;
11474 }
11475 }
11476
11477 fclose (dictstat_fp);
11478 }
11479 }
11480 }
11481
11482 /**
11483 * potfile
11484 */
11485
11486 char potfile[256] = { 0 };
11487
11488 if (potfile_path == NULL)
11489 {
11490 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11491 }
11492 else
11493 {
11494 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11495 }
11496
11497 data.pot_fp = NULL;
11498
11499 FILE *out_fp = NULL;
11500 FILE *pot_fp = NULL;
11501
11502 if (show == 1 || left == 1)
11503 {
11504 pot_fp = fopen (potfile, "rb");
11505
11506 if (pot_fp == NULL)
11507 {
11508 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11509
11510 return (-1);
11511 }
11512
11513 if (outfile != NULL)
11514 {
11515 if ((out_fp = fopen (outfile, "ab")) == NULL)
11516 {
11517 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11518
11519 fclose (pot_fp);
11520
11521 return (-1);
11522 }
11523 }
11524 else
11525 {
11526 out_fp = stdout;
11527 }
11528 }
11529 else
11530 {
11531 if (potfile_disable == 0)
11532 {
11533 pot_fp = fopen (potfile, "ab");
11534
11535 if (pot_fp == NULL)
11536 {
11537 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11538
11539 return (-1);
11540 }
11541
11542 data.pot_fp = pot_fp;
11543 }
11544 }
11545
11546 pot_t *pot = NULL;
11547
11548 uint pot_cnt = 0;
11549 uint pot_avail = 0;
11550
11551 if (show == 1 || left == 1)
11552 {
11553 SUPPRESS_OUTPUT = 1;
11554
11555 pot_avail = count_lines (pot_fp);
11556
11557 rewind (pot_fp);
11558
11559 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11560
11561 uint pot_hashes_avail = 0;
11562
11563 uint line_num = 0;
11564
11565 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11566
11567 while (!feof (pot_fp))
11568 {
11569 line_num++;
11570
11571 int line_len = fgetl (pot_fp, line_buf);
11572
11573 if (line_len == 0) continue;
11574
11575 char *plain_buf = line_buf + line_len;
11576
11577 pot_t *pot_ptr = &pot[pot_cnt];
11578
11579 hash_t *hashes_buf = &pot_ptr->hash;
11580
11581 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11582 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11583
11584 if (pot_cnt == pot_hashes_avail)
11585 {
11586 uint pos = 0;
11587
11588 for (pos = 0; pos < INCR_POT; pos++)
11589 {
11590 if ((pot_cnt + pos) >= pot_avail) break;
11591
11592 pot_t *tmp_pot = &pot[pot_cnt + pos];
11593
11594 hash_t *tmp_hash = &tmp_pot->hash;
11595
11596 tmp_hash->digest = mymalloc (dgst_size);
11597
11598 if (isSalted)
11599 {
11600 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11601 }
11602
11603 if (esalt_size)
11604 {
11605 tmp_hash->esalt = mymalloc (esalt_size);
11606 }
11607
11608 pot_hashes_avail++;
11609 }
11610 }
11611
11612 int plain_len = 0;
11613
11614 int parser_status;
11615
11616 int iter = MAX_CUT_TRIES;
11617
11618 do
11619 {
11620 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11621 {
11622 if (line_buf[i] == ':')
11623 {
11624 line_len--;
11625
11626 break;
11627 }
11628 }
11629
11630 if (data.hash_mode != 2500)
11631 {
11632 parser_status = parse_func (line_buf, line_len, hashes_buf);
11633 }
11634 else
11635 {
11636 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11637
11638 if (line_len > max_salt_size)
11639 {
11640 parser_status = PARSER_GLOBAL_LENGTH;
11641 }
11642 else
11643 {
11644 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11645
11646 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11647
11648 hashes_buf->salt->salt_len = line_len;
11649
11650 parser_status = PARSER_OK;
11651 }
11652 }
11653
11654 // if NOT parsed without error, we add the ":" to the plain
11655
11656 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11657 {
11658 plain_len++;
11659 plain_buf--;
11660 }
11661
11662 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11663
11664 if (parser_status < PARSER_GLOBAL_ZERO)
11665 {
11666 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11667
11668 continue;
11669 }
11670
11671 if (plain_len >= 255) continue;
11672
11673 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11674
11675 pot_ptr->plain_len = plain_len;
11676
11677 pot_cnt++;
11678 }
11679
11680 myfree (line_buf);
11681
11682 fclose (pot_fp);
11683
11684 SUPPRESS_OUTPUT = 0;
11685
11686 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11687 }
11688
11689 /**
11690 * word len
11691 */
11692
11693 uint pw_min = PW_MIN;
11694 uint pw_max = PW_MAX;
11695
11696 switch (hash_mode)
11697 {
11698 case 125: if (pw_max > 32) pw_max = 32;
11699 break;
11700 case 400: if (pw_max > 40) pw_max = 40;
11701 break;
11702 case 500: if (pw_max > 16) pw_max = 16;
11703 break;
11704 case 1500: if (pw_max > 8) pw_max = 8;
11705 break;
11706 case 1600: if (pw_max > 16) pw_max = 16;
11707 break;
11708 case 1800: if (pw_max > 16) pw_max = 16;
11709 break;
11710 case 2100: if (pw_max > 16) pw_max = 16;
11711 break;
11712 case 2500: if (pw_min < 8) pw_min = 8;
11713 break;
11714 case 3000: if (pw_max > 7) pw_max = 7;
11715 break;
11716 case 5200: if (pw_max > 24) pw_max = 24;
11717 break;
11718 case 5800: if (pw_max > 16) pw_max = 16;
11719 break;
11720 case 6300: if (pw_max > 16) pw_max = 16;
11721 break;
11722 case 7400: if (pw_max > 16) pw_max = 16;
11723 break;
11724 case 7700: if (pw_max > 8) pw_max = 8;
11725 break;
11726 case 7900: if (pw_max > 48) pw_max = 48;
11727 break;
11728 case 8500: if (pw_max > 8) pw_max = 8;
11729 break;
11730 case 8600: if (pw_max > 16) pw_max = 16;
11731 break;
11732 case 9710: pw_min = 5;
11733 pw_max = 5;
11734 break;
11735 case 9810: pw_min = 5;
11736 pw_max = 5;
11737 break;
11738 case 10410: pw_min = 5;
11739 pw_max = 5;
11740 break;
11741 case 10300: if (pw_max < 3) pw_min = 3;
11742 if (pw_max > 40) pw_max = 40;
11743 break;
11744 case 10500: if (pw_max < 3) pw_min = 3;
11745 if (pw_max > 40) pw_max = 40;
11746 break;
11747 case 10700: if (pw_max > 16) pw_max = 16;
11748 break;
11749 case 11300: if (pw_max > 40) pw_max = 40;
11750 break;
11751 case 11600: if (pw_max > 32) pw_max = 32;
11752 break;
11753 case 12500: if (pw_max > 20) pw_max = 20;
11754 break;
11755 case 12800: if (pw_max > 24) pw_max = 24;
11756 break;
11757 }
11758
11759 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11760 {
11761 switch (attack_kern)
11762 {
11763 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11764 break;
11765 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11766 break;
11767 }
11768 }
11769
11770 /**
11771 * charsets : keep them together for more easy maintainnce
11772 */
11773
11774 cs_t mp_sys[6] = { { { 0 }, 0 } };
11775 cs_t mp_usr[4] = { { { 0 }, 0 } };
11776
11777 mp_setup_sys (mp_sys);
11778
11779 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11780 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11781 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11782 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11783
11784 /**
11785 * load hashes, part I: find input mode, count hashes
11786 */
11787
11788 uint hashlist_mode = 0;
11789 uint hashlist_format = HLFMT_HASHCAT;
11790
11791 uint hashes_avail = 0;
11792
11793 if ((benchmark == 0) && (stdout_flag == 0))
11794 {
11795 struct stat f;
11796
11797 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11798
11799 if ((hash_mode == 2500) ||
11800 (hash_mode == 5200) ||
11801 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11802 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11803 (hash_mode == 9000))
11804 {
11805 hashlist_mode = HL_MODE_ARG;
11806
11807 char *hashfile = myargv[optind];
11808
11809 data.hashfile = hashfile;
11810
11811 logfile_top_var_string ("target", hashfile);
11812 }
11813
11814 if (hashlist_mode == HL_MODE_ARG)
11815 {
11816 if (hash_mode == 2500)
11817 {
11818 struct stat st;
11819
11820 if (stat (data.hashfile, &st) == -1)
11821 {
11822 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11823
11824 return (-1);
11825 }
11826
11827 hashes_avail = st.st_size / sizeof (hccap_t);
11828 }
11829 else
11830 {
11831 hashes_avail = 1;
11832 }
11833 }
11834 else if (hashlist_mode == HL_MODE_FILE)
11835 {
11836 char *hashfile = myargv[optind];
11837
11838 data.hashfile = hashfile;
11839
11840 logfile_top_var_string ("target", hashfile);
11841
11842 FILE *fp = NULL;
11843
11844 if ((fp = fopen (hashfile, "rb")) == NULL)
11845 {
11846 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11847
11848 return (-1);
11849 }
11850
11851 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11852
11853 hashes_avail = count_lines (fp);
11854
11855 rewind (fp);
11856
11857 if (hashes_avail == 0)
11858 {
11859 log_error ("ERROR: hashfile is empty or corrupt");
11860
11861 fclose (fp);
11862
11863 return (-1);
11864 }
11865
11866 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11867
11868 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11869 {
11870 log_error ("ERROR: remove not supported in native hashfile-format mode");
11871
11872 fclose (fp);
11873
11874 return (-1);
11875 }
11876
11877 fclose (fp);
11878 }
11879 }
11880 else
11881 {
11882 hashlist_mode = HL_MODE_ARG;
11883
11884 hashes_avail = 1;
11885 }
11886
11887 if (hash_mode == 3000) hashes_avail *= 2;
11888
11889 data.hashlist_mode = hashlist_mode;
11890 data.hashlist_format = hashlist_format;
11891
11892 logfile_top_uint (hashlist_mode);
11893 logfile_top_uint (hashlist_format);
11894
11895 /**
11896 * load hashes, part II: allocate required memory, set pointers
11897 */
11898
11899 hash_t *hashes_buf = NULL;
11900 void *digests_buf = NULL;
11901 salt_t *salts_buf = NULL;
11902 void *esalts_buf = NULL;
11903
11904 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11905
11906 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11907
11908 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11909 {
11910 u32 hash_pos;
11911
11912 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11913 {
11914 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11915
11916 hashes_buf[hash_pos].hash_info = hash_info;
11917
11918 if (username && (remove || show || left))
11919 {
11920 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11921 }
11922
11923 if (benchmark)
11924 {
11925 hash_info->orighash = (char *) mymalloc (256);
11926 }
11927 }
11928 }
11929
11930 if (isSalted)
11931 {
11932 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11933
11934 if (esalt_size)
11935 {
11936 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11937 }
11938 }
11939 else
11940 {
11941 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11942 }
11943
11944 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11945 {
11946 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11947
11948 if (isSalted)
11949 {
11950 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11951
11952 if (esalt_size)
11953 {
11954 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11955 }
11956 }
11957 else
11958 {
11959 hashes_buf[hash_pos].salt = &salts_buf[0];
11960 }
11961 }
11962
11963 /**
11964 * load hashes, part III: parse hashes or generate them if benchmark
11965 */
11966
11967 uint hashes_cnt = 0;
11968
11969 if (benchmark == 0)
11970 {
11971 if (keyspace == 1)
11972 {
11973 // useless to read hash file for keyspace, cheat a little bit w/ optind
11974 }
11975 else if (stdout_flag == 1)
11976 {
11977 // useless to read hash file for stdout, cheat a little bit w/ optind
11978 }
11979 else if (hashes_avail == 0)
11980 {
11981 }
11982 else if (hashlist_mode == HL_MODE_ARG)
11983 {
11984 char *input_buf = myargv[optind];
11985
11986 uint input_len = strlen (input_buf);
11987
11988 logfile_top_var_string ("target", input_buf);
11989
11990 char *hash_buf = NULL;
11991 int hash_len = 0;
11992
11993 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11994
11995 bool hash_fmt_error = 0;
11996
11997 if (hash_len < 1) hash_fmt_error = 1;
11998 if (hash_buf == NULL) hash_fmt_error = 1;
11999
12000 if (hash_fmt_error)
12001 {
12002 log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12003 }
12004 else
12005 {
12006 if (opts_type & OPTS_TYPE_HASH_COPY)
12007 {
12008 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12009
12010 hash_info_tmp->orighash = mystrdup (hash_buf);
12011 }
12012
12013 if (isSalted)
12014 {
12015 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
12016 }
12017
12018 int parser_status = PARSER_OK;
12019
12020 if (hash_mode == 2500)
12021 {
12022 if (hash_len == 0)
12023 {
12024 log_error ("ERROR: hccap file not specified");
12025
12026 return (-1);
12027 }
12028
12029 hashlist_mode = HL_MODE_FILE;
12030
12031 data.hashlist_mode = hashlist_mode;
12032
12033 FILE *fp = fopen (hash_buf, "rb");
12034
12035 if (fp == NULL)
12036 {
12037 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
12038
12039 return (-1);
12040 }
12041
12042 if (hashes_avail < 1)
12043 {
12044 log_error ("ERROR: hccap file is empty or corrupt");
12045
12046 fclose (fp);
12047
12048 return (-1);
12049 }
12050
12051 uint hccap_size = sizeof (hccap_t);
12052
12053 char *in = (char *) mymalloc (hccap_size);
12054
12055 while (!feof (fp))
12056 {
12057 int n = fread (in, hccap_size, 1, fp);
12058
12059 if (n != 1)
12060 {
12061 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
12062
12063 break;
12064 }
12065
12066 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12067
12068 if (parser_status != PARSER_OK)
12069 {
12070 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12071
12072 continue;
12073 }
12074
12075 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12076
12077 if ((show == 1) || (left == 1))
12078 {
12079 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12080
12081 char *salt_ptr = (char *) tmp_salt->salt_buf;
12082
12083 int cur_pos = tmp_salt->salt_len;
12084 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12085
12086 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12087
12088 // do the appending task
12089
12090 snprintf (salt_ptr + cur_pos,
12091 rem_len,
12092 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12093 wpa->orig_mac1[0],
12094 wpa->orig_mac1[1],
12095 wpa->orig_mac1[2],
12096 wpa->orig_mac1[3],
12097 wpa->orig_mac1[4],
12098 wpa->orig_mac1[5],
12099 wpa->orig_mac2[0],
12100 wpa->orig_mac2[1],
12101 wpa->orig_mac2[2],
12102 wpa->orig_mac2[3],
12103 wpa->orig_mac2[4],
12104 wpa->orig_mac2[5]);
12105
12106 // memset () the remaining part of the salt
12107
12108 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12109 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12110
12111 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12112
12113 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12114 }
12115
12116 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);
12117 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);
12118
12119 hashes_cnt++;
12120 }
12121
12122 fclose (fp);
12123
12124 myfree (in);
12125 }
12126 else if (hash_mode == 3000)
12127 {
12128 if (hash_len == 32)
12129 {
12130 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12131
12132 hash_t *lm_hash_left = NULL;
12133
12134 if (parser_status == PARSER_OK)
12135 {
12136 lm_hash_left = &hashes_buf[hashes_cnt];
12137
12138 hashes_cnt++;
12139 }
12140 else
12141 {
12142 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12143 }
12144
12145 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12146
12147 hash_t *lm_hash_right = NULL;
12148
12149 if (parser_status == PARSER_OK)
12150 {
12151 lm_hash_right = &hashes_buf[hashes_cnt];
12152
12153 hashes_cnt++;
12154 }
12155 else
12156 {
12157 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12158 }
12159
12160 // show / left
12161
12162 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12163 {
12164 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);
12165 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);
12166 }
12167 }
12168 else
12169 {
12170 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12171
12172 if (parser_status == PARSER_OK)
12173 {
12174 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12175 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12176 }
12177
12178 if (parser_status == PARSER_OK)
12179 {
12180 hashes_cnt++;
12181 }
12182 else
12183 {
12184 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12185 }
12186 }
12187 }
12188 else
12189 {
12190 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12191
12192 if (parser_status == PARSER_OK)
12193 {
12194 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12195 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12196 }
12197
12198 if (parser_status == PARSER_OK)
12199 {
12200 hashes_cnt++;
12201 }
12202 else
12203 {
12204 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12205 }
12206 }
12207 }
12208 }
12209 else if (hashlist_mode == HL_MODE_FILE)
12210 {
12211 char *hashfile = data.hashfile;
12212
12213 FILE *fp;
12214
12215 if ((fp = fopen (hashfile, "rb")) == NULL)
12216 {
12217 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12218
12219 return (-1);
12220 }
12221
12222 uint line_num = 0;
12223
12224 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12225
12226 while (!feof (fp))
12227 {
12228 line_num++;
12229
12230 int line_len = fgetl (fp, line_buf);
12231
12232 if (line_len == 0) continue;
12233
12234 char *hash_buf = NULL;
12235 int hash_len = 0;
12236
12237 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12238
12239 bool hash_fmt_error = 0;
12240
12241 if (hash_len < 1) hash_fmt_error = 1;
12242 if (hash_buf == NULL) hash_fmt_error = 1;
12243
12244 if (hash_fmt_error)
12245 {
12246 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12247
12248 continue;
12249 }
12250
12251 if (username)
12252 {
12253 char *user_buf = NULL;
12254 int user_len = 0;
12255
12256 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12257
12258 if (remove || show)
12259 {
12260 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12261
12262 *user = (user_t *) mymalloc (sizeof (user_t));
12263
12264 user_t *user_ptr = *user;
12265
12266 if (user_buf != NULL)
12267 {
12268 user_ptr->user_name = mystrdup (user_buf);
12269 }
12270 else
12271 {
12272 user_ptr->user_name = mystrdup ("");
12273 }
12274
12275 user_ptr->user_len = user_len;
12276 }
12277 }
12278
12279 if (opts_type & OPTS_TYPE_HASH_COPY)
12280 {
12281 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12282
12283 hash_info_tmp->orighash = mystrdup (hash_buf);
12284 }
12285
12286 if (isSalted)
12287 {
12288 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12289 }
12290
12291 if (hash_mode == 3000)
12292 {
12293 if (hash_len == 32)
12294 {
12295 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12296
12297 if (parser_status < PARSER_GLOBAL_ZERO)
12298 {
12299 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12300
12301 continue;
12302 }
12303
12304 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12305
12306 hashes_cnt++;
12307
12308 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12309
12310 if (parser_status < PARSER_GLOBAL_ZERO)
12311 {
12312 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12313
12314 continue;
12315 }
12316
12317 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12318
12319 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);
12320
12321 hashes_cnt++;
12322
12323 // show / left
12324
12325 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);
12326 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);
12327 }
12328 else
12329 {
12330 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12331
12332 if (parser_status < PARSER_GLOBAL_ZERO)
12333 {
12334 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12335
12336 continue;
12337 }
12338
12339 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);
12340
12341 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12342 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12343
12344 hashes_cnt++;
12345 }
12346 }
12347 else
12348 {
12349 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12350
12351 if (parser_status < PARSER_GLOBAL_ZERO)
12352 {
12353 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12354
12355 continue;
12356 }
12357
12358 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);
12359
12360 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12361 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12362
12363 hashes_cnt++;
12364 }
12365 }
12366
12367 myfree (line_buf);
12368
12369 fclose (fp);
12370
12371 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12372
12373 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12374 }
12375 }
12376 else
12377 {
12378 if (isSalted)
12379 {
12380 hashes_buf[0].salt->salt_len = 8;
12381
12382 // special salt handling
12383
12384 switch (hash_mode)
12385 {
12386 case 1500: hashes_buf[0].salt->salt_len = 2;
12387 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12388 break;
12389 case 1731: hashes_buf[0].salt->salt_len = 4;
12390 break;
12391 case 2410: hashes_buf[0].salt->salt_len = 4;
12392 break;
12393 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12394 break;
12395 case 3100: hashes_buf[0].salt->salt_len = 1;
12396 break;
12397 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12398 break;
12399 case 5800: hashes_buf[0].salt->salt_len = 16;
12400 break;
12401 case 6800: hashes_buf[0].salt->salt_len = 32;
12402 break;
12403 case 8400: hashes_buf[0].salt->salt_len = 40;
12404 break;
12405 case 8800: hashes_buf[0].salt->salt_len = 16;
12406 break;
12407 case 8900: hashes_buf[0].salt->salt_len = 16;
12408 hashes_buf[0].salt->scrypt_N = 1024;
12409 hashes_buf[0].salt->scrypt_r = 1;
12410 hashes_buf[0].salt->scrypt_p = 1;
12411 break;
12412 case 9100: hashes_buf[0].salt->salt_len = 16;
12413 break;
12414 case 9300: hashes_buf[0].salt->salt_len = 14;
12415 hashes_buf[0].salt->scrypt_N = 16384;
12416 hashes_buf[0].salt->scrypt_r = 1;
12417 hashes_buf[0].salt->scrypt_p = 1;
12418 break;
12419 case 9400: hashes_buf[0].salt->salt_len = 16;
12420 break;
12421 case 9500: hashes_buf[0].salt->salt_len = 16;
12422 break;
12423 case 9600: hashes_buf[0].salt->salt_len = 16;
12424 break;
12425 case 9700: hashes_buf[0].salt->salt_len = 16;
12426 break;
12427 case 9710: hashes_buf[0].salt->salt_len = 16;
12428 break;
12429 case 9720: hashes_buf[0].salt->salt_len = 16;
12430 break;
12431 case 9800: hashes_buf[0].salt->salt_len = 16;
12432 break;
12433 case 9810: hashes_buf[0].salt->salt_len = 16;
12434 break;
12435 case 9820: hashes_buf[0].salt->salt_len = 16;
12436 break;
12437 case 10300: hashes_buf[0].salt->salt_len = 12;
12438 break;
12439 case 11500: hashes_buf[0].salt->salt_len = 4;
12440 break;
12441 case 11600: hashes_buf[0].salt->salt_len = 4;
12442 break;
12443 case 12400: hashes_buf[0].salt->salt_len = 4;
12444 break;
12445 case 12500: hashes_buf[0].salt->salt_len = 8;
12446 break;
12447 case 12600: hashes_buf[0].salt->salt_len = 64;
12448 break;
12449 }
12450
12451 // special esalt handling
12452
12453 switch (hash_mode)
12454 {
12455 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12456 break;
12457 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12458 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12459 break;
12460 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12461 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12462 break;
12463 case 5500: ((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 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12469 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12470 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12471 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12472 break;
12473 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12474 break;
12475 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12476 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12477 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12478 break;
12479 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12480 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12481 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12482 break;
12483 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12484 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12485 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12486 break;
12487 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12488 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12489 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12490 break;
12491 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12492 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12493 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12494 break;
12495 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12496 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12497 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12498 break;
12499 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12500 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12501 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12502 break;
12503 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12504 break;
12505 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12506 break;
12507 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12508 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12509 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12510 break;
12511 }
12512 }
12513
12514 // set hashfile
12515
12516 switch (hash_mode)
12517 {
12518 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12519 break;
12520 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12521 break;
12522 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12523 break;
12524 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12525 break;
12526 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12527 break;
12528 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12529 break;
12530 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12531 break;
12532 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12533 break;
12534 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12535 break;
12536 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12537 break;
12538 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12539 break;
12540 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12541 break;
12542 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12543 break;
12544 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12545 break;
12546 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12547 break;
12548 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12549 break;
12550 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12551 break;
12552 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12553 break;
12554 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12555 break;
12556 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12557 break;
12558 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12559 break;
12560 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12561 break;
12562 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12563 break;
12564 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12565 break;
12566 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12567 break;
12568 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12569 break;
12570 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12571 break;
12572 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12573 break;
12574 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12575 break;
12576 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12577 break;
12578 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12579 break;
12580 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12581 break;
12582 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12583 break;
12584 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12585 break;
12586 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12587 break;
12588 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12589 break;
12590 }
12591
12592 // set default iterations
12593
12594 switch (hash_mode)
12595 {
12596 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12597 break;
12598 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12599 break;
12600 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12601 break;
12602 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12603 break;
12604 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12605 break;
12606 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12607 break;
12608 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12609 break;
12610 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12611 break;
12612 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12613 break;
12614 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12615 break;
12616 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12617 break;
12618 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12619 break;
12620 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12621 break;
12622 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12623 break;
12624 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12625 break;
12626 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12627 break;
12628 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12629 break;
12630 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12631 break;
12632 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12633 break;
12634 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12635 break;
12636 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12637 break;
12638 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12639 break;
12640 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12641 break;
12642 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12643 break;
12644 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12645 break;
12646 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12647 break;
12648 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12649 break;
12650 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12651 break;
12652 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12653 break;
12654 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12655 break;
12656 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12657 break;
12658 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12659 break;
12660 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12661 break;
12662 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12663 break;
12664 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12665 break;
12666 case 8900: hashes_buf[0].salt->salt_iter = 1;
12667 break;
12668 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12669 break;
12670 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12671 break;
12672 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12673 break;
12674 case 9300: hashes_buf[0].salt->salt_iter = 1;
12675 break;
12676 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12677 break;
12678 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12679 break;
12680 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12681 break;
12682 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12683 break;
12684 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12685 break;
12686 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12687 break;
12688 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12689 break;
12690 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12691 break;
12692 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12693 break;
12694 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12695 break;
12696 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12697 break;
12698 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12699 break;
12700 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12701 break;
12702 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12703 break;
12704 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12705 break;
12706 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12707 break;
12708 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12709 break;
12710 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12711 break;
12712 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12713 break;
12714 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12715 break;
12716 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12717 break;
12718 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12719 break;
12720 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12721 break;
12722 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12723 break;
12724 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12725 break;
12726 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12727 break;
12728 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12729 break;
12730 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12731 break;
12732 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12733 break;
12734 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12735 break;
12736 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12737 break;
12738 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12739 break;
12740 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12741 break;
12742 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12743 break;
12744 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12745 break;
12746 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12747 break;
12748 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12749 break;
12750 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12751 break;
12752 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12753 break;
12754 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12755 break;
12756 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12757 break;
12758 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12759 break;
12760 }
12761
12762 hashes_cnt = 1;
12763 }
12764
12765 if (show == 1 || left == 1)
12766 {
12767 for (uint i = 0; i < pot_cnt; i++)
12768 {
12769 pot_t *pot_ptr = &pot[i];
12770
12771 hash_t *hashes_buf = &pot_ptr->hash;
12772
12773 local_free (hashes_buf->digest);
12774
12775 if (isSalted)
12776 {
12777 local_free (hashes_buf->salt);
12778 }
12779 }
12780
12781 local_free (pot);
12782
12783 if (data.quiet == 0) log_info_nn ("");
12784
12785 return (0);
12786 }
12787
12788 if ((keyspace == 0) && (stdout_flag == 0))
12789 {
12790 if (hashes_cnt == 0)
12791 {
12792 log_error ("ERROR: No hashes loaded");
12793
12794 return (-1);
12795 }
12796 }
12797
12798 /**
12799 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12800 */
12801
12802 if (data.outfile != NULL)
12803 {
12804 if (data.hashfile != NULL)
12805 {
12806 #ifdef _POSIX
12807 struct stat tmpstat_outfile;
12808 struct stat tmpstat_hashfile;
12809 #endif
12810
12811 #ifdef _WIN
12812 struct stat64 tmpstat_outfile;
12813 struct stat64 tmpstat_hashfile;
12814 #endif
12815
12816 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12817
12818 if (tmp_outfile_fp)
12819 {
12820 #ifdef _POSIX
12821 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12822 #endif
12823
12824 #ifdef _WIN
12825 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12826 #endif
12827
12828 fclose (tmp_outfile_fp);
12829 }
12830
12831 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12832
12833 if (tmp_hashfile_fp)
12834 {
12835 #ifdef _POSIX
12836 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12837 #endif
12838
12839 #ifdef _WIN
12840 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12841 #endif
12842
12843 fclose (tmp_hashfile_fp);
12844 }
12845
12846 if (tmp_outfile_fp && tmp_outfile_fp)
12847 {
12848 tmpstat_outfile.st_mode = 0;
12849 tmpstat_outfile.st_nlink = 0;
12850 tmpstat_outfile.st_uid = 0;
12851 tmpstat_outfile.st_gid = 0;
12852 tmpstat_outfile.st_rdev = 0;
12853 tmpstat_outfile.st_atime = 0;
12854
12855 tmpstat_hashfile.st_mode = 0;
12856 tmpstat_hashfile.st_nlink = 0;
12857 tmpstat_hashfile.st_uid = 0;
12858 tmpstat_hashfile.st_gid = 0;
12859 tmpstat_hashfile.st_rdev = 0;
12860 tmpstat_hashfile.st_atime = 0;
12861
12862 #ifdef _POSIX
12863 tmpstat_outfile.st_blksize = 0;
12864 tmpstat_outfile.st_blocks = 0;
12865
12866 tmpstat_hashfile.st_blksize = 0;
12867 tmpstat_hashfile.st_blocks = 0;
12868 #endif
12869
12870 #ifdef _POSIX
12871 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12872 {
12873 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12874
12875 return (-1);
12876 }
12877 #endif
12878
12879 #ifdef _WIN
12880 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12881 {
12882 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12883
12884 return (-1);
12885 }
12886 #endif
12887 }
12888 }
12889 }
12890
12891 /**
12892 * Remove duplicates
12893 */
12894
12895 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12896
12897 if (isSalted)
12898 {
12899 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12900 }
12901 else
12902 {
12903 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12904 }
12905
12906 uint hashes_cnt_orig = hashes_cnt;
12907
12908 hashes_cnt = 1;
12909
12910 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12911 {
12912 if (isSalted)
12913 {
12914 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12915 {
12916 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12917 }
12918 }
12919 else
12920 {
12921 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12922 }
12923
12924 if (hashes_pos > hashes_cnt)
12925 {
12926 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12927 }
12928
12929 hashes_cnt++;
12930 }
12931
12932 /**
12933 * Potfile removes
12934 */
12935
12936 uint potfile_remove_cracks = 0;
12937
12938 if (potfile_disable == 0)
12939 {
12940 hash_t hash_buf;
12941
12942 hash_buf.digest = mymalloc (dgst_size);
12943 hash_buf.salt = NULL;
12944 hash_buf.esalt = NULL;
12945 hash_buf.hash_info = NULL;
12946 hash_buf.cracked = 0;
12947
12948 if (isSalted)
12949 {
12950 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12951 }
12952
12953 if (esalt_size)
12954 {
12955 hash_buf.esalt = mymalloc (esalt_size);
12956 }
12957
12958 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12959
12960 // no solution for these special hash types (for instane because they use hashfile in output etc)
12961 if ((hash_mode != 5200) &&
12962 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12963 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12964 (hash_mode != 9000))
12965 {
12966 FILE *fp = fopen (potfile, "rb");
12967
12968 if (fp != NULL)
12969 {
12970 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12971
12972 // to be safe work with a copy (because of line_len loop, i etc)
12973 // moved up here because it's easier to handle continue case
12974 // it's just 64kb
12975
12976 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12977
12978 while (!feof (fp))
12979 {
12980 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12981
12982 if (ptr == NULL) break;
12983
12984 int line_len = strlen (line_buf);
12985
12986 if (line_len == 0) continue;
12987
12988 int iter = MAX_CUT_TRIES;
12989
12990 for (int i = line_len - 1; i && iter; i--, line_len--)
12991 {
12992 if (line_buf[i] != ':') continue;
12993
12994 if (isSalted)
12995 {
12996 memset (hash_buf.salt, 0, sizeof (salt_t));
12997 }
12998
12999 hash_t *found = NULL;
13000
13001 if (hash_mode == 6800)
13002 {
13003 if (i < 64) // 64 = 16 * uint in salt_buf[]
13004 {
13005 // manipulate salt_buf
13006 memcpy (hash_buf.salt->salt_buf, line_buf, i);
13007
13008 hash_buf.salt->salt_len = i;
13009
13010 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
13011 }
13012 }
13013 else if (hash_mode == 2500)
13014 {
13015 if (i < 64) // 64 = 16 * uint in salt_buf[]
13016 {
13017 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
13018 // manipulate salt_buf
13019
13020 memcpy (line_buf_cpy, line_buf, i);
13021
13022 char *mac2_pos = strrchr (line_buf_cpy, ':');
13023
13024 if (mac2_pos == NULL) continue;
13025
13026 mac2_pos[0] = 0;
13027 mac2_pos++;
13028
13029 if (strlen (mac2_pos) != 12) continue;
13030
13031 char *mac1_pos = strrchr (line_buf_cpy, ':');
13032
13033 if (mac1_pos == NULL) continue;
13034
13035 mac1_pos[0] = 0;
13036 mac1_pos++;
13037
13038 if (strlen (mac1_pos) != 12) continue;
13039
13040 uint essid_length = mac1_pos - line_buf_cpy - 1;
13041
13042 // here we need the ESSID
13043 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
13044
13045 hash_buf.salt->salt_len = essid_length;
13046
13047 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
13048
13049 if (found)
13050 {
13051 wpa_t *wpa = (wpa_t *) found->esalt;
13052
13053 // compare hex string(s) vs binary MAC address(es)
13054
13055 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13056 {
13057 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
13058 {
13059 found = NULL;
13060
13061 break;
13062 }
13063 }
13064
13065 // early skip ;)
13066 if (!found) continue;
13067
13068 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13069 {
13070 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13071 {
13072 found = NULL;
13073
13074 break;
13075 }
13076 }
13077 }
13078 }
13079 }
13080 else
13081 {
13082 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13083
13084 if (parser_status == PARSER_OK)
13085 {
13086 if (isSalted)
13087 {
13088 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13089 }
13090 else
13091 {
13092 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13093 }
13094 }
13095 }
13096
13097 if (found == NULL) continue;
13098
13099 if (!found->cracked) potfile_remove_cracks++;
13100
13101 found->cracked = 1;
13102
13103 if (found) break;
13104
13105 iter--;
13106 }
13107 }
13108
13109 myfree (line_buf_cpy);
13110
13111 myfree (line_buf);
13112
13113 fclose (fp);
13114 }
13115 }
13116
13117 if (esalt_size)
13118 {
13119 local_free (hash_buf.esalt);
13120 }
13121
13122 if (isSalted)
13123 {
13124 local_free (hash_buf.salt);
13125 }
13126
13127 local_free (hash_buf.digest);
13128 }
13129
13130 /**
13131 * Now generate all the buffers required for later
13132 */
13133
13134 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13135
13136 salt_t *salts_buf_new = NULL;
13137 void *esalts_buf_new = NULL;
13138
13139 if (isSalted)
13140 {
13141 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13142
13143 if (esalt_size)
13144 {
13145 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13146 }
13147 }
13148 else
13149 {
13150 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13151 }
13152
13153 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13154
13155 uint digests_cnt = hashes_cnt;
13156 uint digests_done = 0;
13157
13158 size_t size_digests = digests_cnt * dgst_size;
13159 size_t size_shown = digests_cnt * sizeof (uint);
13160
13161 uint *digests_shown = (uint *) mymalloc (size_shown);
13162 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13163
13164 uint salts_cnt = 0;
13165 uint salts_done = 0;
13166
13167 hashinfo_t **hash_info = NULL;
13168
13169 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13170 {
13171 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13172
13173 if (username && (remove || show))
13174 {
13175 uint user_pos;
13176
13177 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13178 {
13179 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13180
13181 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13182 }
13183 }
13184 }
13185
13186 uint *salts_shown = (uint *) mymalloc (size_shown);
13187
13188 salt_t *salt_buf;
13189
13190 {
13191 // copied from inner loop
13192
13193 salt_buf = &salts_buf_new[salts_cnt];
13194
13195 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13196
13197 if (esalt_size)
13198 {
13199 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13200 }
13201
13202 salt_buf->digests_cnt = 0;
13203 salt_buf->digests_done = 0;
13204 salt_buf->digests_offset = 0;
13205
13206 salts_cnt++;
13207 }
13208
13209 if (hashes_buf[0].cracked == 1)
13210 {
13211 digests_shown[0] = 1;
13212
13213 digests_done++;
13214
13215 salt_buf->digests_done++;
13216 }
13217
13218 salt_buf->digests_cnt++;
13219
13220 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13221
13222 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13223 {
13224 hash_info[0] = hashes_buf[0].hash_info;
13225 }
13226
13227 // copy from inner loop
13228
13229 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13230 {
13231 if (isSalted)
13232 {
13233 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13234 {
13235 salt_buf = &salts_buf_new[salts_cnt];
13236
13237 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13238
13239 if (esalt_size)
13240 {
13241 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13242 }
13243
13244 salt_buf->digests_cnt = 0;
13245 salt_buf->digests_done = 0;
13246 salt_buf->digests_offset = hashes_pos;
13247
13248 salts_cnt++;
13249 }
13250 }
13251
13252 if (hashes_buf[hashes_pos].cracked == 1)
13253 {
13254 digests_shown[hashes_pos] = 1;
13255
13256 digests_done++;
13257
13258 salt_buf->digests_done++;
13259 }
13260
13261 salt_buf->digests_cnt++;
13262
13263 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13264
13265 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13266 {
13267 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13268 }
13269 }
13270
13271 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13272 {
13273 salt_t *salt_buf = &salts_buf_new[salt_pos];
13274
13275 if (salt_buf->digests_done == salt_buf->digests_cnt)
13276 {
13277 salts_shown[salt_pos] = 1;
13278
13279 salts_done++;
13280 }
13281
13282 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13283 }
13284
13285 local_free (digests_buf);
13286 local_free (salts_buf);
13287 local_free (esalts_buf);
13288
13289 digests_buf = digests_buf_new;
13290 salts_buf = salts_buf_new;
13291 esalts_buf = esalts_buf_new;
13292
13293 local_free (hashes_buf);
13294
13295 /**
13296 * special modification not set from parser
13297 */
13298
13299 switch (hash_mode)
13300 {
13301 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13302 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13303 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13304 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13305 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13306 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13307 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13308 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13309 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13310 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13311 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13312 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13313 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13314 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13315 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13316 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13317 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13318 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13319 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13320 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13321 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13322 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13323 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13324 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13325 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13326 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13327 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13328 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13329 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13330 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13331 }
13332
13333 if (truecrypt_keyfiles)
13334 {
13335 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13336
13337 char *keyfiles = strdup (truecrypt_keyfiles);
13338
13339 char *keyfile = strtok (keyfiles, ",");
13340
13341 do
13342 {
13343 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13344
13345 } while ((keyfile = strtok (NULL, ",")) != NULL);
13346
13347 free (keyfiles);
13348 }
13349
13350 if (veracrypt_keyfiles)
13351 {
13352 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13353
13354 char *keyfiles = strdup (veracrypt_keyfiles);
13355
13356 char *keyfile = strtok (keyfiles, ",");
13357
13358 do
13359 {
13360 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13361
13362 } while ((keyfile = strtok (NULL, ",")) != NULL);
13363
13364 free (keyfiles);
13365 }
13366
13367 data.digests_cnt = digests_cnt;
13368 data.digests_done = digests_done;
13369 data.digests_buf = digests_buf;
13370 data.digests_shown = digests_shown;
13371 data.digests_shown_tmp = digests_shown_tmp;
13372
13373 data.salts_cnt = salts_cnt;
13374 data.salts_done = salts_done;
13375 data.salts_buf = salts_buf;
13376 data.salts_shown = salts_shown;
13377
13378 data.esalts_buf = esalts_buf;
13379 data.hash_info = hash_info;
13380
13381 /**
13382 * Automatic Optimizers
13383 */
13384
13385 if (salts_cnt == 1)
13386 opti_type |= OPTI_TYPE_SINGLE_SALT;
13387
13388 if (digests_cnt == 1)
13389 opti_type |= OPTI_TYPE_SINGLE_HASH;
13390
13391 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13392 opti_type |= OPTI_TYPE_NOT_ITERATED;
13393
13394 if (attack_mode == ATTACK_MODE_BF)
13395 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13396
13397 data.opti_type = opti_type;
13398
13399 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13400 {
13401 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13402 {
13403 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13404 {
13405 if (opts_type & OPTS_TYPE_ST_ADD80)
13406 {
13407 opts_type &= ~OPTS_TYPE_ST_ADD80;
13408 opts_type |= OPTS_TYPE_PT_ADD80;
13409 }
13410
13411 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13412 {
13413 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13414 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13415 }
13416
13417 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13418 {
13419 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13420 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13421 }
13422 }
13423 }
13424 }
13425
13426 /**
13427 * Some algorithm, like descrypt, can benefit from JIT compilation
13428 */
13429
13430 int force_jit_compilation = -1;
13431
13432 if (hash_mode == 8900)
13433 {
13434 force_jit_compilation = 8900;
13435 }
13436 else if (hash_mode == 9300)
13437 {
13438 force_jit_compilation = 8900;
13439 }
13440 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13441 {
13442 force_jit_compilation = 1500;
13443 }
13444
13445 /**
13446 * generate bitmap tables
13447 */
13448
13449 const uint bitmap_shift1 = 5;
13450 const uint bitmap_shift2 = 13;
13451
13452 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13453
13454 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13455 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13456 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13457 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13458 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13459 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13460 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13461 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13462
13463 uint bitmap_bits;
13464 uint bitmap_nums;
13465 uint bitmap_mask;
13466 uint bitmap_size;
13467
13468 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13469 {
13470 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13471
13472 bitmap_nums = 1 << bitmap_bits;
13473
13474 bitmap_mask = bitmap_nums - 1;
13475
13476 bitmap_size = bitmap_nums * sizeof (uint);
13477
13478 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13479
13480 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;
13481 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;
13482
13483 break;
13484 }
13485
13486 bitmap_nums = 1 << bitmap_bits;
13487
13488 bitmap_mask = bitmap_nums - 1;
13489
13490 bitmap_size = bitmap_nums * sizeof (uint);
13491
13492 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);
13493 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);
13494
13495 /**
13496 * prepare quick rule
13497 */
13498
13499 data.rule_buf_l = rule_buf_l;
13500 data.rule_buf_r = rule_buf_r;
13501
13502 int rule_len_l = (int) strlen (rule_buf_l);
13503 int rule_len_r = (int) strlen (rule_buf_r);
13504
13505 data.rule_len_l = rule_len_l;
13506 data.rule_len_r = rule_len_r;
13507
13508 /**
13509 * load rules
13510 */
13511
13512 uint *all_kernel_rules_cnt = NULL;
13513
13514 kernel_rule_t **all_kernel_rules_buf = NULL;
13515
13516 if (rp_files_cnt)
13517 {
13518 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13519
13520 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13521 }
13522
13523 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13524
13525 int rule_len = 0;
13526
13527 for (uint i = 0; i < rp_files_cnt; i++)
13528 {
13529 uint kernel_rules_avail = 0;
13530
13531 uint kernel_rules_cnt = 0;
13532
13533 kernel_rule_t *kernel_rules_buf = NULL;
13534
13535 char *rp_file = rp_files[i];
13536
13537 char in[BLOCK_SIZE] = { 0 };
13538 char out[BLOCK_SIZE] = { 0 };
13539
13540 FILE *fp = NULL;
13541
13542 uint rule_line = 0;
13543
13544 if ((fp = fopen (rp_file, "rb")) == NULL)
13545 {
13546 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13547
13548 return (-1);
13549 }
13550
13551 while (!feof (fp))
13552 {
13553 memset (rule_buf, 0, HCBUFSIZ);
13554
13555 rule_len = fgetl (fp, rule_buf);
13556
13557 rule_line++;
13558
13559 if (rule_len == 0) continue;
13560
13561 if (rule_buf[0] == '#') continue;
13562
13563 if (kernel_rules_avail == kernel_rules_cnt)
13564 {
13565 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13566
13567 kernel_rules_avail += INCR_RULES;
13568 }
13569
13570 memset (in, 0, BLOCK_SIZE);
13571 memset (out, 0, BLOCK_SIZE);
13572
13573 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13574
13575 if (result == -1)
13576 {
13577 log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13578
13579 continue;
13580 }
13581
13582 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13583 {
13584 log_info ("WARNING: Cannot convert rule for use on OpenCL device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13585
13586 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13587
13588 continue;
13589 }
13590
13591 /* its so slow
13592 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13593 {
13594 log_info ("Duplicate rule for use on OpenCL device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13595
13596 continue;
13597 }
13598 */
13599
13600 kernel_rules_cnt++;
13601 }
13602
13603 fclose (fp);
13604
13605 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13606
13607 all_kernel_rules_buf[i] = kernel_rules_buf;
13608 }
13609
13610 /**
13611 * merge rules or automatic rule generator
13612 */
13613
13614 uint kernel_rules_cnt = 0;
13615
13616 kernel_rule_t *kernel_rules_buf = NULL;
13617
13618 if (attack_mode == ATTACK_MODE_STRAIGHT)
13619 {
13620 if (rp_files_cnt)
13621 {
13622 kernel_rules_cnt = 1;
13623
13624 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13625
13626 repeats[0] = kernel_rules_cnt;
13627
13628 for (uint i = 0; i < rp_files_cnt; i++)
13629 {
13630 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13631
13632 repeats[i + 1] = kernel_rules_cnt;
13633 }
13634
13635 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13636
13637 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13638
13639 for (uint i = 0; i < kernel_rules_cnt; i++)
13640 {
13641 uint out_pos = 0;
13642
13643 kernel_rule_t *out = &kernel_rules_buf[i];
13644
13645 for (uint j = 0; j < rp_files_cnt; j++)
13646 {
13647 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13648 uint in_pos;
13649
13650 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13651
13652 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13653 {
13654 if (out_pos == RULES_MAX - 1)
13655 {
13656 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13657
13658 break;
13659 }
13660
13661 out->cmds[out_pos] = in->cmds[in_pos];
13662 }
13663 }
13664 }
13665
13666 local_free (repeats);
13667 }
13668 else if (rp_gen)
13669 {
13670 uint kernel_rules_avail = 0;
13671
13672 while (kernel_rules_cnt < rp_gen)
13673 {
13674 if (kernel_rules_avail == kernel_rules_cnt)
13675 {
13676 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13677
13678 kernel_rules_avail += INCR_RULES;
13679 }
13680
13681 memset (rule_buf, 0, HCBUFSIZ);
13682
13683 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13684
13685 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13686
13687 kernel_rules_cnt++;
13688 }
13689 }
13690 }
13691
13692 myfree (rule_buf);
13693
13694 /**
13695 * generate NOP rules
13696 */
13697
13698 if ((rp_files_cnt == 0) && (rp_gen == 0))
13699 {
13700 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13701
13702 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13703
13704 kernel_rules_cnt++;
13705 }
13706
13707 data.kernel_rules_cnt = kernel_rules_cnt;
13708 data.kernel_rules_buf = kernel_rules_buf;
13709
13710 if (kernel_rules_cnt == 0)
13711 {
13712 log_error ("ERROR: No valid rules left");
13713
13714 return (-1);
13715 }
13716
13717 /**
13718 * OpenCL platforms: detect
13719 */
13720
13721 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13722 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13723
13724 cl_uint platforms_cnt = 0;
13725 cl_uint platform_devices_cnt = 0;
13726
13727 if (keyspace == 0)
13728 {
13729 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13730
13731 if (platforms_cnt == 0)
13732 {
13733 log_info ("");
13734 log_info ("ATTENTION! No OpenCL compatible platform found");
13735 log_info ("");
13736 log_info ("You're probably missing the OpenCL runtime installation");
13737 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13738 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13739 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13740 log_info ("");
13741
13742 return (-1);
13743 }
13744
13745 if (opencl_platforms_filter != (uint) -1)
13746 {
13747 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13748
13749 if (opencl_platforms_filter > platform_cnt_mask)
13750 {
13751 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13752
13753 return (-1);
13754 }
13755 }
13756 }
13757
13758 if (opencl_device_types == NULL)
13759 {
13760 /**
13761 * OpenCL device types:
13762 * 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.
13763 */
13764
13765 cl_device_type device_types_all = 0;
13766
13767 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13768 {
13769 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13770
13771 cl_platform_id platform = platforms[platform_id];
13772
13773 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13774
13775 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13776 {
13777 cl_device_id device = platform_devices[platform_devices_id];
13778
13779 cl_device_type device_type;
13780
13781 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13782
13783 device_types_all |= device_type;
13784 }
13785 }
13786
13787 // In such a case, automatically enable CPU device type support, since it's disabled by default.
13788
13789 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13790 {
13791 device_types_filter |= CL_DEVICE_TYPE_CPU;
13792 }
13793
13794 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13795 // If we have a CPU device, force it to be used
13796
13797 if (stdout_flag == 1)
13798 {
13799 if (device_types_all & CL_DEVICE_TYPE_CPU)
13800 {
13801 device_types_filter = CL_DEVICE_TYPE_CPU;
13802 }
13803 }
13804 }
13805
13806 /**
13807 * OpenCL devices: simply push all devices from all platforms into the same device array
13808 */
13809
13810 int need_adl = 0;
13811 int need_nvapi = 0;
13812 int need_nvml = 0;
13813 int need_xnvctrl = 0;
13814
13815 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13816
13817 data.devices_param = devices_param;
13818
13819 uint devices_cnt = 0;
13820
13821 uint devices_active = 0;
13822
13823 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13824 {
13825 cl_platform_id platform = platforms[platform_id];
13826
13827 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13828
13829 char platform_vendor[INFOSZ] = { 0 };
13830
13831 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13832
13833 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13834 // this causes trouble with vendor id based macros
13835 // we'll assign generic to those without special optimization available
13836
13837 cl_uint platform_vendor_id = 0;
13838
13839 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13840 {
13841 platform_vendor_id = VENDOR_ID_AMD;
13842 }
13843 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13844 {
13845 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13846 }
13847 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13848 {
13849 platform_vendor_id = VENDOR_ID_APPLE;
13850 }
13851 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13852 {
13853 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13854 }
13855 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13856 {
13857 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13858 }
13859 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13860 {
13861 platform_vendor_id = VENDOR_ID_MESA;
13862 }
13863 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13864 {
13865 platform_vendor_id = VENDOR_ID_NV;
13866 }
13867 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13868 {
13869 platform_vendor_id = VENDOR_ID_POCL;
13870 }
13871 else
13872 {
13873 platform_vendor_id = VENDOR_ID_GENERIC;
13874 }
13875
13876 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13877
13878 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13879 {
13880 if (machine_readable == 0)
13881 {
13882 if (platform_skipped == 0)
13883 {
13884 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13885
13886 char line[256] = { 0 };
13887
13888 for (int i = 0; i < len; i++) line[i] = '=';
13889
13890 log_info (line);
13891 }
13892 else
13893 {
13894 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13895 log_info ("");
13896 }
13897 }
13898 }
13899
13900 if (platform_skipped == 1) continue;
13901
13902 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13903 {
13904 size_t param_value_size = 0;
13905
13906 const uint device_id = devices_cnt;
13907
13908 hc_device_param_t *device_param = &data.devices_param[device_id];
13909
13910 device_param->platform_vendor_id = platform_vendor_id;
13911
13912 device_param->device = platform_devices[platform_devices_id];
13913
13914 device_param->device_id = device_id;
13915
13916 device_param->platform_devices_id = platform_devices_id;
13917
13918 // device_type
13919
13920 cl_device_type device_type;
13921
13922 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13923
13924 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13925
13926 device_param->device_type = device_type;
13927
13928 // device_name
13929
13930 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13931
13932 char *device_name = (char *) mymalloc (param_value_size);
13933
13934 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13935
13936 device_param->device_name = device_name;
13937
13938 // device_vendor
13939
13940 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13941
13942 char *device_vendor = (char *) mymalloc (param_value_size);
13943
13944 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13945
13946 device_param->device_vendor = device_vendor;
13947
13948 cl_uint device_vendor_id = 0;
13949
13950 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13951 {
13952 device_vendor_id = VENDOR_ID_AMD;
13953 }
13954 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13955 {
13956 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13957 }
13958 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13959 {
13960 device_vendor_id = VENDOR_ID_APPLE;
13961 }
13962 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13963 {
13964 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13965 }
13966 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13967 {
13968 device_vendor_id = VENDOR_ID_INTEL_SDK;
13969 }
13970 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13971 {
13972 device_vendor_id = VENDOR_ID_MESA;
13973 }
13974 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13975 {
13976 device_vendor_id = VENDOR_ID_NV;
13977 }
13978 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13979 {
13980 device_vendor_id = VENDOR_ID_POCL;
13981 }
13982 else
13983 {
13984 device_vendor_id = VENDOR_ID_GENERIC;
13985 }
13986
13987 device_param->device_vendor_id = device_vendor_id;
13988
13989 // tuning db
13990
13991 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13992
13993 // device_version
13994
13995 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13996
13997 char *device_version = (char *) mymalloc (param_value_size);
13998
13999 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
14000
14001 device_param->device_version = device_version;
14002
14003 // device_opencl_version
14004
14005 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
14006
14007 char *device_opencl_version = (char *) mymalloc (param_value_size);
14008
14009 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
14010
14011 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
14012
14013 myfree (device_opencl_version);
14014
14015 // vector_width
14016
14017 cl_uint vector_width;
14018
14019 if (opencl_vector_width_chgd == 0)
14020 {
14021 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
14022 {
14023 if (opti_type & OPTI_TYPE_USES_BITS_64)
14024 {
14025 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
14026 }
14027 else
14028 {
14029 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
14030 }
14031 }
14032 else
14033 {
14034 vector_width = (cl_uint) tuningdb_entry->vector_width;
14035 }
14036 }
14037 else
14038 {
14039 vector_width = opencl_vector_width;
14040 }
14041
14042 if (vector_width > 16) vector_width = 16;
14043
14044 device_param->vector_width = vector_width;
14045
14046 // max_compute_units
14047
14048 cl_uint device_processors;
14049
14050 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
14051
14052 device_param->device_processors = device_processors;
14053
14054 // device_maxmem_alloc
14055 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
14056
14057 cl_ulong device_maxmem_alloc;
14058
14059 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
14060
14061 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
14062
14063 // device_global_mem
14064
14065 cl_ulong device_global_mem;
14066
14067 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14068
14069 device_param->device_global_mem = device_global_mem;
14070
14071 // max_work_group_size
14072
14073 size_t device_maxworkgroup_size;
14074
14075 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14076
14077 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14078
14079 // max_clock_frequency
14080
14081 cl_uint device_maxclock_frequency;
14082
14083 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14084
14085 device_param->device_maxclock_frequency = device_maxclock_frequency;
14086
14087 // device_endian_little
14088
14089 cl_bool device_endian_little;
14090
14091 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14092
14093 if (device_endian_little == CL_FALSE)
14094 {
14095 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14096
14097 device_param->skipped = 1;
14098 }
14099
14100 // device_available
14101
14102 cl_bool device_available;
14103
14104 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14105
14106 if (device_available == CL_FALSE)
14107 {
14108 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14109
14110 device_param->skipped = 1;
14111 }
14112
14113 // device_compiler_available
14114
14115 cl_bool device_compiler_available;
14116
14117 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14118
14119 if (device_compiler_available == CL_FALSE)
14120 {
14121 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14122
14123 device_param->skipped = 1;
14124 }
14125
14126 // device_execution_capabilities
14127
14128 cl_device_exec_capabilities device_execution_capabilities;
14129
14130 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14131
14132 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14133 {
14134 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14135
14136 device_param->skipped = 1;
14137 }
14138
14139 // device_extensions
14140
14141 size_t device_extensions_size;
14142
14143 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14144
14145 char *device_extensions = mymalloc (device_extensions_size + 1);
14146
14147 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14148
14149 if (strstr (device_extensions, "base_atomics") == 0)
14150 {
14151 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14152
14153 device_param->skipped = 1;
14154 }
14155
14156 if (strstr (device_extensions, "byte_addressable_store") == 0)
14157 {
14158 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14159
14160 device_param->skipped = 1;
14161 }
14162
14163 myfree (device_extensions);
14164
14165 // device_local_mem_size
14166
14167 cl_ulong device_local_mem_size;
14168
14169 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14170
14171 if (device_local_mem_size < 32768)
14172 {
14173 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14174
14175 device_param->skipped = 1;
14176 }
14177
14178 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14179 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14180 // This results in both utilizing it for 50%
14181 // However, Intel has much better SIMD control over their own hardware
14182 // It makes sense to give them full control over their own hardware
14183
14184 if (device_type & CL_DEVICE_TYPE_CPU)
14185 {
14186 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14187 {
14188 if (data.force == 0)
14189 {
14190 if (algorithm_pos == 0)
14191 {
14192 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14193 log_info (" You can use --force to override this but do not post error reports if you do so");
14194 }
14195
14196 device_param->skipped = 1;
14197 }
14198 }
14199 }
14200
14201 // skipped
14202
14203 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14204 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14205
14206 // driver_version
14207
14208 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14209
14210 char *driver_version = (char *) mymalloc (param_value_size);
14211
14212 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14213
14214 device_param->driver_version = driver_version;
14215
14216 // device_name_chksum
14217
14218 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14219
14220 #if __x86_64__
14221 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);
14222 #else
14223 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);
14224 #endif
14225
14226 uint device_name_digest[4] = { 0 };
14227
14228 md5_64 ((uint *) device_name_chksum, device_name_digest);
14229
14230 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14231
14232 device_param->device_name_chksum = device_name_chksum;
14233
14234 // vendor specific
14235
14236 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14237 {
14238 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14239 {
14240 need_adl = 1;
14241 }
14242
14243 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14244 {
14245 need_nvml = 1;
14246
14247 #ifdef LINUX
14248 need_xnvctrl = 1;
14249 #endif
14250
14251 #ifdef WIN
14252 need_nvapi = 1;
14253 #endif
14254 }
14255 }
14256
14257 if (device_type & CL_DEVICE_TYPE_GPU)
14258 {
14259 if (device_vendor_id == VENDOR_ID_NV)
14260 {
14261 cl_uint kernel_exec_timeout = 0;
14262
14263 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14264
14265 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14266
14267 device_param->kernel_exec_timeout = kernel_exec_timeout;
14268
14269 cl_uint sm_minor = 0;
14270 cl_uint sm_major = 0;
14271
14272 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14273 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14274
14275 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14276 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14277
14278 device_param->sm_minor = sm_minor;
14279 device_param->sm_major = sm_major;
14280
14281 // CPU burning loop damper
14282 // Value is given as number between 0-100
14283 // By default 100%
14284
14285 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14286
14287 if (nvidia_spin_damp_chgd == 0)
14288 {
14289 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14290 {
14291 /**
14292 * the workaround is not a friend of rule based attacks
14293 * the words from the wordlist combined with fast and slow rules cause
14294 * fluctuations which cause inaccurate wait time estimations
14295 * using a reduced damping percentage almost compensates this
14296 */
14297
14298 device_param->nvidia_spin_damp = 64;
14299 }
14300 }
14301
14302 device_param->nvidia_spin_damp /= 100;
14303 }
14304 }
14305
14306 // display results
14307
14308 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14309 {
14310 if (machine_readable == 0)
14311 {
14312 if (device_param->skipped == 0)
14313 {
14314 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14315 device_id + 1,
14316 device_name,
14317 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14318 (unsigned int) (device_global_mem / 1024 / 1024),
14319 (unsigned int) device_processors);
14320 }
14321 else
14322 {
14323 log_info ("- Device #%u: %s, skipped",
14324 device_id + 1,
14325 device_name);
14326 }
14327 }
14328 }
14329
14330 // common driver check
14331
14332 if (device_param->skipped == 0)
14333 {
14334 if (device_type & CL_DEVICE_TYPE_GPU)
14335 {
14336 if (platform_vendor_id == VENDOR_ID_AMD)
14337 {
14338 int catalyst_check = (force == 1) ? 0 : 1;
14339
14340 int catalyst_warn = 0;
14341
14342 int catalyst_broken = 0;
14343
14344 if (catalyst_check == 1)
14345 {
14346 catalyst_warn = 1;
14347
14348 // v14.9 and higher
14349 if (atoi (device_param->driver_version) >= 1573)
14350 {
14351 catalyst_warn = 0;
14352 }
14353
14354 catalyst_check = 0;
14355 }
14356
14357 if (catalyst_broken == 1)
14358 {
14359 log_info ("");
14360 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14361 log_info ("It passes over cracked hashes and will not report them as cracked");
14362 log_info ("You are STRONGLY encouraged not to use it");
14363 log_info ("You can use --force to override this but do not post error reports if you do so");
14364 log_info ("");
14365
14366 return (-1);
14367 }
14368
14369 if (catalyst_warn == 1)
14370 {
14371 log_info ("");
14372 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14373 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14374 log_info ("See hashcat's homepage for official supported catalyst drivers");
14375 #ifdef _WIN
14376 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14377 #endif
14378 log_info ("You can use --force to override this but do not post error reports if you do so");
14379 log_info ("");
14380
14381 return (-1);
14382 }
14383 }
14384 else if (platform_vendor_id == VENDOR_ID_NV)
14385 {
14386 if (device_param->kernel_exec_timeout != 0)
14387 {
14388 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);
14389 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14390 }
14391 }
14392 }
14393
14394 /* turns out pocl still creates segfaults (because of llvm)
14395 if (device_type & CL_DEVICE_TYPE_CPU)
14396 {
14397 if (platform_vendor_id == VENDOR_ID_AMD)
14398 {
14399 if (force == 0)
14400 {
14401 log_info ("");
14402 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14403 log_info ("You are STRONGLY encouraged not to use it");
14404 log_info ("You can use --force to override this but do not post error reports if you do so");
14405 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14406 log_info ("");
14407
14408 return (-1);
14409 }
14410 }
14411 }
14412 */
14413
14414 /**
14415 * kernel accel and loops tuning db adjustment
14416 */
14417
14418 device_param->kernel_accel_min = 1;
14419 device_param->kernel_accel_max = 1024;
14420
14421 device_param->kernel_loops_min = 1;
14422 device_param->kernel_loops_max = 1024;
14423
14424 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14425
14426 if (tuningdb_entry)
14427 {
14428 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14429 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14430
14431 if (_kernel_accel)
14432 {
14433 device_param->kernel_accel_min = _kernel_accel;
14434 device_param->kernel_accel_max = _kernel_accel;
14435 }
14436
14437 if (_kernel_loops)
14438 {
14439 if (workload_profile == 1)
14440 {
14441 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14442 }
14443 else if (workload_profile == 2)
14444 {
14445 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14446 }
14447
14448 device_param->kernel_loops_min = _kernel_loops;
14449 device_param->kernel_loops_max = _kernel_loops;
14450 }
14451 }
14452
14453 // commandline parameters overwrite tuningdb entries
14454
14455 if (kernel_accel)
14456 {
14457 device_param->kernel_accel_min = kernel_accel;
14458 device_param->kernel_accel_max = kernel_accel;
14459 }
14460
14461 if (kernel_loops)
14462 {
14463 device_param->kernel_loops_min = kernel_loops;
14464 device_param->kernel_loops_max = kernel_loops;
14465 }
14466
14467 /**
14468 * activate device
14469 */
14470
14471 devices_active++;
14472 }
14473
14474 // next please
14475
14476 devices_cnt++;
14477 }
14478
14479 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14480 {
14481 if (machine_readable == 0)
14482 {
14483 log_info ("");
14484 }
14485 }
14486 }
14487
14488 if (keyspace == 0 && devices_active == 0)
14489 {
14490 log_error ("ERROR: No devices found/left");
14491
14492 return (-1);
14493 }
14494
14495 // 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)
14496
14497 if (devices_filter != (uint) -1)
14498 {
14499 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14500
14501 if (devices_filter > devices_cnt_mask)
14502 {
14503 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14504
14505 return (-1);
14506 }
14507 }
14508
14509 data.devices_cnt = devices_cnt;
14510
14511 data.devices_active = devices_active;
14512
14513 /**
14514 * HM devices: init
14515 */
14516
14517 #ifdef HAVE_HWMON
14518 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14519 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14520 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14521 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14522
14523 if (gpu_temp_disable == 0)
14524 {
14525 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14526 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14527 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14528 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14529
14530 data.hm_adl = NULL;
14531 data.hm_nvapi = NULL;
14532 data.hm_nvml = NULL;
14533 data.hm_xnvctrl = NULL;
14534
14535 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14536 {
14537 data.hm_nvml = nvml;
14538 }
14539
14540 if (data.hm_nvml)
14541 {
14542 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14543 {
14544 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14545
14546 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14547
14548 int tmp_out = 0;
14549
14550 for (int i = 0; i < tmp_in; i++)
14551 {
14552 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14553 }
14554
14555 for (int i = 0; i < tmp_out; i++)
14556 {
14557 unsigned int speed;
14558
14559 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14560
14561 // doesn't seem to create any advantages
14562 //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14563 //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14564 }
14565 }
14566 }
14567
14568 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14569 {
14570 data.hm_nvapi = nvapi;
14571 }
14572
14573 if (data.hm_nvapi)
14574 {
14575 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14576 {
14577 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14578
14579 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14580
14581 int tmp_out = 0;
14582
14583 for (int i = 0; i < tmp_in; i++)
14584 {
14585 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14586 }
14587 }
14588 }
14589
14590 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14591 {
14592 data.hm_xnvctrl = xnvctrl;
14593 }
14594
14595 if (data.hm_xnvctrl)
14596 {
14597 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14598 {
14599 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14600 {
14601 hc_device_param_t *device_param = &data.devices_param[device_id];
14602
14603 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14604
14605 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14606
14607 int speed = 0;
14608
14609 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14610 }
14611 }
14612 }
14613
14614 if ((need_adl == 1) && (adl_init (adl) == 0))
14615 {
14616 data.hm_adl = adl;
14617 }
14618
14619 if (data.hm_adl)
14620 {
14621 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14622 {
14623 // total number of adapters
14624
14625 int hm_adapters_num;
14626
14627 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14628
14629 // adapter info
14630
14631 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14632
14633 if (lpAdapterInfo == NULL) return (-1);
14634
14635 // get a list (of ids of) valid/usable adapters
14636
14637 int num_adl_adapters = 0;
14638
14639 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14640
14641 if (num_adl_adapters > 0)
14642 {
14643 hc_thread_mutex_lock (mux_adl);
14644
14645 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14646
14647 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14648
14649 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14650 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14651
14652 hc_thread_mutex_unlock (mux_adl);
14653 }
14654
14655 myfree (valid_adl_device_list);
14656 myfree (lpAdapterInfo);
14657 }
14658 }
14659
14660 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14661 {
14662 gpu_temp_disable = 1;
14663 }
14664 }
14665
14666 /**
14667 * OpenCL devices: allocate buffer for device specific information
14668 */
14669
14670 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14671
14672 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14673
14674 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14675
14676 /**
14677 * User-defined GPU temp handling
14678 */
14679
14680 if (gpu_temp_disable == 1)
14681 {
14682 gpu_temp_abort = 0;
14683 gpu_temp_retain = 0;
14684 }
14685
14686 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14687 {
14688 if (gpu_temp_abort < gpu_temp_retain)
14689 {
14690 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14691
14692 return (-1);
14693 }
14694 }
14695
14696 data.gpu_temp_disable = gpu_temp_disable;
14697 data.gpu_temp_abort = gpu_temp_abort;
14698 data.gpu_temp_retain = gpu_temp_retain;
14699 #endif
14700
14701 /**
14702 * enable custom signal handler(s)
14703 */
14704
14705 if (benchmark == 0)
14706 {
14707 hc_signal (sigHandler_default);
14708 }
14709 else
14710 {
14711 hc_signal (sigHandler_benchmark);
14712 }
14713
14714 /**
14715 * inform the user
14716 */
14717
14718 if (data.quiet == 0)
14719 {
14720 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14721
14722 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);
14723
14724 if (attack_mode == ATTACK_MODE_STRAIGHT)
14725 {
14726 log_info ("Rules: %u", kernel_rules_cnt);
14727 }
14728
14729 if (opti_type)
14730 {
14731 log_info ("Applicable Optimizers:");
14732
14733 for (uint i = 0; i < 32; i++)
14734 {
14735 const uint opti_bit = 1u << i;
14736
14737 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14738 }
14739 }
14740
14741 /**
14742 * Watchdog and Temperature balance
14743 */
14744
14745 #ifdef HAVE_HWMON
14746 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14747 {
14748 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14749 }
14750
14751 if (gpu_temp_abort == 0)
14752 {
14753 log_info ("Watchdog: Temperature abort trigger disabled");
14754 }
14755 else
14756 {
14757 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14758 }
14759
14760 if (gpu_temp_retain == 0)
14761 {
14762 log_info ("Watchdog: Temperature retain trigger disabled");
14763 }
14764 else
14765 {
14766 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14767 }
14768
14769 if (data.quiet == 0) log_info ("");
14770 #endif
14771 }
14772
14773 #ifdef HAVE_HWMON
14774
14775 /**
14776 * HM devices: copy
14777 */
14778
14779 if (gpu_temp_disable == 0)
14780 {
14781 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14782 {
14783 hc_device_param_t *device_param = &data.devices_param[device_id];
14784
14785 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14786
14787 if (device_param->skipped) continue;
14788
14789 const uint platform_devices_id = device_param->platform_devices_id;
14790
14791 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14792 {
14793 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14794 data.hm_device[device_id].nvapi = 0;
14795 data.hm_device[device_id].nvml = 0;
14796 data.hm_device[device_id].xnvctrl = 0;
14797 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14798 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14799 data.hm_device[device_id].fan_set_supported = 0;
14800 }
14801
14802 if (device_param->device_vendor_id == VENDOR_ID_NV)
14803 {
14804 data.hm_device[device_id].adl = 0;
14805 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14806 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14807 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14808 data.hm_device[device_id].od_version = 0;
14809 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14810 data.hm_device[device_id].fan_set_supported = 0;
14811 }
14812 }
14813 }
14814
14815 /**
14816 * powertune on user request
14817 */
14818
14819 if (powertune_enable == 1)
14820 {
14821 hc_thread_mutex_lock (mux_adl);
14822
14823 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14824 {
14825 hc_device_param_t *device_param = &data.devices_param[device_id];
14826
14827 if (device_param->skipped) continue;
14828
14829 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14830 {
14831 /**
14832 * Temporary fix:
14833 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14834 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14835 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14836 * Driver / ADL bug?
14837 */
14838
14839 if (data.hm_device[device_id].od_version == 6)
14840 {
14841 int ADL_rc;
14842
14843 // check powertune capabilities first, if not available then skip device
14844
14845 int powertune_supported = 0;
14846
14847 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14848 {
14849 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14850
14851 return (-1);
14852 }
14853
14854 // first backup current value, we will restore it later
14855
14856 if (powertune_supported != 0)
14857 {
14858 // powercontrol settings
14859
14860 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14861
14862 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14863 {
14864 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14865 }
14866
14867 if (ADL_rc != ADL_OK)
14868 {
14869 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14870
14871 return (-1);
14872 }
14873
14874 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14875 {
14876 log_error ("ERROR: Failed to set new ADL PowerControl values");
14877
14878 return (-1);
14879 }
14880
14881 // clocks
14882
14883 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14884
14885 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14886
14887 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)
14888 {
14889 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14890
14891 return (-1);
14892 }
14893
14894 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14895
14896 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14897
14898 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14899 {
14900 log_error ("ERROR: Failed to get ADL device capabilities");
14901
14902 return (-1);
14903 }
14904
14905 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14906 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14907
14908 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14909 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14910
14911 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14912 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14913
14914 // warning if profile has too low max values
14915
14916 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14917 {
14918 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14919 }
14920
14921 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14922 {
14923 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14924 }
14925
14926 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14927
14928 performance_state->iNumberOfPerformanceLevels = 2;
14929
14930 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14931 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14932 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14933 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14934
14935 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)
14936 {
14937 log_info ("ERROR: Failed to set ADL performance state");
14938
14939 return (-1);
14940 }
14941
14942 local_free (performance_state);
14943 }
14944
14945 // set powertune value only
14946
14947 if (powertune_supported != 0)
14948 {
14949 // powertune set
14950 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14951
14952 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14953 {
14954 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14955
14956 return (-1);
14957 }
14958
14959 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14960 {
14961 log_error ("ERROR: Failed to set new ADL PowerControl values");
14962
14963 return (-1);
14964 }
14965 }
14966 }
14967 }
14968
14969 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14970 {
14971 // first backup current value, we will restore it later
14972
14973 unsigned int limit;
14974
14975 int powertune_supported = 0;
14976
14977 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14978 {
14979 powertune_supported = 1;
14980 }
14981
14982 // if backup worked, activate the maximum allowed
14983
14984 if (powertune_supported != 0)
14985 {
14986 unsigned int minLimit;
14987 unsigned int maxLimit;
14988
14989 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14990 {
14991 if (maxLimit > 0)
14992 {
14993 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14994 {
14995 // now we can be sure we need to reset later
14996
14997 nvml_power_limit[device_id] = limit;
14998 }
14999 }
15000 }
15001 }
15002 }
15003 }
15004
15005 hc_thread_mutex_unlock (mux_adl);
15006 }
15007
15008 #endif // HAVE_HWMON
15009
15010 #ifdef DEBUG
15011 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
15012 #endif
15013
15014 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
15015
15016 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15017 {
15018 /**
15019 * host buffer
15020 */
15021
15022 hc_device_param_t *device_param = &data.devices_param[device_id];
15023
15024 if (device_param->skipped) continue;
15025
15026 /**
15027 * device properties
15028 */
15029
15030 const char *device_name_chksum = device_param->device_name_chksum;
15031 const u32 device_processors = device_param->device_processors;
15032
15033 /**
15034 * create context for each device
15035 */
15036
15037 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
15038
15039 /**
15040 * create command-queue
15041 */
15042
15043 // not supported with NV
15044 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15045
15046 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
15047
15048 /**
15049 * kernel threads: some algorithms need a fixed kernel-threads count
15050 * because of shared memory usage or bitslice
15051 * there needs to be some upper limit, otherwise there's too much overhead
15052 */
15053
15054 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15055
15056 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15057 {
15058 kernel_threads = KERNEL_THREADS_MAX_CPU;
15059 }
15060
15061 if (hash_mode == 1500) kernel_threads = 64; // DES
15062 if (hash_mode == 3000) kernel_threads = 64; // DES
15063 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15064 if (hash_mode == 7500) kernel_threads = 64; // RC4
15065 if (hash_mode == 8900) kernel_threads = 64; // Scrypt
15066 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15067 if (hash_mode == 9300) kernel_threads = 64; // Scrypt
15068 if (hash_mode == 9700) kernel_threads = 64; // RC4
15069 if (hash_mode == 9710) kernel_threads = 64; // RC4
15070 if (hash_mode == 9800) kernel_threads = 64; // RC4
15071 if (hash_mode == 9810) kernel_threads = 64; // RC4
15072 if (hash_mode == 10400) kernel_threads = 64; // RC4
15073 if (hash_mode == 10410) kernel_threads = 64; // RC4
15074 if (hash_mode == 10500) kernel_threads = 64; // RC4
15075 if (hash_mode == 13100) kernel_threads = 64; // RC4
15076
15077 device_param->kernel_threads = kernel_threads;
15078
15079 device_param->hardware_power = device_processors * kernel_threads;
15080
15081 /**
15082 * create input buffers on device : calculate size of fixed memory buffers
15083 */
15084
15085 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15086 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15087
15088 device_param->size_root_css = size_root_css;
15089 device_param->size_markov_css = size_markov_css;
15090
15091 size_t size_results = sizeof (uint);
15092
15093 device_param->size_results = size_results;
15094
15095 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15096 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15097
15098 size_t size_plains = digests_cnt * sizeof (plain_t);
15099 size_t size_salts = salts_cnt * sizeof (salt_t);
15100 size_t size_esalts = salts_cnt * esalt_size;
15101
15102 device_param->size_plains = size_plains;
15103 device_param->size_digests = size_digests;
15104 device_param->size_shown = size_shown;
15105 device_param->size_salts = size_salts;
15106
15107 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15108 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15109 size_t size_tm = 32 * sizeof (bs_word_t);
15110
15111 // scryptV stuff
15112
15113 size_t size_scrypt = 4;
15114
15115 if ((hash_mode == 8900) || (hash_mode == 9300))
15116 {
15117 // we need to check that all hashes have the same scrypt settings
15118
15119 const u32 scrypt_N = data.salts_buf[0].scrypt_N;
15120 const u32 scrypt_r = data.salts_buf[0].scrypt_r;
15121 const u32 scrypt_p = data.salts_buf[0].scrypt_p;
15122
15123 for (uint i = 1; i < salts_cnt; i++)
15124 {
15125 if ((data.salts_buf[i].scrypt_N != scrypt_N)
15126 || (data.salts_buf[i].scrypt_r != scrypt_r)
15127 || (data.salts_buf[i].scrypt_p != scrypt_p))
15128 {
15129 log_error ("ERROR: Mixed scrypt settings not supported");
15130
15131 return -1;
15132 }
15133 }
15134
15135 uint tmto_start = 0;
15136 uint tmto_stop = 10;
15137
15138 if (scrypt_tmto)
15139 {
15140 tmto_start = scrypt_tmto;
15141 }
15142 else
15143 {
15144 // in case the user did not specify the tmto manually
15145 // use some values known to run best (tested on 290x for AMD and GTX1080 for NV)
15146
15147 if (hash_mode == 8900)
15148 {
15149 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15150 {
15151 tmto_start = 3;
15152 }
15153 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15154 {
15155 tmto_start = 2;
15156 }
15157 }
15158 else if (hash_mode == 9300)
15159 {
15160 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15161 {
15162 tmto_start = 2;
15163 }
15164 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15165 {
15166 tmto_start = 4;
15167 }
15168 }
15169 }
15170
15171 data.scrypt_tmp_size = (128 * scrypt_r);
15172
15173 device_param->kernel_accel_min = 1;
15174 device_param->kernel_accel_max = 8;
15175
15176 uint tmto;
15177
15178 for (tmto = tmto_start; tmto < tmto_stop; tmto++)
15179 {
15180 size_scrypt = (128 * scrypt_r) * scrypt_N;
15181
15182 size_scrypt /= 1 << tmto;
15183
15184 size_scrypt *= device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
15185
15186 if ((size_scrypt / 4) > device_param->device_maxmem_alloc)
15187 {
15188 if (quiet == 0) log_info ("WARNING: Not enough single-block device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15189
15190 continue;
15191 }
15192
15193 if (size_scrypt > device_param->device_global_mem)
15194 {
15195 if (quiet == 0) log_info ("WARNING: Not enough total device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15196
15197 continue;
15198 }
15199
15200 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15201 {
15202 data.scrypt_tmto_final = tmto;
15203 }
15204
15205 break;
15206 }
15207
15208 if (tmto == tmto_stop)
15209 {
15210 log_error ("ERROR: Can't allocate enough device memory");
15211
15212 return -1;
15213 }
15214
15215 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.scrypt_tmto_final, size_scrypt);
15216 }
15217
15218 size_t size_scrypt4 = size_scrypt / 4;
15219
15220 /**
15221 * some algorithms need a fixed kernel-loops count
15222 */
15223
15224 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15225 {
15226 const u32 kernel_loops_fixed = 1024;
15227
15228 device_param->kernel_loops_min = kernel_loops_fixed;
15229 device_param->kernel_loops_max = kernel_loops_fixed;
15230 }
15231
15232 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15233 {
15234 const u32 kernel_loops_fixed = 1024;
15235
15236 device_param->kernel_loops_min = kernel_loops_fixed;
15237 device_param->kernel_loops_max = kernel_loops_fixed;
15238 }
15239
15240 if (hash_mode == 8900)
15241 {
15242 const u32 kernel_loops_fixed = 1;
15243
15244 device_param->kernel_loops_min = kernel_loops_fixed;
15245 device_param->kernel_loops_max = kernel_loops_fixed;
15246 }
15247
15248 if (hash_mode == 9300)
15249 {
15250 const u32 kernel_loops_fixed = 1;
15251
15252 device_param->kernel_loops_min = kernel_loops_fixed;
15253 device_param->kernel_loops_max = kernel_loops_fixed;
15254 }
15255
15256 if (hash_mode == 12500)
15257 {
15258 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15259
15260 device_param->kernel_loops_min = kernel_loops_fixed;
15261 device_param->kernel_loops_max = kernel_loops_fixed;
15262 }
15263
15264 /**
15265 * some algorithms have a maximum kernel-loops count
15266 */
15267
15268 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15269 {
15270 u32 innerloop_cnt = 0;
15271
15272 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15273 {
15274 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15275 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15276 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15277 }
15278 else
15279 {
15280 innerloop_cnt = data.salts_buf[0].salt_iter;
15281 }
15282
15283 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15284 (innerloop_cnt <= device_param->kernel_loops_max))
15285 {
15286 device_param->kernel_loops_max = innerloop_cnt;
15287 }
15288 }
15289
15290 u32 kernel_accel_min = device_param->kernel_accel_min;
15291 u32 kernel_accel_max = device_param->kernel_accel_max;
15292
15293 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15294
15295 size_t size_pws = 4;
15296 size_t size_tmps = 4;
15297 size_t size_hooks = 4;
15298
15299 while (kernel_accel_max >= kernel_accel_min)
15300 {
15301 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15302
15303 // size_pws
15304
15305 size_pws = kernel_power_max * sizeof (pw_t);
15306
15307 // size_tmps
15308
15309 switch (hash_mode)
15310 {
15311 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15312 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15313 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15314 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15315 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15316 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15317 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15318 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15319 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15320 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15321 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15322 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15323 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15324 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15325 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15326 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15327 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15328 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15329 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15330 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15331 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15332 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15333 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15334 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15335 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15336 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15337 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15338 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15339 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15340 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15341 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15342 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15343 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15344 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15345 case 8900: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15346 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15347 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15348 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15349 case 9300: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15350 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15351 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15352 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15353 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15354 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15355 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15356 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15357 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15358 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15359 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15360 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15361 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15362 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15363 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15364 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15365 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15366 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15367 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15368 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15369 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15370 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15371 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15372 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15373 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15374 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15375 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15376 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15377 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15378 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15379 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15380 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15381 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15382 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15383 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15384 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15385 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15386 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15387 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15388 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15389 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15390 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15391 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15392 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15393 };
15394
15395 // size_hooks
15396
15397 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15398 {
15399 switch (hash_mode)
15400 {
15401 }
15402 }
15403
15404 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15405 // if not, decrease amplifier and try again
15406
15407 int memory_limit_hit = 0;
15408
15409 if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15410 if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15411 if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15412
15413 const u64 size_total
15414 = bitmap_size
15415 + bitmap_size
15416 + bitmap_size
15417 + bitmap_size
15418 + bitmap_size
15419 + bitmap_size
15420 + bitmap_size
15421 + bitmap_size
15422 + size_bfs
15423 + size_combs
15424 + size_digests
15425 + size_esalts
15426 + size_hooks
15427 + size_markov_css
15428 + size_plains
15429 + size_pws
15430 + size_pws // not a bug
15431 + size_results
15432 + size_root_css
15433 + size_rules
15434 + size_rules_c
15435 + size_salts
15436 + size_scrypt4
15437 + size_scrypt4
15438 + size_scrypt4
15439 + size_scrypt4
15440 + size_shown
15441 + size_tm
15442 + size_tmps;
15443
15444 if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
15445
15446 if (memory_limit_hit == 1)
15447 {
15448 kernel_accel_max--;
15449
15450 continue;
15451 }
15452
15453 break;
15454 }
15455
15456 if (kernel_accel_max < kernel_accel_min)
15457 {
15458 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
15459
15460 return -1;
15461 }
15462
15463 device_param->kernel_accel_min = kernel_accel_min;
15464 device_param->kernel_accel_max = kernel_accel_max;
15465
15466 /*
15467 if (kernel_accel_max < kernel_accel)
15468 {
15469 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15470
15471 device_param->kernel_accel = kernel_accel_max;
15472 }
15473 */
15474
15475 device_param->size_bfs = size_bfs;
15476 device_param->size_combs = size_combs;
15477 device_param->size_rules = size_rules;
15478 device_param->size_rules_c = size_rules_c;
15479 device_param->size_pws = size_pws;
15480 device_param->size_tmps = size_tmps;
15481 device_param->size_hooks = size_hooks;
15482
15483 /**
15484 * default building options
15485 */
15486
15487 char cpath[1024] = { 0 };
15488
15489 char build_opts[1024] = { 0 };
15490
15491 #if _WIN
15492
15493 snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
15494
15495 char *cpath_real = mymalloc (MAX_PATH);
15496
15497 if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
15498 {
15499 log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
15500
15501 return -1;
15502 }
15503
15504 naive_replace (cpath_real, '\\', '/');
15505
15506 // not escaping here, windows has quotes
15507
15508 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
15509
15510 #else
15511
15512 snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
15513
15514 char *cpath_real = mymalloc (PATH_MAX);
15515
15516 if (realpath (cpath, cpath_real) == NULL)
15517 {
15518 log_error ("ERROR: %s: %s", cpath, strerror (errno));
15519
15520 return -1;
15521 }
15522
15523 naive_escape (cpath_real, PATH_MAX, ' ', '\\');
15524
15525 snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
15526
15527 #endif
15528
15529 // include check
15530 // this test needs to be done manually because of osx opencl runtime
15531 // if there's a problem with permission, its not reporting back and erroring out silently
15532
15533 #define files_cnt 15
15534
15535 const char *files_names[files_cnt] =
15536 {
15537 "inc_cipher_aes256.cl",
15538 "inc_cipher_serpent256.cl",
15539 "inc_cipher_twofish256.cl",
15540 "inc_common.cl",
15541 "inc_comp_multi_bs.cl",
15542 "inc_comp_multi.cl",
15543 "inc_comp_single_bs.cl",
15544 "inc_comp_single.cl",
15545 "inc_hash_constants.h",
15546 "inc_hash_functions.cl",
15547 "inc_rp.cl",
15548 "inc_rp.h",
15549 "inc_simd.cl",
15550 "inc_types.cl",
15551 "inc_vendor.cl",
15552 };
15553
15554 for (int i = 0; i < files_cnt; i++)
15555 {
15556 char path[1024] = { 0 };
15557
15558 snprintf (path, sizeof (path) - 1, "%s/%s", cpath_real, files_names[i]);
15559
15560 FILE *fd = fopen (path, "r");
15561
15562 if (fd == NULL)
15563 {
15564 log_error ("ERROR: %s: fopen(): %s", path, strerror (errno));
15565
15566 return -1;
15567 }
15568
15569 char buf[1];
15570
15571 size_t n = fread (buf, 1, 1, fd);
15572
15573 if (n != 1)
15574 {
15575 log_error ("ERROR: %s: fread(): %s", path, strerror (errno));
15576
15577 return -1;
15578 }
15579
15580 fclose (fd);
15581 }
15582
15583 myfree (cpath_real);
15584
15585 // we don't have sm_* on vendors not NV but it doesn't matter
15586
15587 char build_opts_new[1024] = { 0 };
15588
15589 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);
15590
15591 strncpy (build_opts, build_opts_new, sizeof (build_opts));
15592
15593 #ifdef DEBUG
15594 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15595 #endif
15596
15597 /**
15598 * main kernel
15599 */
15600
15601 {
15602 /**
15603 * kernel source filename
15604 */
15605
15606 char source_file[256] = { 0 };
15607
15608 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15609
15610 struct stat sst;
15611
15612 if (stat (source_file, &sst) == -1)
15613 {
15614 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15615
15616 return -1;
15617 }
15618
15619 /**
15620 * kernel cached filename
15621 */
15622
15623 char cached_file[256] = { 0 };
15624
15625 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15626
15627 int cached = 1;
15628
15629 struct stat cst;
15630
15631 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15632 {
15633 cached = 0;
15634 }
15635
15636 /**
15637 * kernel compile or load
15638 */
15639
15640 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15641
15642 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15643
15644 if (force_jit_compilation == -1)
15645 {
15646 if (cached == 0)
15647 {
15648 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));
15649
15650 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15651
15652 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15653
15654 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15655
15656 #ifdef DEBUG
15657 size_t build_log_size = 0;
15658
15659 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15660
15661 if (build_log_size > 1)
15662 {
15663 char *build_log = (char *) malloc (build_log_size + 1);
15664
15665 memset (build_log, 0, build_log_size + 1);
15666
15667 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15668
15669 puts (build_log);
15670
15671 free (build_log);
15672 }
15673 #endif
15674
15675 if (rc != 0)
15676 {
15677 device_param->skipped = true;
15678
15679 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15680
15681 continue;
15682 }
15683
15684 size_t binary_size;
15685
15686 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15687
15688 u8 *binary = (u8 *) mymalloc (binary_size);
15689
15690 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15691
15692 writeProgramBin (cached_file, binary, binary_size);
15693
15694 local_free (binary);
15695 }
15696 else
15697 {
15698 #ifdef DEBUG
15699 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15700 #endif
15701
15702 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15703
15704 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15705
15706 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15707 }
15708 }
15709 else
15710 {
15711 #ifdef DEBUG
15712 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15713 #endif
15714
15715 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15716
15717 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15718
15719 char build_opts_update[1024] = { 0 };
15720
15721 if (force_jit_compilation == 1500)
15722 {
15723 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%u", build_opts, data.salts_buf[0].salt_buf[0]);
15724 }
15725 else if (force_jit_compilation == 8900)
15726 {
15727 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);
15728 }
15729 else
15730 {
15731 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15732 }
15733
15734 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15735
15736 #ifdef DEBUG
15737 size_t build_log_size = 0;
15738
15739 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15740
15741 if (build_log_size > 1)
15742 {
15743 char *build_log = (char *) malloc (build_log_size + 1);
15744
15745 memset (build_log, 0, build_log_size + 1);
15746
15747 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15748
15749 puts (build_log);
15750
15751 free (build_log);
15752 }
15753 #endif
15754
15755 if (rc != 0)
15756 {
15757 device_param->skipped = true;
15758
15759 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15760 }
15761 }
15762
15763 local_free (kernel_lengths);
15764 local_free (kernel_sources[0]);
15765 local_free (kernel_sources);
15766 }
15767
15768 /**
15769 * word generator kernel
15770 */
15771
15772 if (attack_mode != ATTACK_MODE_STRAIGHT)
15773 {
15774 /**
15775 * kernel mp source filename
15776 */
15777
15778 char source_file[256] = { 0 };
15779
15780 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15781
15782 struct stat sst;
15783
15784 if (stat (source_file, &sst) == -1)
15785 {
15786 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15787
15788 return -1;
15789 }
15790
15791 /**
15792 * kernel mp cached filename
15793 */
15794
15795 char cached_file[256] = { 0 };
15796
15797 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15798
15799 int cached = 1;
15800
15801 struct stat cst;
15802
15803 if (stat (cached_file, &cst) == -1)
15804 {
15805 cached = 0;
15806 }
15807
15808 /**
15809 * kernel compile or load
15810 */
15811
15812 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15813
15814 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15815
15816 if (cached == 0)
15817 {
15818 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));
15819 if (quiet == 0) log_info ("");
15820
15821 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15822
15823 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15824
15825 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15826
15827 if (rc != 0)
15828 {
15829 device_param->skipped = true;
15830
15831 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15832
15833 continue;
15834 }
15835
15836 size_t binary_size;
15837
15838 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15839
15840 u8 *binary = (u8 *) mymalloc (binary_size);
15841
15842 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15843
15844 writeProgramBin (cached_file, binary, binary_size);
15845
15846 local_free (binary);
15847 }
15848 else
15849 {
15850 #ifdef DEBUG
15851 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15852 #endif
15853
15854 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15855
15856 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15857
15858 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15859 }
15860
15861 local_free (kernel_lengths);
15862 local_free (kernel_sources[0]);
15863 local_free (kernel_sources);
15864 }
15865
15866 /**
15867 * amplifier kernel
15868 */
15869
15870 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15871 {
15872
15873 }
15874 else
15875 {
15876 /**
15877 * kernel amp source filename
15878 */
15879
15880 char source_file[256] = { 0 };
15881
15882 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15883
15884 struct stat sst;
15885
15886 if (stat (source_file, &sst) == -1)
15887 {
15888 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15889
15890 return -1;
15891 }
15892
15893 /**
15894 * kernel amp cached filename
15895 */
15896
15897 char cached_file[256] = { 0 };
15898
15899 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15900
15901 int cached = 1;
15902
15903 struct stat cst;
15904
15905 if (stat (cached_file, &cst) == -1)
15906 {
15907 cached = 0;
15908 }
15909
15910 /**
15911 * kernel compile or load
15912 */
15913
15914 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15915
15916 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15917
15918 if (cached == 0)
15919 {
15920 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));
15921 if (quiet == 0) log_info ("");
15922
15923 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15924
15925 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15926
15927 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15928
15929 if (rc != 0)
15930 {
15931 device_param->skipped = true;
15932
15933 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15934
15935 continue;
15936 }
15937
15938 size_t binary_size;
15939
15940 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15941
15942 u8 *binary = (u8 *) mymalloc (binary_size);
15943
15944 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15945
15946 writeProgramBin (cached_file, binary, binary_size);
15947
15948 local_free (binary);
15949 }
15950 else
15951 {
15952 #ifdef DEBUG
15953 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15954 #endif
15955
15956 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15957
15958 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15959
15960 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15961 }
15962
15963 local_free (kernel_lengths);
15964 local_free (kernel_sources[0]);
15965 local_free (kernel_sources);
15966 }
15967
15968 // some algorithm collide too fast, make that impossible
15969
15970 if (benchmark == 1)
15971 {
15972 ((uint *) digests_buf)[0] = -1;
15973 ((uint *) digests_buf)[1] = -1;
15974 ((uint *) digests_buf)[2] = -1;
15975 ((uint *) digests_buf)[3] = -1;
15976 }
15977
15978 /**
15979 * global buffers
15980 */
15981
15982 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15983 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15984 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15985 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15986 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15987 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15988 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15989 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15990 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15991 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15992 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15993 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15994 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15995 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15996 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15997 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15998 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15999 device_param->d_scryptV0_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
16000 device_param->d_scryptV1_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
16001 device_param->d_scryptV2_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
16002 device_param->d_scryptV3_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
16003
16004 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);
16005 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);
16006 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);
16007 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);
16008 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);
16009 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);
16010 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);
16011 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);
16012 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
16013 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
16014 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
16015
16016 /**
16017 * special buffers
16018 */
16019
16020 if (attack_kern == ATTACK_KERN_STRAIGHT)
16021 {
16022 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
16023 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
16024
16025 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
16026 }
16027 else if (attack_kern == ATTACK_KERN_COMBI)
16028 {
16029 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
16030 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
16031 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
16032 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
16033 }
16034 else if (attack_kern == ATTACK_KERN_BF)
16035 {
16036 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
16037 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
16038 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
16039 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
16040 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
16041 }
16042
16043 if (size_esalts)
16044 {
16045 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
16046
16047 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
16048 }
16049
16050 /**
16051 * main host data
16052 */
16053
16054 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
16055
16056 device_param->pws_buf = pws_buf;
16057
16058 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
16059
16060 device_param->combs_buf = combs_buf;
16061
16062 void *hooks_buf = mymalloc (size_hooks);
16063
16064 device_param->hooks_buf = hooks_buf;
16065
16066 /**
16067 * kernel args
16068 */
16069
16070 device_param->kernel_params_buf32[24] = bitmap_mask;
16071 device_param->kernel_params_buf32[25] = bitmap_shift1;
16072 device_param->kernel_params_buf32[26] = bitmap_shift2;
16073 device_param->kernel_params_buf32[27] = 0; // salt_pos
16074 device_param->kernel_params_buf32[28] = 0; // loop_pos
16075 device_param->kernel_params_buf32[29] = 0; // loop_cnt
16076 device_param->kernel_params_buf32[30] = 0; // kernel_rules_cnt
16077 device_param->kernel_params_buf32[31] = 0; // digests_cnt
16078 device_param->kernel_params_buf32[32] = 0; // digests_offset
16079 device_param->kernel_params_buf32[33] = 0; // combs_mode
16080 device_param->kernel_params_buf32[34] = 0; // gid_max
16081
16082 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16083 ? &device_param->d_pws_buf
16084 : &device_param->d_pws_amp_buf;
16085 device_param->kernel_params[ 1] = &device_param->d_rules_c;
16086 device_param->kernel_params[ 2] = &device_param->d_combs_c;
16087 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
16088 device_param->kernel_params[ 4] = &device_param->d_tmps;
16089 device_param->kernel_params[ 5] = &device_param->d_hooks;
16090 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
16091 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
16092 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
16093 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
16094 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
16095 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
16096 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
16097 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
16098 device_param->kernel_params[14] = &device_param->d_plain_bufs;
16099 device_param->kernel_params[15] = &device_param->d_digests_buf;
16100 device_param->kernel_params[16] = &device_param->d_digests_shown;
16101 device_param->kernel_params[17] = &device_param->d_salt_bufs;
16102 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
16103 device_param->kernel_params[19] = &device_param->d_result;
16104 device_param->kernel_params[20] = &device_param->d_scryptV0_buf;
16105 device_param->kernel_params[21] = &device_param->d_scryptV1_buf;
16106 device_param->kernel_params[22] = &device_param->d_scryptV2_buf;
16107 device_param->kernel_params[23] = &device_param->d_scryptV3_buf;
16108 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
16109 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
16110 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
16111 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
16112 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
16113 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
16114 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
16115 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
16116 device_param->kernel_params[32] = &device_param->kernel_params_buf32[32];
16117 device_param->kernel_params[33] = &device_param->kernel_params_buf32[33];
16118 device_param->kernel_params[34] = &device_param->kernel_params_buf32[34];
16119
16120 device_param->kernel_params_mp_buf64[3] = 0;
16121 device_param->kernel_params_mp_buf32[4] = 0;
16122 device_param->kernel_params_mp_buf32[5] = 0;
16123 device_param->kernel_params_mp_buf32[6] = 0;
16124 device_param->kernel_params_mp_buf32[7] = 0;
16125 device_param->kernel_params_mp_buf32[8] = 0;
16126
16127 device_param->kernel_params_mp[0] = NULL;
16128 device_param->kernel_params_mp[1] = NULL;
16129 device_param->kernel_params_mp[2] = NULL;
16130 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16131 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16132 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16133 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16134 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16135 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16136
16137 device_param->kernel_params_mp_l_buf64[3] = 0;
16138 device_param->kernel_params_mp_l_buf32[4] = 0;
16139 device_param->kernel_params_mp_l_buf32[5] = 0;
16140 device_param->kernel_params_mp_l_buf32[6] = 0;
16141 device_param->kernel_params_mp_l_buf32[7] = 0;
16142 device_param->kernel_params_mp_l_buf32[8] = 0;
16143 device_param->kernel_params_mp_l_buf32[9] = 0;
16144
16145 device_param->kernel_params_mp_l[0] = NULL;
16146 device_param->kernel_params_mp_l[1] = NULL;
16147 device_param->kernel_params_mp_l[2] = NULL;
16148 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
16149 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
16150 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16151 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16152 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16153 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16154 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16155
16156 device_param->kernel_params_mp_r_buf64[3] = 0;
16157 device_param->kernel_params_mp_r_buf32[4] = 0;
16158 device_param->kernel_params_mp_r_buf32[5] = 0;
16159 device_param->kernel_params_mp_r_buf32[6] = 0;
16160 device_param->kernel_params_mp_r_buf32[7] = 0;
16161 device_param->kernel_params_mp_r_buf32[8] = 0;
16162
16163 device_param->kernel_params_mp_r[0] = NULL;
16164 device_param->kernel_params_mp_r[1] = NULL;
16165 device_param->kernel_params_mp_r[2] = NULL;
16166 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16167 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16168 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16169 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16170 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16171 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16172
16173 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16174 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16175
16176 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16177 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16178 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16179 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16180 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16181 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16182 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16183
16184 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16185 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16186
16187 device_param->kernel_params_memset_buf32[1] = 0; // value
16188 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16189
16190 device_param->kernel_params_memset[0] = NULL;
16191 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16192 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16193
16194 /**
16195 * kernel name
16196 */
16197
16198 size_t kernel_wgs_tmp;
16199
16200 char kernel_name[64] = { 0 };
16201
16202 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16203 {
16204 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16205 {
16206 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16207
16208 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16209
16210 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16211
16212 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16213
16214 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16215
16216 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16217 }
16218 else
16219 {
16220 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16221
16222 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16223
16224 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16225
16226 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16227
16228 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16229
16230 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16231 }
16232
16233 if (data.attack_mode == ATTACK_MODE_BF)
16234 {
16235 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16236 {
16237 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16238
16239 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16240
16241 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);
16242 }
16243 }
16244 }
16245 else
16246 {
16247 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16248
16249 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16250
16251 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16252
16253 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16254
16255 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16256
16257 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16258
16259 if (opts_type & OPTS_TYPE_HOOK12)
16260 {
16261 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16262
16263 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16264
16265 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);
16266 }
16267
16268 if (opts_type & OPTS_TYPE_HOOK23)
16269 {
16270 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16271
16272 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16273
16274 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);
16275 }
16276 }
16277
16278 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);
16279 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);
16280 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);
16281
16282 for (uint i = 0; i <= 23; i++)
16283 {
16284 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16285 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16286 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16287
16288 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16289 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16290 }
16291
16292 for (uint i = 24; i <= 34; i++)
16293 {
16294 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16295 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16296 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16297
16298 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16299 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16300 }
16301
16302 // GPU memset
16303
16304 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16305
16306 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);
16307
16308 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16309 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16310 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16311
16312 // MP start
16313
16314 if (attack_mode == ATTACK_MODE_BF)
16315 {
16316 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16317 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16318
16319 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);
16320 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);
16321
16322 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16323 {
16324 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16325 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16326 }
16327 }
16328 else if (attack_mode == ATTACK_MODE_HYBRID1)
16329 {
16330 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16331
16332 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);
16333 }
16334 else if (attack_mode == ATTACK_MODE_HYBRID2)
16335 {
16336 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16337
16338 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);
16339 }
16340
16341 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16342 {
16343 // nothing to do
16344 }
16345 else
16346 {
16347 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16348
16349 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);
16350 }
16351
16352 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16353 {
16354 // nothing to do
16355 }
16356 else
16357 {
16358 for (uint i = 0; i < 5; i++)
16359 {
16360 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16361 }
16362
16363 for (uint i = 5; i < 7; i++)
16364 {
16365 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16366 }
16367 }
16368
16369 // maybe this has been updated by clGetKernelWorkGroupInfo()
16370 // value can only be decreased, so we don't need to reallocate buffers
16371
16372 device_param->kernel_threads = kernel_threads;
16373
16374 // zero some data buffers
16375
16376 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16377 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16378 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16379 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16380 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16381 run_kernel_bzero (device_param, device_param->d_result, size_results);
16382
16383 /**
16384 * special buffers
16385 */
16386
16387 if (attack_kern == ATTACK_KERN_STRAIGHT)
16388 {
16389 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16390 }
16391 else if (attack_kern == ATTACK_KERN_COMBI)
16392 {
16393 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16394 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16395 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16396 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16397 }
16398 else if (attack_kern == ATTACK_KERN_BF)
16399 {
16400 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16401 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16402 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16403 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16404 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16405 }
16406
16407 #if defined(HAVE_HWMON)
16408
16409 /**
16410 * Store initial fanspeed if gpu_temp_retain is enabled
16411 */
16412
16413 if (gpu_temp_disable == 0)
16414 {
16415 if (gpu_temp_retain != 0)
16416 {
16417 hc_thread_mutex_lock (mux_adl);
16418
16419 if (data.hm_device[device_id].fan_get_supported == 1)
16420 {
16421 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16422 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16423
16424 // we also set it to tell the OS we take control over the fan and it's automatic controller
16425 // if it was set to automatic. we do not control user-defined fanspeeds.
16426
16427 if (fanpolicy == 1)
16428 {
16429 data.hm_device[device_id].fan_set_supported = 1;
16430
16431 int rc = -1;
16432
16433 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16434 {
16435 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16436 }
16437 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16438 {
16439 #ifdef LINUX
16440 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16441 #endif
16442
16443 #ifdef WIN
16444 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16445 #endif
16446 }
16447
16448 if (rc == 0)
16449 {
16450 data.hm_device[device_id].fan_set_supported = 1;
16451 }
16452 else
16453 {
16454 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16455
16456 data.hm_device[device_id].fan_set_supported = 0;
16457 }
16458 }
16459 else
16460 {
16461 data.hm_device[device_id].fan_set_supported = 0;
16462 }
16463 }
16464
16465 hc_thread_mutex_unlock (mux_adl);
16466 }
16467 }
16468
16469 #endif // HAVE_HWMON
16470 }
16471
16472 if (data.quiet == 0) log_info_nn ("");
16473
16474 /**
16475 * In benchmark-mode, inform user which algorithm is checked
16476 */
16477
16478 if (benchmark == 1)
16479 {
16480 if (machine_readable == 0)
16481 {
16482 quiet = 0;
16483
16484 data.quiet = quiet;
16485
16486 char *hash_type = strhashtype (data.hash_mode); // not a bug
16487
16488 log_info ("Hashtype: %s", hash_type);
16489 log_info ("");
16490 }
16491 }
16492
16493 /**
16494 * keep track of the progress
16495 */
16496
16497 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16498 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16499 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16500
16501 /**
16502 * open filehandles
16503 */
16504
16505 #if _WIN
16506 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16507 {
16508 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16509
16510 return (-1);
16511 }
16512
16513 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16514 {
16515 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16516
16517 return (-1);
16518 }
16519
16520 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16521 {
16522 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16523
16524 return (-1);
16525 }
16526 #endif
16527
16528 /**
16529 * dictionary pad
16530 */
16531
16532 segment_size *= (1024 * 1024);
16533
16534 data.segment_size = segment_size;
16535
16536 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16537
16538 wl_data->buf = (char *) mymalloc (segment_size);
16539 wl_data->avail = segment_size;
16540 wl_data->incr = segment_size;
16541 wl_data->cnt = 0;
16542 wl_data->pos = 0;
16543
16544 cs_t *css_buf = NULL;
16545 uint css_cnt = 0;
16546 uint dictcnt = 0;
16547 uint maskcnt = 1;
16548 char **masks = NULL;
16549 char **dictfiles = NULL;
16550
16551 uint mask_from_file = 0;
16552
16553 if (attack_mode == ATTACK_MODE_STRAIGHT)
16554 {
16555 if (wordlist_mode == WL_MODE_FILE)
16556 {
16557 int wls_left = myargc - (optind + 1);
16558
16559 for (int i = 0; i < wls_left; i++)
16560 {
16561 char *l0_filename = myargv[optind + 1 + i];
16562
16563 struct stat l0_stat;
16564
16565 if (stat (l0_filename, &l0_stat) == -1)
16566 {
16567 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16568
16569 return (-1);
16570 }
16571
16572 uint is_dir = S_ISDIR (l0_stat.st_mode);
16573
16574 if (is_dir == 0)
16575 {
16576 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16577
16578 dictcnt++;
16579
16580 dictfiles[dictcnt - 1] = l0_filename;
16581 }
16582 else
16583 {
16584 // do not allow --keyspace w/ a directory
16585
16586 if (keyspace == 1)
16587 {
16588 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16589
16590 return (-1);
16591 }
16592
16593 char **dictionary_files = NULL;
16594
16595 dictionary_files = scan_directory (l0_filename);
16596
16597 if (dictionary_files != NULL)
16598 {
16599 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16600
16601 for (int d = 0; dictionary_files[d] != NULL; d++)
16602 {
16603 char *l1_filename = dictionary_files[d];
16604
16605 struct stat l1_stat;
16606
16607 if (stat (l1_filename, &l1_stat) == -1)
16608 {
16609 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16610
16611 return (-1);
16612 }
16613
16614 if (S_ISREG (l1_stat.st_mode))
16615 {
16616 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16617
16618 dictcnt++;
16619
16620 dictfiles[dictcnt - 1] = strdup (l1_filename);
16621 }
16622 }
16623 }
16624
16625 local_free (dictionary_files);
16626 }
16627 }
16628
16629 if (dictcnt < 1)
16630 {
16631 log_error ("ERROR: No usable dictionary file found.");
16632
16633 return (-1);
16634 }
16635 }
16636 else if (wordlist_mode == WL_MODE_STDIN)
16637 {
16638 dictcnt = 1;
16639 }
16640 }
16641 else if (attack_mode == ATTACK_MODE_COMBI)
16642 {
16643 // display
16644
16645 char *dictfile1 = myargv[optind + 1 + 0];
16646 char *dictfile2 = myargv[optind + 1 + 1];
16647
16648 // find the bigger dictionary and use as base
16649
16650 FILE *fp1 = NULL;
16651 FILE *fp2 = NULL;
16652
16653 struct stat tmp_stat;
16654
16655 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16656 {
16657 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16658
16659 return (-1);
16660 }
16661
16662 if (stat (dictfile1, &tmp_stat) == -1)
16663 {
16664 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16665
16666 fclose (fp1);
16667
16668 return (-1);
16669 }
16670
16671 if (S_ISDIR (tmp_stat.st_mode))
16672 {
16673 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16674
16675 fclose (fp1);
16676
16677 return (-1);
16678 }
16679
16680 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16681 {
16682 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16683
16684 fclose (fp1);
16685
16686 return (-1);
16687 }
16688
16689 if (stat (dictfile2, &tmp_stat) == -1)
16690 {
16691 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16692
16693 fclose (fp1);
16694 fclose (fp2);
16695
16696 return (-1);
16697 }
16698
16699 if (S_ISDIR (tmp_stat.st_mode))
16700 {
16701 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16702
16703 fclose (fp1);
16704 fclose (fp2);
16705
16706 return (-1);
16707 }
16708
16709 data.combs_cnt = 1;
16710
16711 data.quiet = 1;
16712
16713 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16714
16715 data.quiet = quiet;
16716
16717 if (words1_cnt == 0)
16718 {
16719 log_error ("ERROR: %s: empty file", dictfile1);
16720
16721 fclose (fp1);
16722 fclose (fp2);
16723
16724 return (-1);
16725 }
16726
16727 data.combs_cnt = 1;
16728
16729 data.quiet = 1;
16730
16731 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16732
16733 data.quiet = quiet;
16734
16735 if (words2_cnt == 0)
16736 {
16737 log_error ("ERROR: %s: empty file", dictfile2);
16738
16739 fclose (fp1);
16740 fclose (fp2);
16741
16742 return (-1);
16743 }
16744
16745 fclose (fp1);
16746 fclose (fp2);
16747
16748 data.dictfile = dictfile1;
16749 data.dictfile2 = dictfile2;
16750
16751 if (words1_cnt >= words2_cnt)
16752 {
16753 data.combs_cnt = words2_cnt;
16754 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16755
16756 dictfiles = &data.dictfile;
16757
16758 dictcnt = 1;
16759 }
16760 else
16761 {
16762 data.combs_cnt = words1_cnt;
16763 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16764
16765 dictfiles = &data.dictfile2;
16766
16767 dictcnt = 1;
16768
16769 // we also have to switch wordlist related rules!
16770
16771 char *tmpc = data.rule_buf_l;
16772
16773 data.rule_buf_l = data.rule_buf_r;
16774 data.rule_buf_r = tmpc;
16775
16776 int tmpi = data.rule_len_l;
16777
16778 data.rule_len_l = data.rule_len_r;
16779 data.rule_len_r = tmpi;
16780 }
16781 }
16782 else if (attack_mode == ATTACK_MODE_BF)
16783 {
16784 char *mask = NULL;
16785
16786 maskcnt = 0;
16787
16788 if (benchmark == 0)
16789 {
16790 mask = myargv[optind + 1];
16791
16792 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16793
16794 if ((optind + 2) <= myargc)
16795 {
16796 struct stat file_stat;
16797
16798 if (stat (mask, &file_stat) == -1)
16799 {
16800 maskcnt = 1;
16801
16802 masks[maskcnt - 1] = mystrdup (mask);
16803 }
16804 else
16805 {
16806 int wls_left = myargc - (optind + 1);
16807
16808 uint masks_avail = INCR_MASKS;
16809
16810 for (int i = 0; i < wls_left; i++)
16811 {
16812 if (i != 0)
16813 {
16814 mask = myargv[optind + 1 + i];
16815
16816 if (stat (mask, &file_stat) == -1)
16817 {
16818 log_error ("ERROR: %s: %s", mask, strerror (errno));
16819
16820 return (-1);
16821 }
16822 }
16823
16824 uint is_file = S_ISREG (file_stat.st_mode);
16825
16826 if (is_file == 1)
16827 {
16828 FILE *mask_fp;
16829
16830 if ((mask_fp = fopen (mask, "r")) == NULL)
16831 {
16832 log_error ("ERROR: %s: %s", mask, strerror (errno));
16833
16834 return (-1);
16835 }
16836
16837 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16838
16839 while (!feof (mask_fp))
16840 {
16841 memset (line_buf, 0, HCBUFSIZ);
16842
16843 int line_len = fgetl (mask_fp, line_buf);
16844
16845 if (line_len == 0) continue;
16846
16847 if (line_buf[0] == '#') continue;
16848
16849 if (masks_avail == maskcnt)
16850 {
16851 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16852
16853 masks_avail += INCR_MASKS;
16854 }
16855
16856 masks[maskcnt] = mystrdup (line_buf);
16857
16858 maskcnt++;
16859 }
16860
16861 myfree (line_buf);
16862
16863 fclose (mask_fp);
16864 }
16865 else
16866 {
16867 log_error ("ERROR: %s: unsupported file-type", mask);
16868
16869 return (-1);
16870 }
16871 }
16872
16873 mask_from_file = 1;
16874 }
16875 }
16876 else
16877 {
16878 custom_charset_1 = (char *) "?l?d?u";
16879 custom_charset_2 = (char *) "?l?d";
16880 custom_charset_3 = (char *) "?l?d*!$@_";
16881
16882 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16883 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16884 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16885
16886 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16887
16888 wordlist_mode = WL_MODE_MASK;
16889
16890 data.wordlist_mode = wordlist_mode;
16891
16892 increment = 1;
16893
16894 maskcnt = 1;
16895 }
16896 }
16897 else
16898 {
16899 /**
16900 * generate full masks and charsets
16901 */
16902
16903 masks = (char **) mymalloc (sizeof (char *));
16904
16905 switch (hash_mode)
16906 {
16907 case 1731: pw_min = 5;
16908 pw_max = 5;
16909 mask = mystrdup ("?b?b?b?b?b");
16910 break;
16911 case 12500: pw_min = 5;
16912 pw_max = 5;
16913 mask = mystrdup ("?b?b?b?b?b");
16914 break;
16915 default: pw_min = 7;
16916 pw_max = 7;
16917 mask = mystrdup ("?b?b?b?b?b?b?b");
16918 break;
16919 }
16920
16921 maskcnt = 1;
16922
16923 masks[maskcnt - 1] = mystrdup (mask);
16924
16925 wordlist_mode = WL_MODE_MASK;
16926
16927 data.wordlist_mode = wordlist_mode;
16928
16929 increment = 1;
16930 }
16931
16932 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16933
16934 if (increment)
16935 {
16936 if (increment_min > pw_min) pw_min = increment_min;
16937
16938 if (increment_max < pw_max) pw_max = increment_max;
16939 }
16940 }
16941 else if (attack_mode == ATTACK_MODE_HYBRID1)
16942 {
16943 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16944
16945 // display
16946
16947 char *mask = myargv[myargc - 1];
16948
16949 maskcnt = 0;
16950
16951 masks = (char **) mymalloc (1 * sizeof (char *));
16952
16953 // mod
16954
16955 struct stat file_stat;
16956
16957 if (stat (mask, &file_stat) == -1)
16958 {
16959 maskcnt = 1;
16960
16961 masks[maskcnt - 1] = mystrdup (mask);
16962 }
16963 else
16964 {
16965 uint is_file = S_ISREG (file_stat.st_mode);
16966
16967 if (is_file == 1)
16968 {
16969 FILE *mask_fp;
16970
16971 if ((mask_fp = fopen (mask, "r")) == NULL)
16972 {
16973 log_error ("ERROR: %s: %s", mask, strerror (errno));
16974
16975 return (-1);
16976 }
16977
16978 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16979
16980 uint masks_avail = 1;
16981
16982 while (!feof (mask_fp))
16983 {
16984 memset (line_buf, 0, HCBUFSIZ);
16985
16986 int line_len = fgetl (mask_fp, line_buf);
16987
16988 if (line_len == 0) continue;
16989
16990 if (line_buf[0] == '#') continue;
16991
16992 if (masks_avail == maskcnt)
16993 {
16994 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16995
16996 masks_avail += INCR_MASKS;
16997 }
16998
16999 masks[maskcnt] = mystrdup (line_buf);
17000
17001 maskcnt++;
17002 }
17003
17004 myfree (line_buf);
17005
17006 fclose (mask_fp);
17007
17008 mask_from_file = 1;
17009 }
17010 else
17011 {
17012 maskcnt = 1;
17013
17014 masks[maskcnt - 1] = mystrdup (mask);
17015 }
17016 }
17017
17018 // base
17019
17020 int wls_left = myargc - (optind + 2);
17021
17022 for (int i = 0; i < wls_left; i++)
17023 {
17024 char *filename = myargv[optind + 1 + i];
17025
17026 struct stat file_stat;
17027
17028 if (stat (filename, &file_stat) == -1)
17029 {
17030 log_error ("ERROR: %s: %s", filename, strerror (errno));
17031
17032 return (-1);
17033 }
17034
17035 uint is_dir = S_ISDIR (file_stat.st_mode);
17036
17037 if (is_dir == 0)
17038 {
17039 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17040
17041 dictcnt++;
17042
17043 dictfiles[dictcnt - 1] = filename;
17044 }
17045 else
17046 {
17047 // do not allow --keyspace w/ a directory
17048
17049 if (keyspace == 1)
17050 {
17051 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17052
17053 return (-1);
17054 }
17055
17056 char **dictionary_files = NULL;
17057
17058 dictionary_files = scan_directory (filename);
17059
17060 if (dictionary_files != NULL)
17061 {
17062 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17063
17064 for (int d = 0; dictionary_files[d] != NULL; d++)
17065 {
17066 char *l1_filename = dictionary_files[d];
17067
17068 struct stat l1_stat;
17069
17070 if (stat (l1_filename, &l1_stat) == -1)
17071 {
17072 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17073
17074 return (-1);
17075 }
17076
17077 if (S_ISREG (l1_stat.st_mode))
17078 {
17079 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17080
17081 dictcnt++;
17082
17083 dictfiles[dictcnt - 1] = strdup (l1_filename);
17084 }
17085 }
17086 }
17087
17088 local_free (dictionary_files);
17089 }
17090 }
17091
17092 if (dictcnt < 1)
17093 {
17094 log_error ("ERROR: No usable dictionary file found.");
17095
17096 return (-1);
17097 }
17098
17099 if (increment)
17100 {
17101 maskcnt = 0;
17102
17103 uint mask_min = increment_min; // we can't reject smaller masks here
17104 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17105
17106 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17107 {
17108 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17109
17110 if (cur_mask == NULL) break;
17111
17112 masks[maskcnt] = cur_mask;
17113
17114 maskcnt++;
17115
17116 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17117 }
17118 }
17119 }
17120 else if (attack_mode == ATTACK_MODE_HYBRID2)
17121 {
17122 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17123
17124 // display
17125
17126 char *mask = myargv[optind + 1 + 0];
17127
17128 maskcnt = 0;
17129
17130 masks = (char **) mymalloc (1 * sizeof (char *));
17131
17132 // mod
17133
17134 struct stat file_stat;
17135
17136 if (stat (mask, &file_stat) == -1)
17137 {
17138 maskcnt = 1;
17139
17140 masks[maskcnt - 1] = mystrdup (mask);
17141 }
17142 else
17143 {
17144 uint is_file = S_ISREG (file_stat.st_mode);
17145
17146 if (is_file == 1)
17147 {
17148 FILE *mask_fp;
17149
17150 if ((mask_fp = fopen (mask, "r")) == NULL)
17151 {
17152 log_error ("ERROR: %s: %s", mask, strerror (errno));
17153
17154 return (-1);
17155 }
17156
17157 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17158
17159 uint masks_avail = 1;
17160
17161 while (!feof (mask_fp))
17162 {
17163 memset (line_buf, 0, HCBUFSIZ);
17164
17165 int line_len = fgetl (mask_fp, line_buf);
17166
17167 if (line_len == 0) continue;
17168
17169 if (line_buf[0] == '#') continue;
17170
17171 if (masks_avail == maskcnt)
17172 {
17173 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17174
17175 masks_avail += INCR_MASKS;
17176 }
17177
17178 masks[maskcnt] = mystrdup (line_buf);
17179
17180 maskcnt++;
17181 }
17182
17183 myfree (line_buf);
17184
17185 fclose (mask_fp);
17186
17187 mask_from_file = 1;
17188 }
17189 else
17190 {
17191 maskcnt = 1;
17192
17193 masks[maskcnt - 1] = mystrdup (mask);
17194 }
17195 }
17196
17197 // base
17198
17199 int wls_left = myargc - (optind + 2);
17200
17201 for (int i = 0; i < wls_left; i++)
17202 {
17203 char *filename = myargv[optind + 2 + i];
17204
17205 struct stat file_stat;
17206
17207 if (stat (filename, &file_stat) == -1)
17208 {
17209 log_error ("ERROR: %s: %s", filename, strerror (errno));
17210
17211 return (-1);
17212 }
17213
17214 uint is_dir = S_ISDIR (file_stat.st_mode);
17215
17216 if (is_dir == 0)
17217 {
17218 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17219
17220 dictcnt++;
17221
17222 dictfiles[dictcnt - 1] = filename;
17223 }
17224 else
17225 {
17226 // do not allow --keyspace w/ a directory
17227
17228 if (keyspace == 1)
17229 {
17230 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17231
17232 return (-1);
17233 }
17234
17235 char **dictionary_files = NULL;
17236
17237 dictionary_files = scan_directory (filename);
17238
17239 if (dictionary_files != NULL)
17240 {
17241 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17242
17243 for (int d = 0; dictionary_files[d] != NULL; d++)
17244 {
17245 char *l1_filename = dictionary_files[d];
17246
17247 struct stat l1_stat;
17248
17249 if (stat (l1_filename, &l1_stat) == -1)
17250 {
17251 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17252
17253 return (-1);
17254 }
17255
17256 if (S_ISREG (l1_stat.st_mode))
17257 {
17258 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17259
17260 dictcnt++;
17261
17262 dictfiles[dictcnt - 1] = strdup (l1_filename);
17263 }
17264 }
17265 }
17266
17267 local_free (dictionary_files);
17268 }
17269 }
17270
17271 if (dictcnt < 1)
17272 {
17273 log_error ("ERROR: No usable dictionary file found.");
17274
17275 return (-1);
17276 }
17277
17278 if (increment)
17279 {
17280 maskcnt = 0;
17281
17282 uint mask_min = increment_min; // we can't reject smaller masks here
17283 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17284
17285 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17286 {
17287 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17288
17289 if (cur_mask == NULL) break;
17290
17291 masks[maskcnt] = cur_mask;
17292
17293 maskcnt++;
17294
17295 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17296 }
17297 }
17298 }
17299
17300 data.pw_min = pw_min;
17301 data.pw_max = pw_max;
17302
17303 /**
17304 * weak hash check
17305 */
17306
17307 if (weak_hash_threshold >= salts_cnt)
17308 {
17309 hc_device_param_t *device_param = NULL;
17310
17311 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17312 {
17313 device_param = &data.devices_param[device_id];
17314
17315 if (device_param->skipped) continue;
17316
17317 break;
17318 }
17319
17320 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17321
17322 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17323 {
17324 weak_hash_check (device_param, salt_pos);
17325 }
17326
17327 // Display hack, guarantee that there is at least one \r before real start
17328
17329 //if (data.quiet == 0) log_info ("");
17330 }
17331
17332 /**
17333 * status and monitor threads
17334 */
17335
17336 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17337 {
17338 data.devices_status = STATUS_STARTING;
17339 }
17340
17341 uint inner_threads_cnt = 0;
17342
17343 hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17344
17345 data.shutdown_inner = 0;
17346
17347 /**
17348 * Outfile remove
17349 */
17350
17351 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
17352 {
17353 hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL);
17354
17355 inner_threads_cnt++;
17356
17357 if (outfile_check_timer != 0)
17358 {
17359 if (data.outfile_check_directory != NULL)
17360 {
17361 if ((hash_mode != 5200) &&
17362 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17363 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17364 (hash_mode != 9000))
17365 {
17366 hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL);
17367
17368 inner_threads_cnt++;
17369 }
17370 else
17371 {
17372 outfile_check_timer = 0;
17373 }
17374 }
17375 else
17376 {
17377 outfile_check_timer = 0;
17378 }
17379 }
17380 }
17381
17382 /**
17383 * Inform the user if we got some hashes remove because of the pot file remove feature
17384 */
17385
17386 if (data.quiet == 0)
17387 {
17388 if (potfile_remove_cracks > 0)
17389 {
17390 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17391 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17392 }
17393 }
17394
17395 data.outfile_check_timer = outfile_check_timer;
17396
17397 /**
17398 * main loop
17399 */
17400
17401 char **induction_dictionaries = NULL;
17402
17403 int induction_dictionaries_cnt = 0;
17404
17405 hcstat_table_t *root_table_buf = NULL;
17406 hcstat_table_t *markov_table_buf = NULL;
17407
17408 uint initial_restore_done = 0;
17409
17410 data.maskcnt = maskcnt;
17411
17412 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17413 {
17414 if (data.devices_status == STATUS_CRACKED) continue;
17415 if (data.devices_status == STATUS_ABORTED) continue;
17416 if (data.devices_status == STATUS_QUIT) continue;
17417
17418 if (maskpos > rd->maskpos)
17419 {
17420 rd->dictpos = 0;
17421 }
17422
17423 rd->maskpos = maskpos;
17424 data.maskpos = maskpos;
17425
17426 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17427 {
17428 char *mask = masks[maskpos];
17429
17430 if (mask_from_file == 1)
17431 {
17432 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17433
17434 char *str_ptr;
17435 uint str_pos;
17436
17437 uint mask_offset = 0;
17438
17439 uint separator_cnt;
17440
17441 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17442 {
17443 str_ptr = strstr (mask + mask_offset, ",");
17444
17445 if (str_ptr == NULL) break;
17446
17447 str_pos = str_ptr - mask;
17448
17449 // escaped separator, i.e. "\,"
17450
17451 if (str_pos > 0)
17452 {
17453 if (mask[str_pos - 1] == '\\')
17454 {
17455 separator_cnt --;
17456
17457 mask_offset = str_pos + 1;
17458
17459 continue;
17460 }
17461 }
17462
17463 // reset the offset
17464
17465 mask_offset = 0;
17466
17467 mask[str_pos] = '\0';
17468
17469 switch (separator_cnt)
17470 {
17471 case 0:
17472 mp_reset_usr (mp_usr, 0);
17473
17474 custom_charset_1 = mask;
17475 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17476 break;
17477
17478 case 1:
17479 mp_reset_usr (mp_usr, 1);
17480
17481 custom_charset_2 = mask;
17482 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17483 break;
17484
17485 case 2:
17486 mp_reset_usr (mp_usr, 2);
17487
17488 custom_charset_3 = mask;
17489 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17490 break;
17491
17492 case 3:
17493 mp_reset_usr (mp_usr, 3);
17494
17495 custom_charset_4 = mask;
17496 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17497 break;
17498 }
17499
17500 mask = mask + str_pos + 1;
17501 }
17502 }
17503
17504 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17505 {
17506 if (maskpos > 0)
17507 {
17508 local_free (css_buf);
17509 local_free (data.root_css_buf);
17510 local_free (data.markov_css_buf);
17511
17512 local_free (masks[maskpos - 1]);
17513 }
17514
17515 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17516
17517 data.mask = mask;
17518 data.css_cnt = css_cnt;
17519 data.css_buf = css_buf;
17520
17521 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17522
17523 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17524
17525 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17526 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17527
17528 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17529
17530 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17531
17532 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17533 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17534
17535 data.root_css_buf = root_css_buf;
17536 data.markov_css_buf = markov_css_buf;
17537
17538 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17539
17540 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17541
17542 local_free (root_table_buf);
17543 local_free (markov_table_buf);
17544
17545 // args
17546
17547 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17548 {
17549 hc_device_param_t *device_param = &data.devices_param[device_id];
17550
17551 if (device_param->skipped) continue;
17552
17553 device_param->kernel_params_mp[0] = &device_param->d_combs;
17554 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17555 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17556
17557 device_param->kernel_params_mp_buf64[3] = 0;
17558 device_param->kernel_params_mp_buf32[4] = css_cnt;
17559 device_param->kernel_params_mp_buf32[5] = 0;
17560 device_param->kernel_params_mp_buf32[6] = 0;
17561 device_param->kernel_params_mp_buf32[7] = 0;
17562
17563 if (attack_mode == ATTACK_MODE_HYBRID1)
17564 {
17565 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17566 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17567 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17568 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17569 }
17570 else if (attack_mode == ATTACK_MODE_HYBRID2)
17571 {
17572 device_param->kernel_params_mp_buf32[5] = 0;
17573 device_param->kernel_params_mp_buf32[6] = 0;
17574 device_param->kernel_params_mp_buf32[7] = 0;
17575 }
17576
17577 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]);
17578 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]);
17579 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]);
17580
17581 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);
17582 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);
17583 }
17584 }
17585 else if (attack_mode == ATTACK_MODE_BF)
17586 {
17587 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17588
17589 if (increment)
17590 {
17591 for (uint i = 0; i < dictcnt; i++)
17592 {
17593 local_free (dictfiles[i]);
17594 }
17595
17596 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17597 {
17598 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17599
17600 if (l1_filename == NULL) break;
17601
17602 dictcnt++;
17603
17604 dictfiles[dictcnt - 1] = l1_filename;
17605 }
17606 }
17607 else
17608 {
17609 dictcnt++;
17610
17611 dictfiles[dictcnt - 1] = mask;
17612 }
17613
17614 if (dictcnt == 0)
17615 {
17616 log_error ("ERROR: Mask is too small");
17617
17618 return (-1);
17619 }
17620 }
17621 }
17622
17623 free (induction_dictionaries);
17624
17625 // induction_dictionaries_cnt = 0; // implied
17626
17627 if (attack_mode != ATTACK_MODE_BF)
17628 {
17629 if (keyspace == 0)
17630 {
17631 induction_dictionaries = scan_directory (induction_directory);
17632
17633 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17634 }
17635 }
17636
17637 if (induction_dictionaries_cnt)
17638 {
17639 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17640 }
17641
17642 /**
17643 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17644 */
17645 if (keyspace == 1)
17646 {
17647 if ((maskcnt > 1) || (dictcnt > 1))
17648 {
17649 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17650
17651 return (-1);
17652 }
17653 }
17654
17655 for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
17656 {
17657 if (data.devices_status == STATUS_CRACKED) continue;
17658 if (data.devices_status == STATUS_ABORTED) continue;
17659 if (data.devices_status == STATUS_QUIT) continue;
17660
17661 rd->dictpos = dictpos;
17662
17663 char *subid = logfile_generate_subid ();
17664
17665 data.subid = subid;
17666
17667 logfile_sub_msg ("START");
17668
17669 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17670 {
17671 data.devices_status = STATUS_INIT;
17672 }
17673
17674 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17675 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17676 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17677
17678 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17679
17680 data.cpt_pos = 0;
17681
17682 data.cpt_start = time (NULL);
17683
17684 data.cpt_total = 0;
17685
17686 if (data.restore == 0)
17687 {
17688 rd->words_cur = skip;
17689
17690 skip = 0;
17691
17692 data.skip = 0;
17693 }
17694
17695 data.ms_paused = 0;
17696
17697 data.kernel_power_final = 0;
17698
17699 data.words_cur = rd->words_cur;
17700
17701 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17702 {
17703 hc_device_param_t *device_param = &data.devices_param[device_id];
17704
17705 if (device_param->skipped) continue;
17706
17707 device_param->speed_pos = 0;
17708
17709 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17710 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17711
17712 device_param->exec_pos = 0;
17713
17714 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17715
17716 device_param->outerloop_pos = 0;
17717 device_param->outerloop_left = 0;
17718 device_param->innerloop_pos = 0;
17719 device_param->innerloop_left = 0;
17720
17721 // some more resets:
17722
17723 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17724
17725 device_param->pws_cnt = 0;
17726
17727 device_param->words_off = 0;
17728 device_param->words_done = 0;
17729 }
17730
17731 // figure out some workload
17732
17733 if (attack_mode == ATTACK_MODE_STRAIGHT)
17734 {
17735 if (data.wordlist_mode == WL_MODE_FILE)
17736 {
17737 char *dictfile = NULL;
17738
17739 if (induction_dictionaries_cnt)
17740 {
17741 dictfile = induction_dictionaries[0];
17742 }
17743 else
17744 {
17745 dictfile = dictfiles[dictpos];
17746 }
17747
17748 data.dictfile = dictfile;
17749
17750 logfile_sub_string (dictfile);
17751
17752 for (uint i = 0; i < rp_files_cnt; i++)
17753 {
17754 logfile_sub_var_string ("rulefile", rp_files[i]);
17755 }
17756
17757 FILE *fd2 = fopen (dictfile, "rb");
17758
17759 if (fd2 == NULL)
17760 {
17761 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17762
17763 return (-1);
17764 }
17765
17766 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17767
17768 fclose (fd2);
17769
17770 if (data.words_cnt == 0)
17771 {
17772 logfile_sub_msg ("STOP");
17773
17774 continue;
17775 }
17776 }
17777 }
17778 else if (attack_mode == ATTACK_MODE_COMBI)
17779 {
17780 char *dictfile = data.dictfile;
17781 char *dictfile2 = data.dictfile2;
17782
17783 logfile_sub_string (dictfile);
17784 logfile_sub_string (dictfile2);
17785
17786 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17787 {
17788 FILE *fd2 = fopen (dictfile, "rb");
17789
17790 if (fd2 == NULL)
17791 {
17792 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17793
17794 return (-1);
17795 }
17796
17797 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17798
17799 fclose (fd2);
17800 }
17801 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17802 {
17803 FILE *fd2 = fopen (dictfile2, "rb");
17804
17805 if (fd2 == NULL)
17806 {
17807 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17808
17809 return (-1);
17810 }
17811
17812 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17813
17814 fclose (fd2);
17815 }
17816
17817 if (data.words_cnt == 0)
17818 {
17819 logfile_sub_msg ("STOP");
17820
17821 continue;
17822 }
17823 }
17824 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17825 {
17826 char *dictfile = NULL;
17827
17828 if (induction_dictionaries_cnt)
17829 {
17830 dictfile = induction_dictionaries[0];
17831 }
17832 else
17833 {
17834 dictfile = dictfiles[dictpos];
17835 }
17836
17837 data.dictfile = dictfile;
17838
17839 char *mask = data.mask;
17840
17841 logfile_sub_string (dictfile);
17842 logfile_sub_string (mask);
17843
17844 FILE *fd2 = fopen (dictfile, "rb");
17845
17846 if (fd2 == NULL)
17847 {
17848 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17849
17850 return (-1);
17851 }
17852
17853 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17854
17855 fclose (fd2);
17856
17857 if (data.words_cnt == 0)
17858 {
17859 logfile_sub_msg ("STOP");
17860
17861 continue;
17862 }
17863 }
17864 else if (attack_mode == ATTACK_MODE_BF)
17865 {
17866 local_free (css_buf);
17867 local_free (data.root_css_buf);
17868 local_free (data.markov_css_buf);
17869
17870 char *mask = dictfiles[dictpos];
17871
17872 logfile_sub_string (mask);
17873
17874 // base
17875
17876 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17877
17878 if (opts_type & OPTS_TYPE_PT_UNICODE)
17879 {
17880 uint css_cnt_unicode = css_cnt * 2;
17881
17882 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17883
17884 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17885 {
17886 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17887
17888 css_buf_unicode[j + 1].cs_buf[0] = 0;
17889 css_buf_unicode[j + 1].cs_len = 1;
17890 }
17891
17892 free (css_buf);
17893
17894 css_buf = css_buf_unicode;
17895 css_cnt = css_cnt_unicode;
17896 }
17897
17898 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17899
17900 uint mask_min = pw_min;
17901 uint mask_max = pw_max;
17902
17903 if (opts_type & OPTS_TYPE_PT_UNICODE)
17904 {
17905 mask_min *= 2;
17906 mask_max *= 2;
17907 }
17908
17909 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17910 {
17911 if (css_cnt < mask_min)
17912 {
17913 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17914 }
17915
17916 if (css_cnt > mask_max)
17917 {
17918 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17919 }
17920
17921 // skip to next mask
17922
17923 logfile_sub_msg ("STOP");
17924
17925 continue;
17926 }
17927
17928 uint save_css_cnt = css_cnt;
17929
17930 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17931 {
17932 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17933 {
17934 uint salt_len = (uint) data.salts_buf[0].salt_len;
17935 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17936
17937 uint css_cnt_salt = css_cnt + salt_len;
17938
17939 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17940
17941 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17942
17943 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17944 {
17945 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17946 css_buf_salt[j].cs_len = 1;
17947 }
17948
17949 free (css_buf);
17950
17951 css_buf = css_buf_salt;
17952 css_cnt = css_cnt_salt;
17953 }
17954 }
17955
17956 data.mask = mask;
17957 data.css_cnt = css_cnt;
17958 data.css_buf = css_buf;
17959
17960 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17961
17962 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17963
17964 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17965
17966 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17967 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17968
17969 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17970
17971 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17972
17973 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17974 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17975
17976 data.root_css_buf = root_css_buf;
17977 data.markov_css_buf = markov_css_buf;
17978
17979 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17980
17981 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17982
17983 local_free (root_table_buf);
17984 local_free (markov_table_buf);
17985
17986 // copy + args
17987
17988 uint css_cnt_l = css_cnt;
17989 uint css_cnt_r;
17990
17991 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17992 {
17993 if (save_css_cnt < 6)
17994 {
17995 css_cnt_r = 1;
17996 }
17997 else if (save_css_cnt == 6)
17998 {
17999 css_cnt_r = 2;
18000 }
18001 else
18002 {
18003 if (opts_type & OPTS_TYPE_PT_UNICODE)
18004 {
18005 if (save_css_cnt == 8 || save_css_cnt == 10)
18006 {
18007 css_cnt_r = 2;
18008 }
18009 else
18010 {
18011 css_cnt_r = 4;
18012 }
18013 }
18014 else
18015 {
18016 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
18017 {
18018 css_cnt_r = 3;
18019 }
18020 else
18021 {
18022 css_cnt_r = 4;
18023 }
18024 }
18025 }
18026 }
18027 else
18028 {
18029 css_cnt_r = 1;
18030
18031 /* unfinished code?
18032 int sum = css_buf[css_cnt_r - 1].cs_len;
18033
18034 for (uint i = 1; i < 4 && i < css_cnt; i++)
18035 {
18036 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
18037
18038 css_cnt_r++;
18039
18040 sum *= css_buf[css_cnt_r - 1].cs_len;
18041 }
18042 */
18043 }
18044
18045 css_cnt_l -= css_cnt_r;
18046
18047 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
18048
18049 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18050 {
18051 hc_device_param_t *device_param = &data.devices_param[device_id];
18052
18053 if (device_param->skipped) continue;
18054
18055 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
18056 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
18057 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
18058
18059 device_param->kernel_params_mp_l_buf64[3] = 0;
18060 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
18061 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
18062 device_param->kernel_params_mp_l_buf32[6] = 0;
18063 device_param->kernel_params_mp_l_buf32[7] = 0;
18064 device_param->kernel_params_mp_l_buf32[8] = 0;
18065
18066 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
18067 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
18068 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
18069 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
18070
18071 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
18072 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
18073 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
18074
18075 device_param->kernel_params_mp_r_buf64[3] = 0;
18076 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
18077 device_param->kernel_params_mp_r_buf32[5] = 0;
18078 device_param->kernel_params_mp_r_buf32[6] = 0;
18079 device_param->kernel_params_mp_r_buf32[7] = 0;
18080
18081 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]);
18082 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]);
18083 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]);
18084
18085 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]);
18086 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]);
18087 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]);
18088
18089 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);
18090 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);
18091 }
18092 }
18093
18094 u64 words_base = data.words_cnt;
18095
18096 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18097 {
18098 if (data.kernel_rules_cnt)
18099 {
18100 words_base /= data.kernel_rules_cnt;
18101 }
18102 }
18103 else if (data.attack_kern == ATTACK_KERN_COMBI)
18104 {
18105 if (data.combs_cnt)
18106 {
18107 words_base /= data.combs_cnt;
18108 }
18109 }
18110 else if (data.attack_kern == ATTACK_KERN_BF)
18111 {
18112 if (data.bfs_cnt)
18113 {
18114 words_base /= data.bfs_cnt;
18115 }
18116 }
18117
18118 data.words_base = words_base;
18119
18120 if (keyspace == 1)
18121 {
18122 log_info ("%llu", (unsigned long long int) words_base);
18123
18124 return (0);
18125 }
18126
18127 if (data.words_cur > data.words_base)
18128 {
18129 log_error ("ERROR: Restore value greater keyspace");
18130
18131 return (-1);
18132 }
18133
18134 if (data.words_cur)
18135 {
18136 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18137 {
18138 for (uint i = 0; i < data.salts_cnt; i++)
18139 {
18140 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18141 }
18142 }
18143 else if (data.attack_kern == ATTACK_KERN_COMBI)
18144 {
18145 for (uint i = 0; i < data.salts_cnt; i++)
18146 {
18147 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18148 }
18149 }
18150 else if (data.attack_kern == ATTACK_KERN_BF)
18151 {
18152 for (uint i = 0; i < data.salts_cnt; i++)
18153 {
18154 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18155 }
18156 }
18157 }
18158
18159 /*
18160 * Update loopback file
18161 */
18162
18163 if (loopback == 1)
18164 {
18165 time_t now;
18166
18167 time (&now);
18168
18169 uint random_num = get_random_num (0, 9999);
18170
18171 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18172
18173 data.loopback_file = loopback_file;
18174 }
18175
18176 /*
18177 * Update dictionary statistic
18178 */
18179
18180 if (keyspace == 0)
18181 {
18182 dictstat_fp = fopen (dictstat, "wb");
18183
18184 if (dictstat_fp)
18185 {
18186 lock_file (dictstat_fp);
18187
18188 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18189
18190 fclose (dictstat_fp);
18191 }
18192 }
18193
18194 /**
18195 * create autotune threads
18196 */
18197
18198 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18199
18200 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18201 {
18202 data.devices_status = STATUS_AUTOTUNE;
18203 }
18204
18205 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18206 {
18207 hc_device_param_t *device_param = &devices_param[device_id];
18208
18209 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18210 }
18211
18212 hc_thread_wait (data.devices_cnt, c_threads);
18213
18214 /*
18215 * Inform user about possible slow speeds
18216 */
18217
18218 uint hardware_power_all = 0;
18219
18220 uint kernel_power_all = 0;
18221
18222 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18223 {
18224 hc_device_param_t *device_param = &devices_param[device_id];
18225
18226 hardware_power_all += device_param->hardware_power;
18227
18228 kernel_power_all += device_param->kernel_power;
18229 }
18230
18231 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
18232
18233 data.kernel_power_all = kernel_power_all;
18234
18235 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18236 {
18237 if (data.words_base < kernel_power_all)
18238 {
18239 if (quiet == 0)
18240 {
18241 clear_prompt ();
18242
18243 log_info ("ATTENTION!");
18244 log_info (" The wordlist or mask you are using is too small.");
18245 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18246 log_info (" The cracking speed will drop.");
18247 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18248 log_info ("");
18249 }
18250 }
18251 }
18252
18253 /**
18254 * create cracker threads
18255 */
18256
18257 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18258 {
18259 data.devices_status = STATUS_RUNNING;
18260 }
18261
18262 if (initial_restore_done == 0)
18263 {
18264 if (data.restore_disable == 0) cycle_restore ();
18265
18266 initial_restore_done = 1;
18267 }
18268
18269 hc_timer_set (&data.timer_running);
18270
18271 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18272 {
18273 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18274 {
18275 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18276 if (quiet == 0) fflush (stdout);
18277 }
18278 }
18279 else if (wordlist_mode == WL_MODE_STDIN)
18280 {
18281 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18282 if (data.quiet == 0) log_info ("");
18283 }
18284
18285 time_t runtime_start;
18286
18287 time (&runtime_start);
18288
18289 data.runtime_start = runtime_start;
18290
18291 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18292 {
18293 hc_device_param_t *device_param = &devices_param[device_id];
18294
18295 if (wordlist_mode == WL_MODE_STDIN)
18296 {
18297 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18298 }
18299 else
18300 {
18301 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18302 }
18303 }
18304
18305 hc_thread_wait (data.devices_cnt, c_threads);
18306
18307 local_free (c_threads);
18308
18309 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18310 {
18311 data.devices_status = STATUS_EXHAUSTED;
18312 }
18313
18314 logfile_sub_var_uint ("status-after-work", data.devices_status);
18315
18316 data.restore = 0;
18317
18318 if (induction_dictionaries_cnt)
18319 {
18320 unlink (induction_dictionaries[0]);
18321 }
18322
18323 free (induction_dictionaries);
18324
18325 if (attack_mode != ATTACK_MODE_BF)
18326 {
18327 induction_dictionaries = scan_directory (induction_directory);
18328
18329 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18330 }
18331
18332 if (benchmark == 1)
18333 {
18334 status_benchmark ();
18335
18336 if (machine_readable == 0)
18337 {
18338 log_info ("");
18339 }
18340 }
18341 else
18342 {
18343 if (quiet == 0)
18344 {
18345 clear_prompt ();
18346
18347 log_info ("");
18348
18349 status_display ();
18350
18351 log_info ("");
18352 }
18353 else
18354 {
18355 if (status == 1)
18356 {
18357 status_display ();
18358 }
18359 }
18360 }
18361
18362 if (induction_dictionaries_cnt)
18363 {
18364 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18365 }
18366
18367 time_t runtime_stop;
18368
18369 time (&runtime_stop);
18370
18371 data.runtime_stop = runtime_stop;
18372
18373 logfile_sub_uint (runtime_start);
18374 logfile_sub_uint (runtime_stop);
18375
18376 logfile_sub_msg ("STOP");
18377
18378 global_free (subid);
18379
18380 // from this point we handle bypass as running
18381
18382 if (data.devices_status == STATUS_BYPASS)
18383 {
18384 data.devices_status = STATUS_RUNNING;
18385 }
18386
18387 // and overwrite benchmark aborts as well
18388
18389 if (data.benchmark == 1)
18390 {
18391 if (data.devices_status == STATUS_ABORTED)
18392 {
18393 data.devices_status = STATUS_RUNNING;
18394 }
18395 }
18396
18397 // finalize task
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 if (data.devices_status == STATUS_CRACKED) break;
18405 if (data.devices_status == STATUS_ABORTED) break;
18406 if (data.devices_status == STATUS_QUIT) break;
18407 }
18408
18409 // 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
18410 if (attack_mode == ATTACK_MODE_STRAIGHT)
18411 {
18412 if (data.wordlist_mode == WL_MODE_FILE)
18413 {
18414 if (data.dictfile == NULL)
18415 {
18416 if (dictfiles != NULL)
18417 {
18418 data.dictfile = dictfiles[0];
18419
18420 hc_timer_set (&data.timer_running);
18421 }
18422 }
18423 }
18424 }
18425 // NOTE: combi is okay because it is already set beforehand
18426 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18427 {
18428 if (data.dictfile == NULL)
18429 {
18430 if (dictfiles != NULL)
18431 {
18432 hc_timer_set (&data.timer_running);
18433
18434 data.dictfile = dictfiles[0];
18435 }
18436 }
18437 }
18438 else if (attack_mode == ATTACK_MODE_BF)
18439 {
18440 if (data.mask == NULL)
18441 {
18442 hc_timer_set (&data.timer_running);
18443
18444 data.mask = masks[0];
18445 }
18446 }
18447
18448 // if cracked / aborted remove last induction dictionary
18449
18450 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18451 {
18452 struct stat induct_stat;
18453
18454 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18455 {
18456 unlink (induction_dictionaries[file_pos]);
18457 }
18458 }
18459
18460 // wait for inner threads
18461
18462 data.shutdown_inner = 1;
18463
18464 for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++)
18465 {
18466 hc_thread_wait (1, &inner_threads[thread_idx]);
18467 }
18468
18469 local_free (inner_threads);
18470
18471 // we dont need restore file anymore
18472 if (data.restore_disable == 0)
18473 {
18474 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18475 {
18476 unlink (eff_restore_file);
18477 unlink (new_restore_file);
18478 }
18479 else
18480 {
18481 cycle_restore ();
18482 }
18483 }
18484
18485 // finally save left hashes
18486
18487 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18488 {
18489 save_hash ();
18490 }
18491
18492 /**
18493 * Clean up
18494 */
18495
18496 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18497 {
18498 hc_device_param_t *device_param = &data.devices_param[device_id];
18499
18500 if (device_param->skipped) continue;
18501
18502 local_free (device_param->combs_buf);
18503 local_free (device_param->hooks_buf);
18504 local_free (device_param->device_name);
18505 local_free (device_param->device_name_chksum);
18506 local_free (device_param->device_version);
18507 local_free (device_param->driver_version);
18508
18509 if (device_param->pws_buf) myfree (device_param->pws_buf);
18510 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18511 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18512 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18513 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18514 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18515 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18516 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18517 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18518 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18519 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18520 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18521 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18522 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18523 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18524 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18525 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18526 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18527 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18528 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18529 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18530 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18531 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18532 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18533 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18534 if (device_param->d_scryptV0_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV0_buf);
18535 if (device_param->d_scryptV1_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV1_buf);
18536 if (device_param->d_scryptV2_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV2_buf);
18537 if (device_param->d_scryptV3_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV3_buf);
18538 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18539 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18540 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18541
18542 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18543 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18544 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18545 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18546 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18547 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18548 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18549 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18550 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18551 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18552 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18553
18554 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18555 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18556 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18557
18558 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18559 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18560 }
18561
18562 // reset default fan speed
18563
18564 #ifdef HAVE_HWMON
18565 if (gpu_temp_disable == 0)
18566 {
18567 if (gpu_temp_retain != 0)
18568 {
18569 hc_thread_mutex_lock (mux_adl);
18570
18571 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18572 {
18573 hc_device_param_t *device_param = &data.devices_param[device_id];
18574
18575 if (device_param->skipped) continue;
18576
18577 if (data.hm_device[device_id].fan_set_supported == 1)
18578 {
18579 int rc = -1;
18580
18581 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18582 {
18583 rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0);
18584 }
18585 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18586 {
18587 #ifdef LINUX
18588 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18589 #endif
18590
18591 #ifdef WIN
18592 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 0);
18593 #endif
18594 }
18595
18596 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18597 }
18598 }
18599
18600 hc_thread_mutex_unlock (mux_adl);
18601 }
18602 }
18603
18604 // reset power tuning
18605
18606 if (powertune_enable == 1)
18607 {
18608 hc_thread_mutex_lock (mux_adl);
18609
18610 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18611 {
18612 hc_device_param_t *device_param = &data.devices_param[device_id];
18613
18614 if (device_param->skipped) continue;
18615
18616 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18617 {
18618 if (data.hm_device[device_id].od_version == 6)
18619 {
18620 // check powertune capabilities first, if not available then skip device
18621
18622 int powertune_supported = 0;
18623
18624 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18625 {
18626 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18627
18628 return (-1);
18629 }
18630
18631 if (powertune_supported != 0)
18632 {
18633 // powercontrol settings
18634
18635 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18636 {
18637 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18638
18639 return (-1);
18640 }
18641
18642 // clocks
18643
18644 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18645
18646 performance_state->iNumberOfPerformanceLevels = 2;
18647
18648 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18649 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18650 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18651 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18652
18653 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18654 {
18655 log_info ("ERROR: Failed to restore ADL performance state");
18656
18657 return (-1);
18658 }
18659
18660 local_free (performance_state);
18661 }
18662 }
18663 }
18664
18665 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18666 {
18667 unsigned int limit = nvml_power_limit[device_id];
18668
18669 if (limit > 0)
18670 {
18671 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18672 }
18673 }
18674 }
18675
18676 hc_thread_mutex_unlock (mux_adl);
18677 }
18678
18679 if (gpu_temp_disable == 0)
18680 {
18681 if (data.hm_nvml)
18682 {
18683 hm_NVML_nvmlShutdown (data.hm_nvml);
18684
18685 nvml_close (data.hm_nvml);
18686
18687 data.hm_nvml = NULL;
18688 }
18689
18690 if (data.hm_nvapi)
18691 {
18692 hm_NvAPI_Unload (data.hm_nvapi);
18693
18694 nvapi_close (data.hm_nvapi);
18695
18696 data.hm_nvapi = NULL;
18697 }
18698
18699 if (data.hm_xnvctrl)
18700 {
18701 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18702
18703 xnvctrl_close (data.hm_xnvctrl);
18704
18705 data.hm_xnvctrl = NULL;
18706 }
18707
18708 if (data.hm_adl)
18709 {
18710 hm_ADL_Main_Control_Destroy (data.hm_adl);
18711
18712 adl_close (data.hm_adl);
18713
18714 data.hm_adl = NULL;
18715 }
18716 }
18717 #endif // HAVE_HWMON
18718
18719 // free memory
18720
18721 local_free (masks);
18722
18723 local_free (dictstat_base);
18724
18725 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18726 {
18727 pot_t *pot_ptr = &pot[pot_pos];
18728
18729 hash_t *hash = &pot_ptr->hash;
18730
18731 local_free (hash->digest);
18732
18733 if (isSalted)
18734 {
18735 local_free (hash->salt);
18736 }
18737 }
18738
18739 local_free (pot);
18740
18741 local_free (all_kernel_rules_cnt);
18742 local_free (all_kernel_rules_buf);
18743
18744 local_free (wl_data->buf);
18745 local_free (wl_data);
18746
18747 local_free (bitmap_s1_a);
18748 local_free (bitmap_s1_b);
18749 local_free (bitmap_s1_c);
18750 local_free (bitmap_s1_d);
18751 local_free (bitmap_s2_a);
18752 local_free (bitmap_s2_b);
18753 local_free (bitmap_s2_c);
18754 local_free (bitmap_s2_d);
18755
18756 #ifdef HAVE_HWMON
18757 local_free (od_clock_mem_status);
18758 local_free (od_power_control_status);
18759 local_free (nvml_power_limit);
18760 #endif
18761
18762 global_free (devices_param);
18763
18764 global_free (kernel_rules_buf);
18765
18766 global_free (root_css_buf);
18767 global_free (markov_css_buf);
18768
18769 global_free (digests_buf);
18770 global_free (digests_shown);
18771 global_free (digests_shown_tmp);
18772
18773 global_free (salts_buf);
18774 global_free (salts_shown);
18775
18776 global_free (esalts_buf);
18777
18778 global_free (words_progress_done);
18779 global_free (words_progress_rejected);
18780 global_free (words_progress_restored);
18781
18782 if (pot_fp) fclose (pot_fp);
18783
18784 if (data.devices_status == STATUS_QUIT) break;
18785 }
18786
18787 // wait for outer threads
18788
18789 data.shutdown_outer = 1;
18790
18791 for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++)
18792 {
18793 hc_thread_wait (1, &outer_threads[thread_idx]);
18794 }
18795
18796 local_free (outer_threads);
18797
18798 // destroy others mutex
18799
18800 hc_thread_mutex_delete (mux_dispatcher);
18801 hc_thread_mutex_delete (mux_counter);
18802 hc_thread_mutex_delete (mux_display);
18803 hc_thread_mutex_delete (mux_adl);
18804
18805 // free memory
18806
18807 local_free (eff_restore_file);
18808 local_free (new_restore_file);
18809
18810 local_free (rd);
18811
18812 // tuning db
18813
18814 tuning_db_destroy (tuning_db);
18815
18816 // loopback
18817
18818 local_free (loopback_file);
18819
18820 if (loopback == 1) unlink (loopback_file);
18821
18822 // induction directory
18823
18824 if (induction_dir == NULL)
18825 {
18826 if (attack_mode != ATTACK_MODE_BF)
18827 {
18828 if (rmdir (induction_directory) == -1)
18829 {
18830 if (errno == ENOENT)
18831 {
18832 // good, we can ignore
18833 }
18834 else if (errno == ENOTEMPTY)
18835 {
18836 // good, we can ignore
18837 }
18838 else
18839 {
18840 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18841
18842 return (-1);
18843 }
18844 }
18845
18846 local_free (induction_directory);
18847 }
18848 }
18849
18850 // outfile-check directory
18851
18852 if (outfile_check_dir == NULL)
18853 {
18854 if (rmdir (outfile_check_directory) == -1)
18855 {
18856 if (errno == ENOENT)
18857 {
18858 // good, we can ignore
18859 }
18860 else if (errno == ENOTEMPTY)
18861 {
18862 // good, we can ignore
18863 }
18864 else
18865 {
18866 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18867
18868 return (-1);
18869 }
18870 }
18871
18872 local_free (outfile_check_directory);
18873 }
18874
18875 time_t proc_stop;
18876
18877 time (&proc_stop);
18878
18879 logfile_top_uint (proc_start);
18880 logfile_top_uint (proc_stop);
18881
18882 logfile_top_msg ("STOP");
18883
18884 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18885 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18886
18887 if (data.ocl) ocl_close (data.ocl);
18888
18889 if (data.devices_status == STATUS_ABORTED) return 2;
18890 if (data.devices_status == STATUS_QUIT) return 2;
18891 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18892 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18893 if (data.devices_status == STATUS_CRACKED) return 0;
18894
18895 return -1;
18896 }
Hashcat additions to support pwdhash