projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fixed a bug where hashcat did not check the return of realpath() and crashes uncontro...
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef DARWIN
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define STDOUT_FLAG 0
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define MACHINE_READABLE 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define NVIDIA_SPIN_DAMP 100
79 #define GPU_TEMP_DISABLE 0
80 #define GPU_TEMP_ABORT 90
81 #define GPU_TEMP_RETAIN 75
82 #define WORKLOAD_PROFILE 2
83 #define KERNEL_ACCEL 0
84 #define KERNEL_LOOPS 0
85 #define KERNEL_RULES 1024
86 #define KERNEL_COMBS 1024
87 #define KERNEL_BFS 1024
88 #define KERNEL_THREADS_MAX 256
89 #define KERNEL_THREADS_MAX_CPU 16
90 #define POWERTUNE_ENABLE 0
91 #define LOGFILE_DISABLE 0
92 #define SCRYPT_TMTO 0
93 #define OPENCL_VECTOR_WIDTH 0
94
95 #define WL_MODE_STDIN 1
96 #define WL_MODE_FILE 2
97 #define WL_MODE_MASK 3
98
99 #define HL_MODE_FILE 4
100 #define HL_MODE_ARG 5
101
102 #define HLFMTS_CNT 11
103 #define HLFMT_HASHCAT 0
104 #define HLFMT_PWDUMP 1
105 #define HLFMT_PASSWD 2
106 #define HLFMT_SHADOW 3
107 #define HLFMT_DCC 4
108 #define HLFMT_DCC2 5
109 #define HLFMT_NETNTLM1 7
110 #define HLFMT_NETNTLM2 8
111 #define HLFMT_NSLDAP 9
112 #define HLFMT_NSLDAPS 10
113
114 #define HLFMT_TEXT_HASHCAT "native hashcat"
115 #define HLFMT_TEXT_PWDUMP "pwdump"
116 #define HLFMT_TEXT_PASSWD "passwd"
117 #define HLFMT_TEXT_SHADOW "shadow"
118 #define HLFMT_TEXT_DCC "DCC"
119 #define HLFMT_TEXT_DCC2 "DCC 2"
120 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
121 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
122 #define HLFMT_TEXT_NSLDAP "nsldap"
123 #define HLFMT_TEXT_NSLDAPS "nsldaps"
124
125 #define ATTACK_MODE_STRAIGHT 0
126 #define ATTACK_MODE_COMBI 1
127 #define ATTACK_MODE_TOGGLE 2
128 #define ATTACK_MODE_BF 3
129 #define ATTACK_MODE_PERM 4
130 #define ATTACK_MODE_TABLE 5
131 #define ATTACK_MODE_HYBRID1 6
132 #define ATTACK_MODE_HYBRID2 7
133 #define ATTACK_MODE_NONE 100
134
135 #define ATTACK_KERN_STRAIGHT 0
136 #define ATTACK_KERN_COMBI 1
137 #define ATTACK_KERN_BF 3
138 #define ATTACK_KERN_NONE 100
139
140 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
141 #define ATTACK_EXEC_INSIDE_KERNEL 11
142
143 #define COMBINATOR_MODE_BASE_LEFT 10001
144 #define COMBINATOR_MODE_BASE_RIGHT 10002
145
146 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
147 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
148
149 #define MAX_CUT_TRIES 4
150
151 #define MAX_DICTSTAT 10000
152
153 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
154
155 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
156
157 #define global_free(attr) \
158 { \
159 myfree ((void *) data.attr); \
160 \
161 data.attr = NULL; \
162 }
163
164 #define local_free(attr) \
165 { \
166 myfree ((void *) attr); \
167 \
168 attr = NULL; \
169 }
170
171 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
172 #define HC_API_CALL __stdcall
173 #else
174 #define HC_API_CALL
175 #endif
176
177 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
178 {
179 900,
180 0,
181 5100,
182 100,
183 1400,
184 10800,
185 1700,
186 5000,
187 10100,
188 6000,
189 6100,
190 6900,
191 11700,
192 11800,
193 400,
194 8900,
195 11900,
196 12000,
197 10900,
198 12100,
199 23,
200 2500,
201 5300,
202 5400,
203 5500,
204 5600,
205 7300,
206 7500,
207 13100,
208 8300,
209 11100,
210 11200,
211 11400,
212 121,
213 2611,
214 2711,
215 2811,
216 8400,
217 11,
218 2612,
219 7900,
220 21,
221 11000,
222 124,
223 10000,
224 3711,
225 7600,
226 12,
227 131,
228 132,
229 1731,
230 200,
231 300,
232 3100,
233 112,
234 12300,
235 8000,
236 141,
237 1441,
238 1600,
239 12600,
240 1421,
241 101,
242 111,
243 1711,
244 3000,
245 1000,
246 1100,
247 2100,
248 12800,
249 1500,
250 12400,
251 500,
252 3200,
253 7400,
254 1800,
255 122,
256 1722,
257 7100,
258 6300,
259 6700,
260 6400,
261 6500,
262 2400,
263 2410,
264 5700,
265 9200,
266 9300,
267 22,
268 501,
269 5800,
270 8100,
271 8500,
272 7200,
273 9900,
274 7700,
275 7800,
276 10300,
277 8600,
278 8700,
279 9100,
280 133,
281 13500,
282 11600,
283 13600,
284 12500,
285 13000,
286 13200,
287 13300,
288 6211,
289 6221,
290 6231,
291 6241,
292 13711,
293 13721,
294 13731,
295 13741,
296 13751,
297 13761,
298 8800,
299 12900,
300 12200,
301 9700,
302 9710,
303 9800,
304 9810,
305 9400,
306 9500,
307 9600,
308 10400,
309 10410,
310 10500,
311 10600,
312 10700,
313 9000,
314 5200,
315 6800,
316 6600,
317 8200,
318 11300,
319 12700,
320 13400,
321 125
322 };
323
324 /**
325 * types
326 */
327
328 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
329
330 /**
331 * globals
332 */
333
334 static unsigned int full01 = 0x01010101;
335 static unsigned int full80 = 0x80808080;
336
337 int SUPPRESS_OUTPUT = 0;
338
339 hc_thread_mutex_t mux_adl;
340 hc_thread_mutex_t mux_counter;
341 hc_thread_mutex_t mux_dispatcher;
342 hc_thread_mutex_t mux_display;
343
344 hc_global_data_t data;
345
346 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
347
348 const char *USAGE_MINI[] =
349 {
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "Try --help for more help.",
353 NULL
354 };
355
356 const char *USAGE_BIG[] =
357 {
358 "%s, advanced password recovery",
359 "",
360 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
361 "",
362 "- [ Options ] -",
363 "",
364 " Options Short / Long | Type | Description | Example",
365 "===============================+======+======================================================+=======================",
366 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
367 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
368 " -V, --version | | Print version |",
369 " -h, --help | | Print help |",
370 " --quiet | | Suppress output |",
371 " --hex-charset | | Assume charset is given in hex |",
372 " --hex-salt | | Assume salt is given in hex |",
373 " --hex-wordlist | | Assume words in wordlist is given in hex |",
374 " --force | | Ignore warnings |",
375 " --status | | Enable automatic update of the status-screen |",
376 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
377 " --machine-readable | | Display the status view in a machine readable format |",
378 " --loopback | | Add new plains to induct directory |",
379 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
380 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
381 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
382 " --markov-classic | | Enables classic markov-chains, no per-position |",
383 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
384 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
385 " --session | Str | Define specific session name | --session=mysession",
386 " --restore | | Restore session from --session |",
387 " --restore-disable | | Do not write restore file |",
388 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
389 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
390 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
391 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
392 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
393 " --stdout | | Do not crack a hash, instead print candidates only |",
394 " --show | | Compare hashlist with potfile; Show cracked hashes |",
395 " --left | | Compare hashlist with potfile; Show uncracked hashes |",
396 " --username | | Enable ignoring of usernames in hashfile |",
397 " --remove | | Enable remove of hash once it is cracked |",
398 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
399 " --potfile-disable | | Do not write potfile |",
400 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
401 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
402 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
403 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
404 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
405 " --logfile-disable | | Disable the logfile |",
406 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
407 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
408 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
409 " -b, --benchmark | | Run benchmark |",
410 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
411 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
412 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
413 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
414 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
415 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
416 " -D, --opencl-device-types | Str | OpenCL device-types to use, separate with comma | -D 1",
417 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
418 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
419 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
420 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
421 " --nvidia-spin-damp | Num | Workaround NVidias CPU burning loop bug, in percent | --nvidia-spin-damp=50",
422 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
423 #ifdef HAVE_HWMON
424 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
425 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
426 " --powertune-enable | | Enable power tuning, restores settings when finished |",
427 #endif
428 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
429 " -s, --skip | Num | Skip X words from the start | -s 1000000",
430 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
431 " --keyspace | | Show keyspace base:mod values and quit |",
432 " -j, --rule-left | Rule | Single rule applied to each word from left wordlist | -j 'c'",
433 " -k, --rule-right | Rule | Single rule applied to each word from right wordlist | -k '^-'",
434 " -r, --rules-file | File | Multiple rules applied to each word from wordlists | -r rules/best64.rule",
435 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
436 " --generate-rules-func-min | Num | Force min X funcs per rule |",
437 " --generate-rules-func-max | Num | Force max X funcs per rule |",
438 " --generate-rules-seed | Num | Force RNG seed set to X |",
439 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
440 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
441 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
442 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
443 " -i, --increment | | Enable mask increment mode |",
444 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
445 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
446 "",
447 "- [ Hash modes ] -",
448 "",
449 " # | Name | Category",
450 " ======+==================================================+======================================",
451 " 900 | MD4 | Raw Hash",
452 " 0 | MD5 | Raw Hash",
453 " 5100 | Half MD5 | Raw Hash",
454 " 100 | SHA1 | Raw Hash",
455 " 10800 | SHA-384 | Raw Hash",
456 " 1400 | SHA-256 | Raw Hash",
457 " 1700 | SHA-512 | Raw Hash",
458 " 5000 | SHA-3(Keccak) | Raw Hash",
459 " 10100 | SipHash | Raw Hash",
460 " 6000 | RipeMD160 | Raw Hash",
461 " 6100 | Whirlpool | Raw Hash",
462 " 6900 | GOST R 34.11-94 | Raw Hash",
463 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
464 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
465 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
466 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
467 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
468 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
469 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
471 " 2600 | md5(md5($pass)) | Raw Hash, Salted and / or Iterated",
472 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
473 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
474 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
476 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
477 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
478 " 4500 | sha1(sha1($pass)) | Raw Hash, Salted and / or Iterated",
479 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
480 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
481 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
482 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
483 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
484 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
485 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
486 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
487 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
488 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
489 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
490 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
491 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
492 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
493 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
494 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
495 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
496 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
497 " 400 | phpass | Generic KDF",
498 " 8900 | scrypt | Generic KDF",
499 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
500 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
501 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
502 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
503 " 23 | Skype | Network protocols",
504 " 2500 | WPA/WPA2 | Network protocols",
505 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
506 " 5300 | IKE-PSK MD5 | Network protocols",
507 " 5400 | IKE-PSK SHA1 | Network protocols",
508 " 5500 | NetNTLMv1 | Network protocols",
509 " 5500 | NetNTLMv1 + ESS | Network protocols",
510 " 5600 | NetNTLMv2 | Network protocols",
511 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
512 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
513 " 8300 | DNSSEC (NSEC3) | Network protocols",
514 " 10200 | Cram MD5 | Network protocols",
515 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
516 " 11200 | MySQL CRAM (SHA1) | Network protocols",
517 " 11400 | SIP digest authentication (MD5) | Network protocols",
518 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
519 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
520 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
521 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
522 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
523 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
524 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
525 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
526 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
527 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
528 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
529 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
530 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
531 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
532 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
533 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
534 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
535 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
536 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
537 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
538 " 12 | PostgreSQL | Database Server",
539 " 131 | MSSQL(2000) | Database Server",
540 " 132 | MSSQL(2005) | Database Server",
541 " 1731 | MSSQL(2012) | Database Server",
542 " 1731 | MSSQL(2014) | Database Server",
543 " 200 | MySQL323 | Database Server",
544 " 300 | MySQL4.1/MySQL5 | Database Server",
545 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
546 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
547 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
548 " 8000 | Sybase ASE | Database Server",
549 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
550 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
551 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
552 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
553 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
554 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
555 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
556 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
557 " 11500 | CRC32 | Checksums",
558 " 3000 | LM | Operating-Systems",
559 " 1000 | NTLM | Operating-Systems",
560 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
561 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
562 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
563 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
564 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
565 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
566 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
567 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
568 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
569 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
570 " 1722 | OSX v10.7 | Operating-Systems",
571 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
572 " 6300 | AIX {smd5} | Operating-Systems",
573 " 6700 | AIX {ssha1} | Operating-Systems",
574 " 6400 | AIX {ssha256} | Operating-Systems",
575 " 6500 | AIX {ssha512} | Operating-Systems",
576 " 2400 | Cisco-PIX | Operating-Systems",
577 " 2410 | Cisco-ASA | Operating-Systems",
578 " 500 | Cisco-IOS $1$ | Operating-Systems",
579 " 5700 | Cisco-IOS $4$ | Operating-Systems",
580 " 9200 | Cisco-IOS $8$ | Operating-Systems",
581 " 9300 | Cisco-IOS $9$ | Operating-Systems",
582 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
583 " 501 | Juniper IVE | Operating-Systems",
584 " 5800 | Android PIN | Operating-Systems",
585 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
586 " 8100 | Citrix Netscaler | Operating-Systems",
587 " 8500 | RACF | Operating-Systems",
588 " 7200 | GRUB 2 | Operating-Systems",
589 " 9900 | Radmin2 | Operating-Systems",
590 " 125 | ArubaOS | Operating-Systems",
591 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
592 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
593 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
594 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
595 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
596 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
597 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
598 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
599 " 11600 | 7-Zip | Archives",
600 " 12500 | RAR3-hp | Archives",
601 " 13000 | RAR5 | Archives",
602 " 13200 | AxCrypt | Archives",
603 " 13300 | AxCrypt in memory SHA1 | Archives",
604 " 13600 | WinZip | Archives",
605 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
606 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
607 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
608 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
609 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
610 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
611 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
612 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
615 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
616 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
617 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
618 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
619 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
620 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
621 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
622 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
623 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
624 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
625 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
626 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
627 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
628 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
629 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
630 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
631 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
632 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
635 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
636 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
637 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
638 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
639 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
640 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
641 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
642 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
643 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
644 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
645 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
646 " 9400 | MS Office 2007 | Documents",
647 " 9500 | MS Office 2010 | Documents",
648 " 9600 | MS Office 2013 | Documents",
649 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
650 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
651 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
652 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
653 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
654 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
655 " 9000 | Password Safe v2 | Password Managers",
656 " 5200 | Password Safe v3 | Password Managers",
657 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
658 " 6600 | 1Password, agilekeychain | Password Managers",
659 " 8200 | 1Password, cloudkeychain | Password Managers",
660 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
661 " 12700 | Blockchain, My Wallet | Password Managers",
662 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
663 "",
664 "- [ Outfile Formats ] -",
665 "",
666 " # | Format",
667 " ===+========",
668 " 1 | hash[:salt]",
669 " 2 | plain",
670 " 3 | hash[:salt]:plain",
671 " 4 | hex_plain",
672 " 5 | hash[:salt]:hex_plain",
673 " 6 | plain:hex_plain",
674 " 7 | hash[:salt]:plain:hex_plain",
675 " 8 | crackpos",
676 " 9 | hash[:salt]:crack_pos",
677 " 10 | plain:crack_pos",
678 " 11 | hash[:salt]:plain:crack_pos",
679 " 12 | hex_plain:crack_pos",
680 " 13 | hash[:salt]:hex_plain:crack_pos",
681 " 14 | plain:hex_plain:crack_pos",
682 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
683 "",
684 "- [ Rule Debugging Modes ] -",
685 "",
686 " # | Format",
687 " ===+========",
688 " 1 | Finding-Rule",
689 " 2 | Original-Word",
690 " 3 | Original-Word:Finding-Rule",
691 " 4 | Original-Word:Finding-Rule:Processed-Word",
692 "",
693 "- [ Attack Modes ] -",
694 "",
695 " # | Mode",
696 " ===+======",
697 " 0 | Straight",
698 " 1 | Combination",
699 " 3 | Brute-force",
700 " 6 | Hybrid Wordlist + Mask",
701 " 7 | Hybrid Mask + Wordlist",
702 "",
703 "- [ Built-in Charsets ] -",
704 "",
705 " ? | Charset",
706 " ===+=========",
707 " l | abcdefghijklmnopqrstuvwxyz",
708 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
709 " d | 0123456789",
710 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
711 " a | ?l?u?d?s",
712 " b | 0x00 - 0xff",
713 "",
714 "- [ OpenCL Device Types ] -",
715 "",
716 " # | Device Type",
717 " ===+=============",
718 " 1 | CPU",
719 " 2 | GPU",
720 " 3 | FPGA, DSP, Co-Processor",
721 "",
722 "- [ Workload Profiles ] -",
723 "",
724 " # | Performance | Runtime | Power Consumption | Desktop Impact",
725 " ===+=============+=========+===================+=================",
726 " 1 | Low | 2 ms | Low | Minimal",
727 " 2 | Default | 12 ms | Economic | Noticeable",
728 " 3 | High | 96 ms | High | Unresponsive",
729 " 4 | Nightmare | 480 ms | Insane | Headless",
730 "",
731 "- [ Basic Examples ] -",
732 "",
733 " Attack- | Hash- |",
734 " Mode | Type | Example command",
735 " ==================+=======+==================================================================",
736 " Wordlist | $P$ | %s -a 0 -m 400 example400.hash example.dict",
737 " Wordlist + Rules | MD5 | %s -a 0 -m 0 example0.hash example.dict -r rules/best64.rule",
738 " Brute-Force | MD5 | %s -a 3 -m 0 example0.hash ?a?a?a?a?a?a",
739 " Combinator | MD5 | %s -a 1 -m 0 example0.hash example.dict example.dict",
740 "",
741 "If you still have no idea what just happened try following pages:",
742 "",
743 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
744 "* https://hashcat.net/wiki/#frequently_asked_questions",
745 NULL
746 };
747
748 /**
749 * hashcat specific functions
750 */
751
752 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
753 {
754 int exec_pos = (int) device_param->exec_pos - last_num_entries;
755
756 if (exec_pos < 0) exec_pos += EXEC_CACHE;
757
758 double exec_ms_sum = 0;
759
760 int exec_ms_cnt = 0;
761
762 for (int i = 0; i < last_num_entries; i++)
763 {
764 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
765
766 if (exec_ms)
767 {
768 exec_ms_sum += exec_ms;
769
770 exec_ms_cnt++;
771 }
772 }
773
774 if (exec_ms_cnt == 0) return 0;
775
776 return exec_ms_sum / exec_ms_cnt;
777 }
778
779 void status_display_machine_readable ()
780 {
781 FILE *out = stdout;
782
783 fprintf (out, "STATUS\t%u\t", data.devices_status);
784
785 /**
786 * speed new
787 */
788
789 fprintf (out, "SPEED\t");
790
791 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
792 {
793 hc_device_param_t *device_param = &data.devices_param[device_id];
794
795 if (device_param->skipped) continue;
796
797 u64 speed_cnt = 0;
798 double speed_ms = 0;
799
800 for (int i = 0; i < SPEED_CACHE; i++)
801 {
802 speed_cnt += device_param->speed_cnt[i];
803 speed_ms += device_param->speed_ms[i];
804 }
805
806 speed_cnt /= SPEED_CACHE;
807 speed_ms /= SPEED_CACHE;
808
809 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
810 }
811
812 /**
813 * exec time
814 */
815
816 fprintf (out, "EXEC_RUNTIME\t");
817
818 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
819 {
820 hc_device_param_t *device_param = &data.devices_param[device_id];
821
822 if (device_param->skipped) continue;
823
824 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
825
826 fprintf (out, "%f\t", exec_ms_avg);
827 }
828
829 /**
830 * words_cur
831 */
832
833 u64 words_cur = get_lowest_words_done ();
834
835 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
836
837 /**
838 * counter
839 */
840
841 u64 progress_total = data.words_cnt * data.salts_cnt;
842
843 u64 all_done = 0;
844 u64 all_rejected = 0;
845 u64 all_restored = 0;
846
847 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
848 {
849 all_done += data.words_progress_done[salt_pos];
850 all_rejected += data.words_progress_rejected[salt_pos];
851 all_restored += data.words_progress_restored[salt_pos];
852 }
853
854 u64 progress_cur = all_restored + all_done + all_rejected;
855 u64 progress_end = progress_total;
856
857 u64 progress_skip = 0;
858
859 if (data.skip)
860 {
861 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
862
863 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
864 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
865 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
866 }
867
868 if (data.limit)
869 {
870 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
871
872 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
873 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
874 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
875 }
876
877 u64 progress_cur_relative_skip = progress_cur - progress_skip;
878 u64 progress_end_relative_skip = progress_end - progress_skip;
879
880 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
881
882 /**
883 * cracks
884 */
885
886 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
887 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
888
889 /**
890 * temperature
891 */
892
893 #ifdef HAVE_HWMON
894 if (data.gpu_temp_disable == 0)
895 {
896 fprintf (out, "TEMP\t");
897
898 hc_thread_mutex_lock (mux_adl);
899
900 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
901 {
902 hc_device_param_t *device_param = &data.devices_param[device_id];
903
904 if (device_param->skipped) continue;
905
906 int temp = hm_get_temperature_with_device_id (device_id);
907
908 fprintf (out, "%d\t", temp);
909 }
910
911 hc_thread_mutex_unlock (mux_adl);
912 }
913 #endif // HAVE_HWMON
914
915 /**
916 * flush
917 */
918
919 fputs (EOL, out);
920 fflush (out);
921 }
922
923 void status_display ()
924 {
925 if (data.devices_status == STATUS_INIT) return;
926 if (data.devices_status == STATUS_STARTING) return;
927
928 if (data.machine_readable == 1)
929 {
930 status_display_machine_readable ();
931
932 return;
933 }
934
935 char tmp_buf[1000] = { 0 };
936
937 uint tmp_len = 0;
938
939 log_info ("Session.Name...: %s", data.session);
940
941 char *status_type = strstatus (data.devices_status);
942
943 uint hash_mode = data.hash_mode;
944
945 char *hash_type = strhashtype (hash_mode); // not a bug
946
947 log_info ("Status.........: %s", status_type);
948
949 /**
950 * show rules
951 */
952
953 if (data.rp_files_cnt)
954 {
955 uint i;
956
957 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
958 {
959 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
960 }
961
962 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
963
964 log_info ("Rules.Type.....: %s", tmp_buf);
965
966 tmp_len = 0;
967 }
968
969 if (data.rp_gen)
970 {
971 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
972
973 if (data.rp_gen_seed)
974 {
975 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
976 }
977 }
978
979 /**
980 * show input
981 */
982
983 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
984 {
985 if (data.wordlist_mode == WL_MODE_FILE)
986 {
987 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
988 }
989 else if (data.wordlist_mode == WL_MODE_STDIN)
990 {
991 log_info ("Input.Mode.....: Pipe");
992 }
993 }
994 else if (data.attack_mode == ATTACK_MODE_COMBI)
995 {
996 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
997 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
998 }
999 else if (data.attack_mode == ATTACK_MODE_BF)
1000 {
1001 char *mask = data.mask;
1002
1003 if (mask != NULL)
1004 {
1005 uint mask_len = data.css_cnt;
1006
1007 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1008
1009 if (mask_len > 0)
1010 {
1011 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1012 {
1013 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1014 {
1015 mask_len -= data.salts_buf[0].salt_len;
1016 }
1017 }
1018
1019 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1020
1021 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1022 }
1023
1024 if (data.maskcnt > 1)
1025 {
1026 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1027
1028 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1029 }
1030
1031 log_info ("Input.Mode.....: %s", tmp_buf);
1032 }
1033
1034 tmp_len = 0;
1035 }
1036 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1037 {
1038 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1039 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1040 }
1041 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1042 {
1043 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1044 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1045 }
1046
1047 if (data.digests_cnt == 1)
1048 {
1049 if (data.hash_mode == 2500)
1050 {
1051 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1052
1053 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1054 (char *) data.salts_buf[0].salt_buf,
1055 wpa->orig_mac1[0],
1056 wpa->orig_mac1[1],
1057 wpa->orig_mac1[2],
1058 wpa->orig_mac1[3],
1059 wpa->orig_mac1[4],
1060 wpa->orig_mac1[5],
1061 wpa->orig_mac2[0],
1062 wpa->orig_mac2[1],
1063 wpa->orig_mac2[2],
1064 wpa->orig_mac2[3],
1065 wpa->orig_mac2[4],
1066 wpa->orig_mac2[5]);
1067 }
1068 else if (data.hash_mode == 5200)
1069 {
1070 log_info ("Hash.Target....: File (%s)", data.hashfile);
1071 }
1072 else if (data.hash_mode == 9000)
1073 {
1074 log_info ("Hash.Target....: File (%s)", data.hashfile);
1075 }
1076 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1077 {
1078 log_info ("Hash.Target....: File (%s)", data.hashfile);
1079 }
1080 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1081 {
1082 log_info ("Hash.Target....: File (%s)", data.hashfile);
1083 }
1084 else
1085 {
1086 char out_buf[HCBUFSIZ] = { 0 };
1087
1088 ascii_digest (out_buf, 0, 0);
1089
1090 // limit length
1091 if (strlen (out_buf) > 40)
1092 {
1093 out_buf[41] = '.';
1094 out_buf[42] = '.';
1095 out_buf[43] = '.';
1096 out_buf[44] = 0;
1097 }
1098
1099 log_info ("Hash.Target....: %s", out_buf);
1100 }
1101 }
1102 else
1103 {
1104 if (data.hash_mode == 3000)
1105 {
1106 char out_buf1[32] = { 0 };
1107 char out_buf2[32] = { 0 };
1108
1109 ascii_digest (out_buf1, 0, 0);
1110 ascii_digest (out_buf2, 0, 1);
1111
1112 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1113 }
1114 else
1115 {
1116 log_info ("Hash.Target....: File (%s)", data.hashfile);
1117 }
1118 }
1119
1120 log_info ("Hash.Type......: %s", hash_type);
1121
1122 /**
1123 * speed new
1124 */
1125
1126 u64 speed_cnt[DEVICES_MAX] = { 0 };
1127 double speed_ms[DEVICES_MAX] = { 0 };
1128
1129 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1130 {
1131 hc_device_param_t *device_param = &data.devices_param[device_id];
1132
1133 if (device_param->skipped) continue;
1134
1135 speed_cnt[device_id] = 0;
1136 speed_ms[device_id] = 0;
1137
1138 for (int i = 0; i < SPEED_CACHE; i++)
1139 {
1140 speed_cnt[device_id] += device_param->speed_cnt[i];
1141 speed_ms[device_id] += device_param->speed_ms[i];
1142 }
1143
1144 speed_cnt[device_id] /= SPEED_CACHE;
1145 speed_ms[device_id] /= SPEED_CACHE;
1146 }
1147
1148 double hashes_all_ms = 0;
1149
1150 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1151
1152 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1153 {
1154 hc_device_param_t *device_param = &data.devices_param[device_id];
1155
1156 if (device_param->skipped) continue;
1157
1158 hashes_dev_ms[device_id] = 0;
1159
1160 if (speed_ms[device_id])
1161 {
1162 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1163
1164 hashes_all_ms += hashes_dev_ms[device_id];
1165 }
1166 }
1167
1168 /**
1169 * exec time
1170 */
1171
1172 double exec_all_ms[DEVICES_MAX] = { 0 };
1173
1174 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1175 {
1176 hc_device_param_t *device_param = &data.devices_param[device_id];
1177
1178 if (device_param->skipped) continue;
1179
1180 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1181
1182 exec_all_ms[device_id] = exec_ms_avg;
1183 }
1184
1185 /**
1186 * timers
1187 */
1188
1189 double ms_running = 0;
1190
1191 hc_timer_get (data.timer_running, ms_running);
1192
1193 double ms_paused = data.ms_paused;
1194
1195 if (data.devices_status == STATUS_PAUSED)
1196 {
1197 double ms_paused_tmp = 0;
1198
1199 hc_timer_get (data.timer_paused, ms_paused_tmp);
1200
1201 ms_paused += ms_paused_tmp;
1202 }
1203
1204 #ifdef WIN
1205
1206 __time64_t sec_run = ms_running / 1000;
1207
1208 #else
1209
1210 time_t sec_run = ms_running / 1000;
1211
1212 #endif
1213
1214 if (sec_run)
1215 {
1216 char display_run[32] = { 0 };
1217
1218 struct tm tm_run;
1219
1220 struct tm *tmp = NULL;
1221
1222 #ifdef WIN
1223
1224 tmp = _gmtime64 (&sec_run);
1225
1226 #else
1227
1228 tmp = gmtime (&sec_run);
1229
1230 #endif
1231
1232 if (tmp != NULL)
1233 {
1234 memset (&tm_run, 0, sizeof (tm_run));
1235
1236 memcpy (&tm_run, tmp, sizeof (tm_run));
1237
1238 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1239
1240 char *start = ctime (&data.proc_start);
1241
1242 size_t start_len = strlen (start);
1243
1244 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1245 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1246
1247 log_info ("Time.Started...: %s (%s)", start, display_run);
1248 }
1249 }
1250 else
1251 {
1252 log_info ("Time.Started...: 0 secs");
1253 }
1254
1255 /**
1256 * counters
1257 */
1258
1259 u64 progress_total = data.words_cnt * data.salts_cnt;
1260
1261 u64 all_done = 0;
1262 u64 all_rejected = 0;
1263 u64 all_restored = 0;
1264
1265 u64 progress_noneed = 0;
1266
1267 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1268 {
1269 all_done += data.words_progress_done[salt_pos];
1270 all_rejected += data.words_progress_rejected[salt_pos];
1271 all_restored += data.words_progress_restored[salt_pos];
1272
1273 // Important for ETA only
1274
1275 if (data.salts_shown[salt_pos] == 1)
1276 {
1277 const u64 all = data.words_progress_done[salt_pos]
1278 + data.words_progress_rejected[salt_pos]
1279 + data.words_progress_restored[salt_pos];
1280
1281 const u64 left = data.words_cnt - all;
1282
1283 progress_noneed += left;
1284 }
1285 }
1286
1287 u64 progress_cur = all_restored + all_done + all_rejected;
1288 u64 progress_end = progress_total;
1289
1290 u64 progress_skip = 0;
1291
1292 if (data.skip)
1293 {
1294 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1295
1296 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1297 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1298 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1299 }
1300
1301 if (data.limit)
1302 {
1303 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1304
1305 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1306 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1307 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1308 }
1309
1310 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1311 u64 progress_end_relative_skip = progress_end - progress_skip;
1312
1313 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1314 {
1315 if (data.devices_status != STATUS_CRACKED)
1316 {
1317 #ifdef WIN
1318 __time64_t sec_etc = 0;
1319 #else
1320 time_t sec_etc = 0;
1321 #endif
1322
1323 if (hashes_all_ms)
1324 {
1325 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1326
1327 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1328
1329 sec_etc = ms_left / 1000;
1330 }
1331
1332 if (sec_etc == 0)
1333 {
1334 //log_info ("Time.Estimated.: 0 secs");
1335 }
1336 else if ((u64) sec_etc > ETC_MAX)
1337 {
1338 log_info ("Time.Estimated.: > 10 Years");
1339 }
1340 else
1341 {
1342 char display_etc[32] = { 0 };
1343
1344 struct tm tm_etc;
1345
1346 struct tm *tmp = NULL;
1347
1348 #ifdef WIN
1349
1350 tmp = _gmtime64 (&sec_etc);
1351
1352 #else
1353
1354 tmp = gmtime (&sec_etc);
1355
1356 #endif
1357
1358 if (tmp != NULL)
1359 {
1360 memset (&tm_etc, 0, sizeof (tm_etc));
1361
1362 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1363
1364 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1365
1366 time_t now;
1367
1368 time (&now);
1369
1370 now += sec_etc;
1371
1372 char *etc = ctime (&now);
1373
1374 size_t etc_len = strlen (etc);
1375
1376 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1377 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1378
1379 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1380 }
1381 }
1382 }
1383 }
1384
1385 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1386 {
1387 hc_device_param_t *device_param = &data.devices_param[device_id];
1388
1389 if (device_param->skipped) continue;
1390
1391 char display_dev_cur[16] = { 0 };
1392
1393 strncpy (display_dev_cur, "0.00", 4);
1394
1395 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1396
1397 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1398 }
1399
1400 char display_all_cur[16] = { 0 };
1401
1402 strncpy (display_all_cur, "0.00", 4);
1403
1404 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1405
1406 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1407
1408 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1409 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1410
1411 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1412
1413 // crack-per-time
1414
1415 if (data.digests_cnt > 100)
1416 {
1417 time_t now = time (NULL);
1418
1419 int cpt_cur_min = 0;
1420 int cpt_cur_hour = 0;
1421 int cpt_cur_day = 0;
1422
1423 for (int i = 0; i < CPT_BUF; i++)
1424 {
1425 const uint cracked = data.cpt_buf[i].cracked;
1426 const time_t timestamp = data.cpt_buf[i].timestamp;
1427
1428 if ((timestamp + 60) > now)
1429 {
1430 cpt_cur_min += cracked;
1431 }
1432
1433 if ((timestamp + 3600) > now)
1434 {
1435 cpt_cur_hour += cracked;
1436 }
1437
1438 if ((timestamp + 86400) > now)
1439 {
1440 cpt_cur_day += cracked;
1441 }
1442 }
1443
1444 double ms_real = ms_running - ms_paused;
1445
1446 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1447 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1448 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1449
1450 if ((data.cpt_start + 86400) < now)
1451 {
1452 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1453 cpt_cur_min,
1454 cpt_cur_hour,
1455 cpt_cur_day,
1456 cpt_avg_min,
1457 cpt_avg_hour,
1458 cpt_avg_day);
1459 }
1460 else if ((data.cpt_start + 3600) < now)
1461 {
1462 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1463 cpt_cur_min,
1464 cpt_cur_hour,
1465 cpt_avg_min,
1466 cpt_avg_hour,
1467 cpt_avg_day);
1468 }
1469 else if ((data.cpt_start + 60) < now)
1470 {
1471 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1472 cpt_cur_min,
1473 cpt_avg_min,
1474 cpt_avg_hour,
1475 cpt_avg_day);
1476 }
1477 else
1478 {
1479 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1480 cpt_avg_min,
1481 cpt_avg_hour,
1482 cpt_avg_day);
1483 }
1484 }
1485
1486 // Restore point
1487
1488 u64 restore_point = get_lowest_words_done ();
1489
1490 u64 restore_total = data.words_base;
1491
1492 float percent_restore = 0;
1493
1494 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1495
1496 if (progress_end_relative_skip)
1497 {
1498 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1499 {
1500 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1501 float percent_rejected = 0.0;
1502
1503 if (progress_cur)
1504 {
1505 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1506 }
1507
1508 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1509 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1510
1511 if (data.restore_disable == 0)
1512 {
1513 if (percent_finished != 1)
1514 {
1515 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1516 }
1517 }
1518 }
1519 }
1520 else
1521 {
1522 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1523 {
1524 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1525 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1526
1527 if (data.restore_disable == 0)
1528 {
1529 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1530 }
1531 }
1532 else
1533 {
1534 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1535 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1536
1537 // --restore not allowed if stdin is used -- really? why?
1538
1539 //if (data.restore_disable == 0)
1540 //{
1541 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1542 //}
1543 }
1544 }
1545
1546 #ifdef HAVE_HWMON
1547
1548 if (data.devices_status == STATUS_EXHAUSTED) return;
1549 if (data.devices_status == STATUS_CRACKED) return;
1550 if (data.devices_status == STATUS_ABORTED) return;
1551 if (data.devices_status == STATUS_QUIT) return;
1552
1553 if (data.gpu_temp_disable == 0)
1554 {
1555 hc_thread_mutex_lock (mux_adl);
1556
1557 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1558 {
1559 hc_device_param_t *device_param = &data.devices_param[device_id];
1560
1561 if (device_param->skipped) continue;
1562
1563 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1564 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1565 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1566 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1567 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1568 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1569 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1570
1571 char output_buf[256] = { 0 };
1572
1573 int output_len = 0;
1574
1575 if (num_temperature >= 0)
1576 {
1577 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1578
1579 output_len = strlen (output_buf);
1580 }
1581
1582 if (num_fanspeed >= 0)
1583 {
1584 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1585
1586 output_len = strlen (output_buf);
1587 }
1588
1589 if (num_utilization >= 0)
1590 {
1591 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1592
1593 output_len = strlen (output_buf);
1594 }
1595
1596 if (num_corespeed >= 0)
1597 {
1598 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1599
1600 output_len = strlen (output_buf);
1601 }
1602
1603 if (num_memoryspeed >= 0)
1604 {
1605 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1606
1607 output_len = strlen (output_buf);
1608 }
1609
1610 if (num_buslanes >= 0)
1611 {
1612 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1613
1614 output_len = strlen (output_buf);
1615 }
1616
1617 if (num_throttle == 1)
1618 {
1619 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1620
1621 output_len = strlen (output_buf);
1622 }
1623
1624 if (output_len == 0)
1625 {
1626 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1627
1628 output_len = strlen (output_buf);
1629 }
1630
1631 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1632 }
1633
1634 hc_thread_mutex_unlock (mux_adl);
1635 }
1636
1637 #endif // HAVE_HWMON
1638 }
1639
1640 static void status_benchmark_automate ()
1641 {
1642 u64 speed_cnt[DEVICES_MAX] = { 0 };
1643 double speed_ms[DEVICES_MAX] = { 0 };
1644
1645 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1646 {
1647 hc_device_param_t *device_param = &data.devices_param[device_id];
1648
1649 if (device_param->skipped) continue;
1650
1651 speed_cnt[device_id] = device_param->speed_cnt[0];
1652 speed_ms[device_id] = device_param->speed_ms[0];
1653 }
1654
1655 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1656
1657 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1658 {
1659 hc_device_param_t *device_param = &data.devices_param[device_id];
1660
1661 if (device_param->skipped) continue;
1662
1663 hashes_dev_ms[device_id] = 0;
1664
1665 if (speed_ms[device_id])
1666 {
1667 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1668 }
1669 }
1670
1671 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1672 {
1673 hc_device_param_t *device_param = &data.devices_param[device_id];
1674
1675 if (device_param->skipped) continue;
1676
1677 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1678 }
1679 }
1680
1681 static void status_benchmark ()
1682 {
1683 if (data.devices_status == STATUS_INIT) return;
1684 if (data.devices_status == STATUS_STARTING) return;
1685
1686 if (data.machine_readable == 1)
1687 {
1688 status_benchmark_automate ();
1689
1690 return;
1691 }
1692
1693 u64 speed_cnt[DEVICES_MAX] = { 0 };
1694 double speed_ms[DEVICES_MAX] = { 0 };
1695
1696 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1697 {
1698 hc_device_param_t *device_param = &data.devices_param[device_id];
1699
1700 if (device_param->skipped) continue;
1701
1702 speed_cnt[device_id] = device_param->speed_cnt[0];
1703 speed_ms[device_id] = device_param->speed_ms[0];
1704 }
1705
1706 double hashes_all_ms = 0;
1707
1708 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1709
1710 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1711 {
1712 hc_device_param_t *device_param = &data.devices_param[device_id];
1713
1714 if (device_param->skipped) continue;
1715
1716 hashes_dev_ms[device_id] = 0;
1717
1718 if (speed_ms[device_id])
1719 {
1720 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1721
1722 hashes_all_ms += hashes_dev_ms[device_id];
1723 }
1724 }
1725
1726 /**
1727 * exec time
1728 */
1729
1730 double exec_all_ms[DEVICES_MAX] = { 0 };
1731
1732 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1733 {
1734 hc_device_param_t *device_param = &data.devices_param[device_id];
1735
1736 if (device_param->skipped) continue;
1737
1738 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1739
1740 exec_all_ms[device_id] = exec_ms_avg;
1741 }
1742
1743 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1744 {
1745 hc_device_param_t *device_param = &data.devices_param[device_id];
1746
1747 if (device_param->skipped) continue;
1748
1749 char display_dev_cur[16] = { 0 };
1750
1751 strncpy (display_dev_cur, "0.00", 4);
1752
1753 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1754
1755 if (data.devices_active >= 10)
1756 {
1757 log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1758 }
1759 else
1760 {
1761 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1762 }
1763 }
1764
1765 char display_all_cur[16] = { 0 };
1766
1767 strncpy (display_all_cur, "0.00", 4);
1768
1769 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1770
1771 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1772 }
1773
1774 /**
1775 * hashcat -only- functions
1776 */
1777
1778 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1779 {
1780 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1781 {
1782 if (attack_kern == ATTACK_KERN_STRAIGHT)
1783 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1784 else if (attack_kern == ATTACK_KERN_COMBI)
1785 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1786 else if (attack_kern == ATTACK_KERN_BF)
1787 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1788 }
1789 else
1790 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1791 }
1792
1793 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)
1794 {
1795 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1796 {
1797 if (attack_kern == ATTACK_KERN_STRAIGHT)
1798 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1799 else if (attack_kern == ATTACK_KERN_COMBI)
1800 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1801 else if (attack_kern == ATTACK_KERN_BF)
1802 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1803 }
1804 else
1805 {
1806 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1807 }
1808 }
1809
1810 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1811 {
1812 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1813 {
1814 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1815 }
1816 else
1817 {
1818 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1819 }
1820 }
1821
1822 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)
1823 {
1824 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1825 {
1826 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1827 }
1828 else
1829 {
1830 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1831 }
1832 }
1833
1834 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1835 {
1836 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1837 }
1838
1839 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1840 {
1841 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1842 }
1843
1844 static char *filename_from_filepath (char *filepath)
1845 {
1846 char *ptr = NULL;
1847
1848 if ((ptr = strrchr (filepath, '/')) != NULL)
1849 {
1850 ptr++;
1851 }
1852 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1853 {
1854 ptr++;
1855 }
1856 else
1857 {
1858 ptr = filepath;
1859 }
1860
1861 return ptr;
1862 }
1863
1864 static uint convert_from_hex (char *line_buf, const uint line_len)
1865 {
1866 if (line_len & 1) return (line_len); // not in hex
1867
1868 if (data.hex_wordlist == 1)
1869 {
1870 uint i;
1871 uint j;
1872
1873 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1874 {
1875 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1876 }
1877
1878 memset (line_buf + i, 0, line_len - i);
1879
1880 return (i);
1881 }
1882 else if (line_len >= 6) // $HEX[] = 6
1883 {
1884 if (line_buf[0] != '$') return (line_len);
1885 if (line_buf[1] != 'H') return (line_len);
1886 if (line_buf[2] != 'E') return (line_len);
1887 if (line_buf[3] != 'X') return (line_len);
1888 if (line_buf[4] != '[') return (line_len);
1889 if (line_buf[line_len - 1] != ']') return (line_len);
1890
1891 uint i;
1892 uint j;
1893
1894 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1895 {
1896 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1897 }
1898
1899 memset (line_buf + i, 0, line_len - i);
1900
1901 return (i);
1902 }
1903
1904 return (line_len);
1905 }
1906
1907 static void clear_prompt ()
1908 {
1909 fputc ('\r', stdout);
1910
1911 for (size_t i = 0; i < strlen (PROMPT); i++)
1912 {
1913 fputc (' ', stdout);
1914 }
1915
1916 fputc ('\r', stdout);
1917
1918 fflush (stdout);
1919 }
1920
1921 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1922 {
1923 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);
1924 }
1925
1926 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1927 {
1928 char *outfile = data.outfile;
1929 uint quiet = data.quiet;
1930 FILE *pot_fp = data.pot_fp;
1931 uint loopback = data.loopback;
1932 uint debug_mode = data.debug_mode;
1933 char *debug_file = data.debug_file;
1934
1935 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1936 int debug_rule_len = 0; // -1 error
1937 uint debug_plain_len = 0;
1938
1939 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1940
1941 // hash
1942
1943 char out_buf[HCBUFSIZ] = { 0 };
1944
1945 const u32 salt_pos = plain->salt_pos;
1946 const u32 digest_pos = plain->digest_pos; // relative
1947 const u32 gidvid = plain->gidvid;
1948 const u32 il_pos = plain->il_pos;
1949
1950 ascii_digest (out_buf, salt_pos, digest_pos);
1951
1952 // plain
1953
1954 u64 crackpos = device_param->words_off;
1955
1956 uint plain_buf[16] = { 0 };
1957
1958 u8 *plain_ptr = (u8 *) plain_buf;
1959
1960 unsigned int plain_len = 0;
1961
1962 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1963 {
1964 pw_t pw;
1965
1966 gidd_to_pw_t (device_param, gidvid, &pw);
1967
1968 for (int i = 0; i < 16; i++)
1969 {
1970 plain_buf[i] = pw.i[i];
1971 }
1972
1973 plain_len = pw.pw_len;
1974
1975 const uint off = device_param->innerloop_pos + il_pos;
1976
1977 if (debug_mode > 0)
1978 {
1979 debug_rule_len = 0;
1980
1981 // save rule
1982 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1983 {
1984 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1985
1986 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1987 }
1988
1989 // save plain
1990 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1991 {
1992 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1993
1994 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1995
1996 debug_plain_len = plain_len;
1997 }
1998 }
1999
2000 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2001
2002 crackpos += gidvid;
2003 crackpos *= data.kernel_rules_cnt;
2004 crackpos += device_param->innerloop_pos + il_pos;
2005
2006 if (plain_len > data.pw_max) plain_len = data.pw_max;
2007 }
2008 else if (data.attack_mode == ATTACK_MODE_COMBI)
2009 {
2010 pw_t pw;
2011
2012 gidd_to_pw_t (device_param, gidvid, &pw);
2013
2014 for (int i = 0; i < 16; i++)
2015 {
2016 plain_buf[i] = pw.i[i];
2017 }
2018
2019 plain_len = pw.pw_len;
2020
2021 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2022 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2023
2024 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2025 {
2026 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2027 }
2028 else
2029 {
2030 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2031
2032 memcpy (plain_ptr, comb_buf, comb_len);
2033 }
2034
2035 plain_len += comb_len;
2036
2037 crackpos += gidvid;
2038 crackpos *= data.combs_cnt;
2039 crackpos += device_param->innerloop_pos + il_pos;
2040
2041 if (data.pw_max != PW_DICTMAX1)
2042 {
2043 if (plain_len > data.pw_max) plain_len = data.pw_max;
2044 }
2045 }
2046 else if (data.attack_mode == ATTACK_MODE_BF)
2047 {
2048 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2049 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2050
2051 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2052 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2053
2054 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2055 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2056
2057 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2058 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2059
2060 plain_len = data.css_cnt;
2061
2062 crackpos += gidvid;
2063 crackpos *= data.bfs_cnt;
2064 crackpos += device_param->innerloop_pos + il_pos;
2065 }
2066 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2067 {
2068 pw_t pw;
2069
2070 gidd_to_pw_t (device_param, gidvid, &pw);
2071
2072 for (int i = 0; i < 16; i++)
2073 {
2074 plain_buf[i] = pw.i[i];
2075 }
2076
2077 plain_len = pw.pw_len;
2078
2079 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2080
2081 uint start = 0;
2082 uint stop = device_param->kernel_params_mp_buf32[4];
2083
2084 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2085
2086 plain_len += start + stop;
2087
2088 crackpos += gidvid;
2089 crackpos *= data.combs_cnt;
2090 crackpos += device_param->innerloop_pos + il_pos;
2091
2092 if (data.pw_max != PW_DICTMAX1)
2093 {
2094 if (plain_len > data.pw_max) plain_len = data.pw_max;
2095 }
2096 }
2097 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2098 {
2099 pw_t pw;
2100
2101 gidd_to_pw_t (device_param, gidvid, &pw);
2102
2103 for (int i = 0; i < 16; i++)
2104 {
2105 plain_buf[i] = pw.i[i];
2106 }
2107
2108 plain_len = pw.pw_len;
2109
2110 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2111
2112 uint start = 0;
2113 uint stop = device_param->kernel_params_mp_buf32[4];
2114
2115 memmove (plain_ptr + stop, plain_ptr, plain_len);
2116
2117 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2118
2119 plain_len += start + stop;
2120
2121 crackpos += gidvid;
2122 crackpos *= data.combs_cnt;
2123 crackpos += device_param->innerloop_pos + il_pos;
2124
2125 if (data.pw_max != PW_DICTMAX1)
2126 {
2127 if (plain_len > data.pw_max) plain_len = data.pw_max;
2128 }
2129 }
2130
2131 if (data.attack_mode == ATTACK_MODE_BF)
2132 {
2133 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2134 {
2135 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2136 {
2137 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2138 {
2139 plain_len = plain_len - data.salts_buf[0].salt_len;
2140 }
2141 }
2142
2143 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2144 {
2145 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2146 {
2147 plain_ptr[j] = plain_ptr[i];
2148 }
2149
2150 plain_len = plain_len / 2;
2151 }
2152 }
2153 }
2154
2155 // if enabled, update also the potfile
2156
2157 if (pot_fp)
2158 {
2159 lock_file (pot_fp);
2160
2161 fprintf (pot_fp, "%s:", out_buf);
2162
2163 format_plain (pot_fp, plain_ptr, plain_len, 1);
2164
2165 fputc ('\n', pot_fp);
2166
2167 fflush (pot_fp);
2168
2169 unlock_file (pot_fp);
2170 }
2171
2172 // outfile
2173
2174 FILE *out_fp = NULL;
2175
2176 if (outfile != NULL)
2177 {
2178 if ((out_fp = fopen (outfile, "ab")) == NULL)
2179 {
2180 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2181
2182 out_fp = stdout;
2183 }
2184
2185 lock_file (out_fp);
2186 }
2187 else
2188 {
2189 out_fp = stdout;
2190
2191 if (quiet == 0) clear_prompt ();
2192 }
2193
2194 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2195
2196 if (outfile != NULL)
2197 {
2198 if (out_fp != stdout)
2199 {
2200 fclose (out_fp);
2201 }
2202 }
2203 else
2204 {
2205 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2206 {
2207 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2208 {
2209 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2210 if (quiet == 0) fflush (stdout);
2211 }
2212 }
2213 }
2214
2215 // loopback
2216
2217 if (loopback)
2218 {
2219 char *loopback_file = data.loopback_file;
2220
2221 FILE *fb_fp = NULL;
2222
2223 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2224 {
2225 lock_file (fb_fp);
2226
2227 format_plain (fb_fp, plain_ptr, plain_len, 1);
2228
2229 fputc ('\n', fb_fp);
2230
2231 fclose (fb_fp);
2232 }
2233 }
2234
2235 // (rule) debug mode
2236
2237 // the next check implies that:
2238 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2239 // - debug_mode > 0
2240
2241 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2242 {
2243 if (debug_rule_len < 0) debug_rule_len = 0;
2244
2245 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2246
2247 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2248
2249 if ((quiet == 0) && (debug_file == NULL))
2250 {
2251 fprintf (stdout, "%s", PROMPT);
2252
2253 fflush (stdout);
2254 }
2255 }
2256 }
2257
2258 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2259 {
2260 salt_t *salt_buf = &data.salts_buf[salt_pos];
2261
2262 u32 num_cracked;
2263
2264 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2265
2266 if (num_cracked)
2267 {
2268 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2269
2270 log_info_nn ("");
2271
2272 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2273
2274 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);
2275
2276 uint cpt_cracked = 0;
2277
2278 hc_thread_mutex_lock (mux_display);
2279
2280 for (uint i = 0; i < num_cracked; i++)
2281 {
2282 const uint hash_pos = cracked[i].hash_pos;
2283
2284 if (data.digests_shown[hash_pos] == 1) continue;
2285
2286 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2287 {
2288 data.digests_shown[hash_pos] = 1;
2289
2290 data.digests_done++;
2291
2292 cpt_cracked++;
2293
2294 salt_buf->digests_done++;
2295
2296 if (salt_buf->digests_done == salt_buf->digests_cnt)
2297 {
2298 data.salts_shown[salt_pos] = 1;
2299
2300 data.salts_done++;
2301 }
2302 }
2303
2304 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2305
2306 check_hash (device_param, &cracked[i]);
2307 }
2308
2309 hc_thread_mutex_unlock (mux_display);
2310
2311 myfree (cracked);
2312
2313 if (cpt_cracked > 0)
2314 {
2315 hc_thread_mutex_lock (mux_display);
2316
2317 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2318 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2319
2320 data.cpt_pos++;
2321
2322 data.cpt_total += cpt_cracked;
2323
2324 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2325
2326 hc_thread_mutex_unlock (mux_display);
2327 }
2328
2329 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2330 {
2331 // we need to reset cracked state on the device
2332 // otherwise host thinks again and again the hash was cracked
2333 // and returns invalid password each time
2334
2335 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2336
2337 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);
2338 }
2339
2340 num_cracked = 0;
2341
2342 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2343 }
2344 }
2345
2346 // stolen from princeprocessor ;)
2347
2348 typedef struct
2349 {
2350 FILE *fp;
2351
2352 char buf[BUFSIZ];
2353 int len;
2354
2355 } out_t;
2356
2357 static void out_flush (out_t *out)
2358 {
2359 fwrite (out->buf, 1, out->len, out->fp);
2360
2361 out->len = 0;
2362 }
2363
2364 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2365 {
2366 char *ptr = out->buf + out->len;
2367
2368 memcpy (ptr, pw_buf, pw_len);
2369
2370 ptr[pw_len] = '\n';
2371
2372 out->len += pw_len + 1;
2373
2374 if (out->len >= BUFSIZ - 100)
2375 {
2376 out_flush (out);
2377 }
2378 }
2379
2380 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2381 {
2382 out_t out;
2383
2384 out.fp = stdout;
2385 out.len = 0;
2386
2387 uint plain_buf[16] = { 0 };
2388
2389 u8 *plain_ptr = (u8 *) plain_buf;
2390
2391 uint plain_len = 0;
2392
2393 const uint il_cnt = device_param->kernel_params_buf32[30]; // ugly, i know
2394
2395 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2396 {
2397 pw_t pw;
2398
2399 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2400 {
2401 gidd_to_pw_t (device_param, gidvid, &pw);
2402
2403 const uint pos = device_param->innerloop_pos;
2404
2405 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2406 {
2407 for (int i = 0; i < 8; i++)
2408 {
2409 plain_buf[i] = pw.i[i];
2410 }
2411
2412 plain_len = pw.pw_len;
2413
2414 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2415
2416 if (plain_len > data.pw_max) plain_len = data.pw_max;
2417
2418 out_push (&out, plain_ptr, plain_len);
2419 }
2420 }
2421 }
2422 else if (data.attack_mode == ATTACK_MODE_COMBI)
2423 {
2424 pw_t pw;
2425
2426 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2427 {
2428 gidd_to_pw_t (device_param, gidvid, &pw);
2429
2430 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2431 {
2432 for (int i = 0; i < 8; i++)
2433 {
2434 plain_buf[i] = pw.i[i];
2435 }
2436
2437 plain_len = pw.pw_len;
2438
2439 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2440 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2441
2442 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2443 {
2444 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2445 }
2446 else
2447 {
2448 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2449
2450 memcpy (plain_ptr, comb_buf, comb_len);
2451 }
2452
2453 plain_len += comb_len;
2454
2455 if (data.pw_max != PW_DICTMAX1)
2456 {
2457 if (plain_len > data.pw_max) plain_len = data.pw_max;
2458 }
2459
2460 out_push (&out, plain_ptr, plain_len);
2461 }
2462 }
2463 }
2464 else if (data.attack_mode == ATTACK_MODE_BF)
2465 {
2466 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2467 {
2468 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2469 {
2470 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2471 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2472
2473 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2474 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2475
2476 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2477 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2478
2479 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2480 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2481
2482 plain_len = data.css_cnt;
2483
2484 out_push (&out, plain_ptr, plain_len);
2485 }
2486 }
2487 }
2488 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2489 {
2490 pw_t pw;
2491
2492 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2493 {
2494 gidd_to_pw_t (device_param, gidvid, &pw);
2495
2496 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2497 {
2498 for (int i = 0; i < 8; i++)
2499 {
2500 plain_buf[i] = pw.i[i];
2501 }
2502
2503 plain_len = pw.pw_len;
2504
2505 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2506
2507 uint start = 0;
2508 uint stop = device_param->kernel_params_mp_buf32[4];
2509
2510 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2511
2512 plain_len += start + stop;
2513
2514 out_push (&out, plain_ptr, plain_len);
2515 }
2516 }
2517 }
2518 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2519 {
2520 pw_t pw;
2521
2522 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2523 {
2524 gidd_to_pw_t (device_param, gidvid, &pw);
2525
2526 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2527 {
2528 for (int i = 0; i < 8; i++)
2529 {
2530 plain_buf[i] = pw.i[i];
2531 }
2532
2533 plain_len = pw.pw_len;
2534
2535 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2536
2537 uint start = 0;
2538 uint stop = device_param->kernel_params_mp_buf32[4];
2539
2540 memmove (plain_ptr + stop, plain_ptr, plain_len);
2541
2542 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2543
2544 plain_len += start + stop;
2545
2546 out_push (&out, plain_ptr, plain_len);
2547 }
2548 }
2549 }
2550
2551 out_flush (&out);
2552 }
2553
2554 static void save_hash ()
2555 {
2556 char *hashfile = data.hashfile;
2557
2558 char new_hashfile[256] = { 0 };
2559 char old_hashfile[256] = { 0 };
2560
2561 snprintf (new_hashfile, 255, "%s.new", hashfile);
2562 snprintf (old_hashfile, 255, "%s.old", hashfile);
2563
2564 unlink (new_hashfile);
2565
2566 char separator = data.separator;
2567
2568 FILE *fp = fopen (new_hashfile, "wb");
2569
2570 if (fp == NULL)
2571 {
2572 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2573
2574 exit (-1);
2575 }
2576
2577 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2578 {
2579 if (data.salts_shown[salt_pos] == 1) continue;
2580
2581 salt_t *salt_buf = &data.salts_buf[salt_pos];
2582
2583 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2584 {
2585 uint idx = salt_buf->digests_offset + digest_pos;
2586
2587 if (data.digests_shown[idx] == 1) continue;
2588
2589 if (data.hash_mode != 2500)
2590 {
2591 if (data.username == 1)
2592 {
2593 user_t *user = data.hash_info[idx]->user;
2594
2595 uint i;
2596
2597 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2598
2599 fputc (separator, fp);
2600 }
2601
2602 char out_buf[HCBUFSIZ]; // scratch buffer
2603
2604 out_buf[0] = 0;
2605
2606 ascii_digest (out_buf, salt_pos, digest_pos);
2607
2608 fputs (out_buf, fp);
2609
2610 fputc ('\n', fp);
2611 }
2612 else
2613 {
2614 hccap_t hccap;
2615
2616 to_hccap_t (&hccap, salt_pos, digest_pos);
2617
2618 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2619 }
2620 }
2621 }
2622
2623 fflush (fp);
2624
2625 fclose (fp);
2626
2627 unlink (old_hashfile);
2628
2629 if (rename (hashfile, old_hashfile) != 0)
2630 {
2631 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2632
2633 exit (-1);
2634 }
2635
2636 unlink (hashfile);
2637
2638 if (rename (new_hashfile, hashfile) != 0)
2639 {
2640 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2641
2642 exit (-1);
2643 }
2644
2645 unlink (old_hashfile);
2646 }
2647
2648 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2649 {
2650 uint num_elements = num;
2651
2652 device_param->kernel_params_buf32[33] = data.combs_mode;
2653 device_param->kernel_params_buf32[34] = num;
2654
2655 uint kernel_threads = device_param->kernel_threads;
2656
2657 while (num_elements % kernel_threads) num_elements++;
2658
2659 cl_kernel kernel = NULL;
2660
2661 switch (kern_run)
2662 {
2663 case KERN_RUN_1: kernel = device_param->kernel1; break;
2664 case KERN_RUN_12: kernel = device_param->kernel12; break;
2665 case KERN_RUN_2: kernel = device_param->kernel2; break;
2666 case KERN_RUN_23: kernel = device_param->kernel23; break;
2667 case KERN_RUN_3: kernel = device_param->kernel3; break;
2668 }
2669
2670 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2671 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2672 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2673 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2674 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2675 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2676 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2677 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2678 hc_clSetKernelArg (data.ocl, kernel, 32, sizeof (cl_uint), device_param->kernel_params[32]);
2679 hc_clSetKernelArg (data.ocl, kernel, 33, sizeof (cl_uint), device_param->kernel_params[33]);
2680 hc_clSetKernelArg (data.ocl, kernel, 34, sizeof (cl_uint), device_param->kernel_params[34]);
2681
2682 cl_event event;
2683
2684 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2685 {
2686 const size_t global_work_size[3] = { num_elements, 32, 1 };
2687 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2688
2689 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2690 }
2691 else
2692 {
2693 if (kern_run == KERN_RUN_2)
2694 {
2695 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2696 {
2697 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2698 }
2699 }
2700
2701 while (num_elements % kernel_threads) num_elements++;
2702
2703 const size_t global_work_size[3] = { num_elements, 1, 1 };
2704 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2705
2706 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2707 }
2708
2709 hc_clFlush (data.ocl, device_param->command_queue);
2710
2711 if (device_param->nvidia_spin_damp)
2712 {
2713 if (data.devices_status == STATUS_RUNNING)
2714 {
2715 if (iteration < EXPECTED_ITERATIONS)
2716 {
2717 switch (kern_run)
2718 {
2719 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2720 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2721 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2722 }
2723 }
2724 }
2725 }
2726
2727 hc_clWaitForEvents (data.ocl, 1, &event);
2728
2729 cl_ulong time_start;
2730 cl_ulong time_end;
2731
2732 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2733 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2734
2735 const double exec_us = (double) (time_end - time_start) / 1000;
2736
2737 if (data.devices_status == STATUS_RUNNING)
2738 {
2739 if (iteration < EXPECTED_ITERATIONS)
2740 {
2741 switch (kern_run)
2742 {
2743 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2744 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2745 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2746 }
2747 }
2748 }
2749
2750 if (event_update)
2751 {
2752 uint exec_pos = device_param->exec_pos;
2753
2754 device_param->exec_ms[exec_pos] = exec_us / 1000;
2755
2756 exec_pos++;
2757
2758 if (exec_pos == EXEC_CACHE)
2759 {
2760 exec_pos = 0;
2761 }
2762
2763 device_param->exec_pos = exec_pos;
2764 }
2765
2766 hc_clReleaseEvent (data.ocl, event);
2767
2768 hc_clFinish (data.ocl, device_param->command_queue);
2769 }
2770
2771 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2772 {
2773 uint num_elements = num;
2774
2775 switch (kern_run)
2776 {
2777 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2778 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2779 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2780 }
2781
2782 // causes problems with special threads like in bcrypt
2783 // const uint kernel_threads = device_param->kernel_threads;
2784
2785 uint kernel_threads = device_param->kernel_threads;
2786
2787 while (num_elements % kernel_threads) num_elements++;
2788
2789 cl_kernel kernel = NULL;
2790
2791 switch (kern_run)
2792 {
2793 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2794 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2795 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2796 }
2797
2798 switch (kern_run)
2799 {
2800 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2801 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2802 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2803 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2804 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2805 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2806 break;
2807 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2808 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2809 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2810 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2811 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2812 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2813 break;
2814 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2815 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2816 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2817 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2818 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2819 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2820 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2821 break;
2822 }
2823
2824 const size_t global_work_size[3] = { num_elements, 1, 1 };
2825 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2826
2827 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2828
2829 hc_clFlush (data.ocl, device_param->command_queue);
2830
2831 hc_clFinish (data.ocl, device_param->command_queue);
2832 }
2833
2834 static void run_kernel_tm (hc_device_param_t *device_param)
2835 {
2836 const uint num_elements = 1024; // fixed
2837
2838 uint kernel_threads = 32;
2839
2840 cl_kernel kernel = device_param->kernel_tm;
2841
2842 const size_t global_work_size[3] = { num_elements, 1, 1 };
2843 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2844
2845 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2846
2847 hc_clFlush (data.ocl, device_param->command_queue);
2848
2849 hc_clFinish (data.ocl, device_param->command_queue);
2850 }
2851
2852 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2853 {
2854 uint num_elements = num;
2855
2856 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2857 device_param->kernel_params_amp_buf32[6] = num_elements;
2858
2859 // causes problems with special threads like in bcrypt
2860 // const uint kernel_threads = device_param->kernel_threads;
2861
2862 uint kernel_threads = device_param->kernel_threads;
2863
2864 while (num_elements % kernel_threads) num_elements++;
2865
2866 cl_kernel kernel = device_param->kernel_amp;
2867
2868 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2869 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2870
2871 const size_t global_work_size[3] = { num_elements, 1, 1 };
2872 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2873
2874 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2875
2876 hc_clFlush (data.ocl, device_param->command_queue);
2877
2878 hc_clFinish (data.ocl, device_param->command_queue);
2879 }
2880
2881 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2882 {
2883 const u32 num16d = num / 16;
2884 const u32 num16m = num % 16;
2885
2886 if (num16d)
2887 {
2888 device_param->kernel_params_memset_buf32[1] = value;
2889 device_param->kernel_params_memset_buf32[2] = num16d;
2890
2891 uint kernel_threads = device_param->kernel_threads;
2892
2893 uint num_elements = num16d;
2894
2895 while (num_elements % kernel_threads) num_elements++;
2896
2897 cl_kernel kernel = device_param->kernel_memset;
2898
2899 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2900 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2901 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2902
2903 const size_t global_work_size[3] = { num_elements, 1, 1 };
2904 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2905
2906 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2907
2908 hc_clFlush (data.ocl, device_param->command_queue);
2909
2910 hc_clFinish (data.ocl, device_param->command_queue);
2911 }
2912
2913 if (num16m)
2914 {
2915 u32 tmp[4];
2916
2917 tmp[0] = value;
2918 tmp[1] = value;
2919 tmp[2] = value;
2920 tmp[3] = value;
2921
2922 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2923 }
2924 }
2925
2926 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2927 {
2928 run_kernel_memset (device_param, buf, 0, size);
2929
2930 /*
2931 int rc = -1;
2932
2933 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2934 {
2935 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2936
2937 const cl_uchar zero = 0;
2938
2939 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2940 }
2941
2942 if (rc != 0)
2943 {
2944 // NOTE: clEnqueueFillBuffer () always fails with -59
2945 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2946 // How's that possible, OpenCL 1.2 support is advertised??
2947 // We need to workaround...
2948
2949 #define FILLSZ 0x100000
2950
2951 char *tmp = (char *) mymalloc (FILLSZ);
2952
2953 for (size_t i = 0; i < size; i += FILLSZ)
2954 {
2955 const size_t left = size - i;
2956
2957 const size_t fillsz = MIN (FILLSZ, left);
2958
2959 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2960 }
2961
2962 myfree (tmp);
2963 }
2964 */
2965 }
2966
2967 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)
2968 {
2969 if (data.hash_mode == 2000)
2970 {
2971 process_stdout (device_param, pws_cnt);
2972
2973 return;
2974 }
2975
2976 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2977 {
2978 if (attack_mode == ATTACK_MODE_BF)
2979 {
2980 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2981 {
2982 const uint size_tm = 32 * sizeof (bs_word_t);
2983
2984 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2985
2986 run_kernel_tm (device_param);
2987
2988 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);
2989 }
2990 }
2991
2992 if (highest_pw_len < 16)
2993 {
2994 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
2995 }
2996 else if (highest_pw_len < 32)
2997 {
2998 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
2999 }
3000 else
3001 {
3002 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3003 }
3004 }
3005 else
3006 {
3007 run_kernel_amp (device_param, pws_cnt);
3008
3009 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3010
3011 if (opts_type & OPTS_TYPE_HOOK12)
3012 {
3013 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3014
3015 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);
3016
3017 // do something with data
3018
3019 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);
3020 }
3021
3022 uint iter = salt_buf->salt_iter;
3023
3024 uint loop_step = device_param->kernel_loops;
3025
3026 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3027 {
3028 uint loop_left = iter - loop_pos;
3029
3030 loop_left = MIN (loop_left, loop_step);
3031
3032 device_param->kernel_params_buf32[28] = loop_pos;
3033 device_param->kernel_params_buf32[29] = loop_left;
3034
3035 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3036
3037 if (data.devices_status == STATUS_CRACKED) break;
3038 if (data.devices_status == STATUS_ABORTED) break;
3039 if (data.devices_status == STATUS_QUIT) break;
3040 if (data.devices_status == STATUS_BYPASS) break;
3041
3042 /**
3043 * speed
3044 */
3045
3046 const float iter_part = (float) (loop_pos + loop_left) / iter;
3047
3048 const u64 perf_sum_all = pws_cnt * iter_part;
3049
3050 double speed_ms;
3051
3052 hc_timer_get (device_param->timer_speed, speed_ms);
3053
3054 const u32 speed_pos = device_param->speed_pos;
3055
3056 device_param->speed_cnt[speed_pos] = perf_sum_all;
3057
3058 device_param->speed_ms[speed_pos] = speed_ms;
3059
3060 if (data.benchmark == 1)
3061 {
3062 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3063 }
3064 }
3065
3066 if (opts_type & OPTS_TYPE_HOOK23)
3067 {
3068 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3069
3070 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);
3071
3072 // do something with data
3073
3074 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);
3075 }
3076
3077 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3078 }
3079 }
3080
3081 static int run_rule_engine (const int rule_len, const char *rule_buf)
3082 {
3083 if (rule_len == 0)
3084 {
3085 return 0;
3086 }
3087 else if (rule_len == 1)
3088 {
3089 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3090 }
3091
3092 return 1;
3093 }
3094
3095 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3096 {
3097 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3098 {
3099 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);
3100 }
3101 else if (data.attack_kern == ATTACK_KERN_COMBI)
3102 {
3103 if (data.attack_mode == ATTACK_MODE_COMBI)
3104 {
3105 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3106 {
3107 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3108 {
3109 for (u32 i = 0; i < pws_cnt; i++)
3110 {
3111 const u32 pw_len = device_param->pws_buf[i].pw_len;
3112
3113 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3114
3115 ptr[pw_len] = 0x01;
3116 }
3117 }
3118 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3119 {
3120 for (u32 i = 0; i < pws_cnt; i++)
3121 {
3122 const u32 pw_len = device_param->pws_buf[i].pw_len;
3123
3124 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3125
3126 ptr[pw_len] = 0x80;
3127 }
3128 }
3129 }
3130 }
3131 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3132 {
3133 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3134 {
3135 for (u32 i = 0; i < pws_cnt; i++)
3136 {
3137 const u32 pw_len = device_param->pws_buf[i].pw_len;
3138
3139 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3140
3141 ptr[pw_len] = 0x01;
3142 }
3143 }
3144 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
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] = 0x80;
3153 }
3154 }
3155 }
3156
3157 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);
3158 }
3159 else if (data.attack_kern == ATTACK_KERN_BF)
3160 {
3161 const u64 off = device_param->words_off;
3162
3163 device_param->kernel_params_mp_l_buf64[3] = off;
3164
3165 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3166 }
3167 }
3168
3169 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3170 {
3171 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3172
3173 device_param->kernel_params_buf32[28] = 0;
3174 device_param->kernel_params_buf32[29] = kernel_loops; // not a bug, both need to be set
3175 device_param->kernel_params_buf32[30] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3176
3177 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3178 {
3179 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3180 }
3181 else
3182 {
3183 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3184 }
3185
3186 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3187
3188 return exec_ms_prev;
3189 }
3190
3191 static void autotune (hc_device_param_t *device_param)
3192 {
3193 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3194
3195 const u32 kernel_accel_min = device_param->kernel_accel_min;
3196 const u32 kernel_accel_max = device_param->kernel_accel_max;
3197
3198 const u32 kernel_loops_min = device_param->kernel_loops_min;
3199 const u32 kernel_loops_max = device_param->kernel_loops_max;
3200
3201 u32 kernel_accel = kernel_accel_min;
3202 u32 kernel_loops = kernel_loops_min;
3203
3204 // in this case the user specified a fixed -u and -n on the commandline
3205 // no way to tune anything
3206 // but we need to run a few caching rounds
3207
3208 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3209 {
3210 if (data.hash_mode != 2000)
3211 {
3212 try_run (device_param, kernel_accel, kernel_loops);
3213 try_run (device_param, kernel_accel, kernel_loops);
3214 try_run (device_param, kernel_accel, kernel_loops);
3215 try_run (device_param, kernel_accel, kernel_loops);
3216 }
3217
3218 device_param->kernel_accel = kernel_accel;
3219 device_param->kernel_loops = kernel_loops;
3220
3221 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3222
3223 device_param->kernel_power = kernel_power;
3224
3225 return;
3226 }
3227
3228 // from here it's clear we are allowed to autotune
3229 // so let's init some fake words
3230
3231 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3232
3233 if (data.attack_kern == ATTACK_KERN_BF)
3234 {
3235 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3236 }
3237 else
3238 {
3239 for (u32 i = 0; i < kernel_power_max; i++)
3240 {
3241 device_param->pws_buf[i].i[0] = i;
3242 device_param->pws_buf[i].i[1] = 0x01234567;
3243 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3244 }
3245
3246 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);
3247 }
3248
3249 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3250 {
3251 if (data.kernel_rules_cnt > 1)
3252 {
3253 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);
3254 }
3255 }
3256 else
3257 {
3258 run_kernel_amp (device_param, kernel_power_max);
3259 }
3260
3261 #define VERIFIER_CNT 1
3262
3263 // first find out highest kernel-loops that stays below target_ms
3264
3265 if (kernel_loops_min < kernel_loops_max)
3266 {
3267 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3268 {
3269 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3270
3271 for (int i = 0; i < VERIFIER_CNT; i++)
3272 {
3273 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3274
3275 exec_ms = MIN (exec_ms, exec_ms_v);
3276 }
3277
3278 if (exec_ms < target_ms) break;
3279 }
3280 }
3281
3282 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3283
3284 #define STEPS_CNT 10
3285
3286 if (kernel_accel_min < kernel_accel_max)
3287 {
3288 for (int i = 0; i < STEPS_CNT; i++)
3289 {
3290 const u32 kernel_accel_try = 1 << i;
3291
3292 if (kernel_accel_try < kernel_accel_min) continue;
3293 if (kernel_accel_try > kernel_accel_max) break;
3294
3295 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3296
3297 for (int i = 0; i < VERIFIER_CNT; i++)
3298 {
3299 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3300
3301 exec_ms = MIN (exec_ms, exec_ms_v);
3302 }
3303
3304 if (exec_ms > target_ms) break;
3305
3306 kernel_accel = kernel_accel_try;
3307 }
3308 }
3309
3310 // at this point we want to know the actual runtime for the following reason:
3311 // we need a reference for the balancing loop following up, and this
3312 // the balancing loop can have an effect that the creates a new opportunity, for example:
3313 // if the target is 95 ms and the current runtime is 48ms the above loop
3314 // stopped the execution because the previous exec_ms was > 95ms
3315 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3316 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3317
3318 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3319
3320 for (int i = 0; i < VERIFIER_CNT; i++)
3321 {
3322 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3323
3324 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3325 }
3326
3327 u32 diff = kernel_loops - kernel_accel;
3328
3329 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3330 {
3331 u32 kernel_accel_orig = kernel_accel;
3332 u32 kernel_loops_orig = kernel_loops;
3333
3334 for (u32 f = 1; f < 1024; f++)
3335 {
3336 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3337 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3338
3339 if (kernel_accel_try > kernel_accel_max) break;
3340 if (kernel_loops_try < kernel_loops_min) break;
3341
3342 u32 diff_new = kernel_loops_try - kernel_accel_try;
3343
3344 if (diff_new > diff) break;
3345
3346 diff_new = diff;
3347
3348 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3349
3350 for (int i = 0; i < VERIFIER_CNT; i++)
3351 {
3352 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3353
3354 exec_ms = MIN (exec_ms, exec_ms_v);
3355 }
3356
3357 if (exec_ms < exec_ms_pre_final)
3358 {
3359 exec_ms_pre_final = exec_ms;
3360
3361 kernel_accel = kernel_accel_try;
3362 kernel_loops = kernel_loops_try;
3363 }
3364 }
3365 }
3366
3367 const double exec_left = target_ms / exec_ms_pre_final;
3368
3369 const double accel_left = kernel_accel_max / kernel_accel;
3370
3371 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3372
3373 if (exec_accel_min >= 1.0)
3374 {
3375 // this is safe to not overflow kernel_accel_max because of accel_left
3376
3377 kernel_accel = (double) kernel_accel * exec_accel_min;
3378 }
3379
3380 // reset them fake words
3381
3382 /*
3383 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3384
3385 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);
3386 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);
3387 */
3388
3389 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3390
3391 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3392 {
3393 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3394 }
3395
3396 // reset timer
3397
3398 device_param->exec_pos = 0;
3399
3400 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3401
3402 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3403 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3404 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3405
3406 // store
3407
3408 device_param->kernel_accel = kernel_accel;
3409 device_param->kernel_loops = kernel_loops;
3410
3411 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3412
3413 device_param->kernel_power = kernel_power;
3414
3415 #ifdef DEBUG
3416
3417 if (data.quiet == 0)
3418 {
3419 clear_prompt ();
3420
3421 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3422 "- Device #%u: autotuned kernel-loops to %u\n",
3423 device_param->device_id + 1, kernel_accel,
3424 device_param->device_id + 1, kernel_loops);
3425
3426 fprintf (stdout, "%s", PROMPT);
3427
3428 fflush (stdout);
3429 }
3430
3431 #endif
3432 }
3433
3434 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3435 {
3436 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3437
3438 // init speed timer
3439
3440 uint speed_pos = device_param->speed_pos;
3441
3442 #ifdef _POSIX
3443 if (device_param->timer_speed.tv_sec == 0)
3444 {
3445 hc_timer_set (&device_param->timer_speed);
3446 }
3447 #endif
3448
3449 #ifdef _WIN
3450 if (device_param->timer_speed.QuadPart == 0)
3451 {
3452 hc_timer_set (&device_param->timer_speed);
3453 }
3454 #endif
3455
3456 // find higest password length, this is for optimization stuff
3457
3458 uint highest_pw_len = 0;
3459
3460 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3461 {
3462 }
3463 else if (data.attack_kern == ATTACK_KERN_COMBI)
3464 {
3465 }
3466 else if (data.attack_kern == ATTACK_KERN_BF)
3467 {
3468 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3469 + device_param->kernel_params_mp_l_buf32[5];
3470 }
3471
3472 // iteration type
3473
3474 uint innerloop_step = 0;
3475 uint innerloop_cnt = 0;
3476
3477 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3478 else innerloop_step = 1;
3479
3480 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3481 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3482 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3483
3484 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3485
3486 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3487 {
3488 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3489
3490 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3491
3492 if (data.devices_status == STATUS_CRACKED) break;
3493 if (data.devices_status == STATUS_ABORTED) break;
3494 if (data.devices_status == STATUS_QUIT) break;
3495 if (data.devices_status == STATUS_BYPASS) break;
3496
3497 salt_t *salt_buf = &data.salts_buf[salt_pos];
3498
3499 device_param->kernel_params_buf32[27] = salt_pos;
3500 device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
3501 device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
3502
3503 FILE *combs_fp = device_param->combs_fp;
3504
3505 if (data.attack_mode == ATTACK_MODE_COMBI)
3506 {
3507 rewind (combs_fp);
3508 }
3509
3510 // innerloops
3511
3512 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3513 {
3514 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3515
3516 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3517
3518 if (data.devices_status == STATUS_CRACKED) break;
3519 if (data.devices_status == STATUS_ABORTED) break;
3520 if (data.devices_status == STATUS_QUIT) break;
3521 if (data.devices_status == STATUS_BYPASS) break;
3522
3523 uint fast_iteration = 0;
3524
3525 uint innerloop_left = innerloop_cnt - innerloop_pos;
3526
3527 if (innerloop_left > innerloop_step)
3528 {
3529 innerloop_left = innerloop_step;
3530
3531 fast_iteration = 1;
3532 }
3533
3534 device_param->innerloop_pos = innerloop_pos;
3535 device_param->innerloop_left = innerloop_left;
3536
3537 device_param->kernel_params_buf32[30] = innerloop_left;
3538
3539 // i think we can get rid of this
3540 if (innerloop_left == 0)
3541 {
3542 puts ("bug, how should this happen????\n");
3543
3544 continue;
3545 }
3546
3547 if (data.salts_shown[salt_pos] == 1)
3548 {
3549 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3550
3551 continue;
3552 }
3553
3554 // initialize amplifiers
3555
3556 if (data.attack_mode == ATTACK_MODE_COMBI)
3557 {
3558 uint i = 0;
3559
3560 while (i < innerloop_left)
3561 {
3562 if (feof (combs_fp)) break;
3563
3564 int line_len = fgetl (combs_fp, line_buf);
3565
3566 if (line_len >= PW_MAX1) continue;
3567
3568 line_len = convert_from_hex (line_buf, line_len);
3569
3570 char *line_buf_new = line_buf;
3571
3572 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3573 {
3574 char rule_buf_out[BLOCK_SIZE] = { 0 };
3575
3576 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3577
3578 if (rule_len_out < 0)
3579 {
3580 data.words_progress_rejected[salt_pos] += pws_cnt;
3581
3582 continue;
3583 }
3584
3585 line_len = rule_len_out;
3586
3587 line_buf_new = rule_buf_out;
3588 }
3589
3590 line_len = MIN (line_len, PW_DICTMAX);
3591
3592 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3593
3594 memcpy (ptr, line_buf_new, line_len);
3595
3596 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3597
3598 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3599 {
3600 uppercase (ptr, line_len);
3601 }
3602
3603 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3604 {
3605 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3606 {
3607 ptr[line_len] = 0x80;
3608 }
3609
3610 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3611 {
3612 ptr[line_len] = 0x01;
3613 }
3614 }
3615
3616 device_param->combs_buf[i].pw_len = line_len;
3617
3618 i++;
3619 }
3620
3621 for (uint j = i; j < innerloop_left; j++)
3622 {
3623 device_param->combs_buf[j].i[0] = 0;
3624 device_param->combs_buf[j].i[1] = 0;
3625 device_param->combs_buf[j].i[2] = 0;
3626 device_param->combs_buf[j].i[3] = 0;
3627 device_param->combs_buf[j].i[4] = 0;
3628 device_param->combs_buf[j].i[5] = 0;
3629 device_param->combs_buf[j].i[6] = 0;
3630 device_param->combs_buf[j].i[7] = 0;
3631
3632 device_param->combs_buf[j].pw_len = 0;
3633 }
3634
3635 innerloop_left = i;
3636 }
3637 else if (data.attack_mode == ATTACK_MODE_BF)
3638 {
3639 u64 off = innerloop_pos;
3640
3641 device_param->kernel_params_mp_r_buf64[3] = off;
3642
3643 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3644 }
3645 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3646 {
3647 u64 off = innerloop_pos;
3648
3649 device_param->kernel_params_mp_buf64[3] = off;
3650
3651 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3652 }
3653 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3654 {
3655 u64 off = innerloop_pos;
3656
3657 device_param->kernel_params_mp_buf64[3] = off;
3658
3659 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3660 }
3661
3662 // copy amplifiers
3663
3664 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3665 {
3666 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);
3667 }
3668 else if (data.attack_mode == ATTACK_MODE_COMBI)
3669 {
3670 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);
3671 }
3672 else if (data.attack_mode == ATTACK_MODE_BF)
3673 {
3674 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);
3675 }
3676 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3677 {
3678 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);
3679 }
3680 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3681 {
3682 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);
3683 }
3684
3685 if (data.benchmark == 1)
3686 {
3687 hc_timer_set (&device_param->timer_speed);
3688 }
3689
3690 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3691
3692 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3693
3694 if (data.devices_status == STATUS_CRACKED) break;
3695 if (data.devices_status == STATUS_ABORTED) break;
3696 if (data.devices_status == STATUS_QUIT) break;
3697 if (data.devices_status == STATUS_BYPASS) break;
3698
3699 /**
3700 * result
3701 */
3702
3703 if (data.benchmark == 0)
3704 {
3705 check_cracked (device_param, salt_pos);
3706 }
3707
3708 /**
3709 * progress
3710 */
3711
3712 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3713
3714 hc_thread_mutex_lock (mux_counter);
3715
3716 data.words_progress_done[salt_pos] += perf_sum_all;
3717
3718 hc_thread_mutex_unlock (mux_counter);
3719
3720 /**
3721 * speed
3722 */
3723
3724 double speed_ms;
3725
3726 hc_timer_get (device_param->timer_speed, speed_ms);
3727
3728 hc_timer_set (&device_param->timer_speed);
3729
3730 // current speed
3731
3732 //hc_thread_mutex_lock (mux_display);
3733
3734 device_param->speed_cnt[speed_pos] = perf_sum_all;
3735
3736 device_param->speed_ms[speed_pos] = speed_ms;
3737
3738 //hc_thread_mutex_unlock (mux_display);
3739
3740 speed_pos++;
3741
3742 if (speed_pos == SPEED_CACHE)
3743 {
3744 speed_pos = 0;
3745 }
3746
3747 /**
3748 * benchmark
3749 */
3750
3751 if (data.benchmark == 1) break;
3752 }
3753 }
3754
3755 device_param->speed_pos = speed_pos;
3756
3757 myfree (line_buf);
3758 }
3759
3760 static void load_segment (wl_data_t *wl_data, FILE *fd)
3761 {
3762 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3763
3764 wl_data->pos = 0;
3765
3766 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3767
3768 wl_data->buf[wl_data->cnt] = 0;
3769
3770 if (wl_data->cnt == 0) return;
3771
3772 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3773
3774 while (!feof (fd))
3775 {
3776 if (wl_data->cnt == wl_data->avail)
3777 {
3778 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3779
3780 wl_data->avail += wl_data->incr;
3781 }
3782
3783 const int c = fgetc (fd);
3784
3785 if (c == EOF) break;
3786
3787 wl_data->buf[wl_data->cnt] = (char) c;
3788
3789 wl_data->cnt++;
3790
3791 if (c == '\n') break;
3792 }
3793
3794 // ensure stream ends with a newline
3795
3796 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3797 {
3798 wl_data->cnt++;
3799
3800 wl_data->buf[wl_data->cnt - 1] = '\n';
3801 }
3802
3803 return;
3804 }
3805
3806 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3807 {
3808 char *ptr = buf;
3809
3810 for (u32 i = 0; i < sz; i++, ptr++)
3811 {
3812 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3813
3814 if (i == 7)
3815 {
3816 *off = i;
3817 *len = i;
3818
3819 return;
3820 }
3821
3822 if (*ptr != '\n') continue;
3823
3824 *off = i + 1;
3825
3826 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3827
3828 *len = i;
3829
3830 return;
3831 }
3832
3833 *off = sz;
3834 *len = sz;
3835 }
3836
3837 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3838 {
3839 char *ptr = buf;
3840
3841 for (u32 i = 0; i < sz; i++, ptr++)
3842 {
3843 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3844
3845 if (*ptr != '\n') continue;
3846
3847 *off = i + 1;
3848
3849 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3850
3851 *len = i;
3852
3853 return;
3854 }
3855
3856 *off = sz;
3857 *len = sz;
3858 }
3859
3860 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3861 {
3862 char *ptr = buf;
3863
3864 for (u32 i = 0; i < sz; i++, ptr++)
3865 {
3866 if (*ptr != '\n') continue;
3867
3868 *off = i + 1;
3869
3870 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3871
3872 *len = i;
3873
3874 return;
3875 }
3876
3877 *off = sz;
3878 *len = sz;
3879 }
3880
3881 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3882 {
3883 while (wl_data->pos < wl_data->cnt)
3884 {
3885 uint off;
3886 uint len;
3887
3888 char *ptr = wl_data->buf + wl_data->pos;
3889
3890 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3891
3892 wl_data->pos += off;
3893
3894 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3895 {
3896 char rule_buf_out[BLOCK_SIZE] = { 0 };
3897
3898 int rule_len_out = -1;
3899
3900 if (len < BLOCK_SIZE)
3901 {
3902 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3903 }
3904
3905 if (rule_len_out < 0)
3906 {
3907 continue;
3908 }
3909
3910 if (rule_len_out > PW_MAX)
3911 {
3912 continue;
3913 }
3914 }
3915 else
3916 {
3917 if (len > PW_MAX)
3918 {
3919 continue;
3920 }
3921 }
3922
3923 *out_buf = ptr;
3924 *out_len = len;
3925
3926 return;
3927 }
3928
3929 if (feof (fd))
3930 {
3931 fprintf (stderr, "BUG feof()!!\n");
3932
3933 return;
3934 }
3935
3936 load_segment (wl_data, fd);
3937
3938 get_next_word (wl_data, fd, out_buf, out_len);
3939 }
3940
3941 #ifdef _POSIX
3942 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3943 #endif
3944
3945 #ifdef _WIN
3946 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3947 #endif
3948 {
3949 hc_signal (NULL);
3950
3951 dictstat_t d;
3952
3953 d.cnt = 0;
3954
3955 #ifdef _POSIX
3956 fstat (fileno (fd), &d.stat);
3957 #endif
3958
3959 #ifdef _WIN
3960 _fstat64 (fileno (fd), &d.stat);
3961 #endif
3962
3963 d.stat.st_mode = 0;
3964 d.stat.st_nlink = 0;
3965 d.stat.st_uid = 0;
3966 d.stat.st_gid = 0;
3967 d.stat.st_rdev = 0;
3968 d.stat.st_atime = 0;
3969
3970 #ifdef _POSIX
3971 d.stat.st_blksize = 0;
3972 d.stat.st_blocks = 0;
3973 #endif
3974
3975 if (d.stat.st_size == 0) return 0;
3976
3977 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3978
3979 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3980 {
3981 if (d_cache)
3982 {
3983 u64 cnt = d_cache->cnt;
3984
3985 u64 keyspace = cnt;
3986
3987 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3988 {
3989 keyspace *= data.kernel_rules_cnt;
3990 }
3991 else if (data.attack_kern == ATTACK_KERN_COMBI)
3992 {
3993 keyspace *= data.combs_cnt;
3994 }
3995
3996 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);
3997 if (data.quiet == 0) log_info ("");
3998
3999 hc_signal (sigHandler_default);
4000
4001 return (keyspace);
4002 }
4003 }
4004
4005 time_t now = 0;
4006 time_t prev = 0;
4007
4008 u64 comp = 0;
4009 u64 cnt = 0;
4010 u64 cnt2 = 0;
4011
4012 while (!feof (fd))
4013 {
4014 load_segment (wl_data, fd);
4015
4016 comp += wl_data->cnt;
4017
4018 u32 i = 0;
4019
4020 while (i < wl_data->cnt)
4021 {
4022 u32 len;
4023 u32 off;
4024
4025 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4026
4027 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4028 {
4029 char rule_buf_out[BLOCK_SIZE] = { 0 };
4030
4031 int rule_len_out = -1;
4032
4033 if (len < BLOCK_SIZE)
4034 {
4035 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4036 }
4037
4038 if (rule_len_out < 0)
4039 {
4040 len = PW_MAX1;
4041 }
4042 else
4043 {
4044 len = rule_len_out;
4045 }
4046 }
4047
4048 if (len < PW_MAX1)
4049 {
4050 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4051 {
4052 cnt += data.kernel_rules_cnt;
4053 }
4054 else if (data.attack_kern == ATTACK_KERN_COMBI)
4055 {
4056 cnt += data.combs_cnt;
4057 }
4058
4059 d.cnt++;
4060 }
4061
4062 i += off;
4063
4064 cnt2++;
4065 }
4066
4067 time (&now);
4068
4069 if ((now - prev) == 0) continue;
4070
4071 float percent = (float) comp / (float) d.stat.st_size;
4072
4073 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);
4074
4075 time (&prev);
4076 }
4077
4078 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);
4079 if (data.quiet == 0) log_info ("");
4080
4081 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4082
4083 hc_signal (sigHandler_default);
4084
4085 return (cnt);
4086 }
4087
4088 static void *thread_monitor (void *p)
4089 {
4090 uint runtime_check = 0;
4091 uint remove_check = 0;
4092 uint status_check = 0;
4093 uint restore_check = 0;
4094
4095 uint restore_left = data.restore_timer;
4096 uint remove_left = data.remove_timer;
4097 uint status_left = data.status_timer;
4098
4099 #ifdef HAVE_HWMON
4100 uint hwmon_check = 0;
4101
4102 int slowdown_warnings = 0;
4103
4104 // these variables are mainly used for fan control
4105
4106 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4107
4108 // temperature controller "loopback" values
4109
4110 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4111 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4112
4113 int temp_threshold = 1; // degrees celcius
4114
4115 int fan_speed_min = 15; // in percentage
4116 int fan_speed_max = 100;
4117
4118 time_t last_temp_check_time;
4119 #endif // HAVE_HWMON
4120
4121 uint sleep_time = 1;
4122
4123 if (data.runtime)
4124 {
4125 runtime_check = 1;
4126 }
4127
4128 if (data.restore_timer)
4129 {
4130 restore_check = 1;
4131 }
4132
4133 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4134 {
4135 remove_check = 1;
4136 }
4137
4138 if (data.status == 1)
4139 {
4140 status_check = 1;
4141 }
4142
4143 #ifdef HAVE_HWMON
4144 if (data.gpu_temp_disable == 0)
4145 {
4146 time (&last_temp_check_time);
4147
4148 hwmon_check = 1;
4149 }
4150 #endif
4151
4152 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4153 {
4154 #ifdef HAVE_HWMON
4155 if (hwmon_check == 0)
4156 #endif
4157 return (p);
4158 }
4159
4160 while (data.shutdown_inner == 0)
4161 {
4162 hc_sleep (sleep_time);
4163
4164 if (data.devices_status != STATUS_RUNNING) continue;
4165
4166 #ifdef HAVE_HWMON
4167
4168 if (hwmon_check == 1)
4169 {
4170 hc_thread_mutex_lock (mux_adl);
4171
4172 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4173 {
4174 hc_device_param_t *device_param = &data.devices_param[device_id];
4175
4176 if (device_param->skipped) continue;
4177
4178 if (device_param->device_vendor_id == VENDOR_ID_NV)
4179 {
4180 if (data.hm_nvapi)
4181 {
4182 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4183 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4184
4185 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4186 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4187
4188 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4189
4190 perfPolicies_status.info_value = perfPolicies_info.info_value;
4191
4192 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4193
4194 if (perfPolicies_status.throttle & 2)
4195 {
4196 if (slowdown_warnings < 3)
4197 {
4198 if (data.quiet == 0) clear_prompt ();
4199
4200 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4201
4202 if (slowdown_warnings == 2)
4203 {
4204 log_info ("");
4205 }
4206
4207 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4208 if (data.quiet == 0) fflush (stdout);
4209
4210 slowdown_warnings++;
4211 }
4212 }
4213 else
4214 {
4215 slowdown_warnings = 0;
4216 }
4217 }
4218 }
4219 }
4220
4221 hc_thread_mutex_unlock (mux_adl);
4222 }
4223
4224 if (hwmon_check == 1)
4225 {
4226 hc_thread_mutex_lock (mux_adl);
4227
4228 time_t temp_check_time;
4229
4230 time (&temp_check_time);
4231
4232 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4233
4234 if (Ta == 0) Ta = 1;
4235
4236 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4237 {
4238 hc_device_param_t *device_param = &data.devices_param[device_id];
4239
4240 if (device_param->skipped) continue;
4241
4242 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4243
4244 const int temperature = hm_get_temperature_with_device_id (device_id);
4245
4246 if (temperature > (int) data.gpu_temp_abort)
4247 {
4248 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4249
4250 if (data.devices_status != STATUS_QUIT) myabort ();
4251
4252 break;
4253 }
4254
4255 const int gpu_temp_retain = data.gpu_temp_retain;
4256
4257 if (gpu_temp_retain)
4258 {
4259 if (data.hm_device[device_id].fan_set_supported == 1)
4260 {
4261 int temp_cur = temperature;
4262
4263 int temp_diff_new = gpu_temp_retain - temp_cur;
4264
4265 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4266
4267 // calculate Ta value (time difference in seconds between the last check and this check)
4268
4269 last_temp_check_time = temp_check_time;
4270
4271 float Kp = 1.8;
4272 float Ki = 0.005;
4273 float Kd = 6;
4274
4275 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4276
4277 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);
4278
4279 if (abs (fan_diff_required) >= temp_threshold)
4280 {
4281 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4282
4283 int fan_speed_level = fan_speed_cur;
4284
4285 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4286
4287 int fan_speed_new = fan_speed_level - fan_diff_required;
4288
4289 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4290 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4291
4292 if (fan_speed_new != fan_speed_cur)
4293 {
4294 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4295 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4296
4297 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4298 {
4299 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4300 {
4301 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4302 }
4303 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4304 {
4305 #ifdef WIN
4306 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4307 #endif
4308
4309 #ifdef LINUX
4310 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4311 #endif
4312 }
4313
4314 fan_speed_chgd[device_id] = 1;
4315 }
4316
4317 temp_diff_old[device_id] = temp_diff_new;
4318 }
4319 }
4320 }
4321 }
4322 }
4323
4324 hc_thread_mutex_unlock (mux_adl);
4325 }
4326 #endif // HAVE_HWMON
4327
4328 if (restore_check == 1)
4329 {
4330 restore_left--;
4331
4332 if (restore_left == 0)
4333 {
4334 if (data.restore_disable == 0) cycle_restore ();
4335
4336 restore_left = data.restore_timer;
4337 }
4338 }
4339
4340 if ((runtime_check == 1) && (data.runtime_start > 0))
4341 {
4342 time_t runtime_cur;
4343
4344 time (&runtime_cur);
4345
4346 int runtime_left = data.proc_start + data.runtime - runtime_cur;
4347
4348 if (runtime_left <= 0)
4349 {
4350 if (data.benchmark == 0)
4351 {
4352 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4353 }
4354
4355 if (data.devices_status != STATUS_QUIT) myabort ();
4356 }
4357 }
4358
4359 if (remove_check == 1)
4360 {
4361 remove_left--;
4362
4363 if (remove_left == 0)
4364 {
4365 if (data.digests_saved != data.digests_done)
4366 {
4367 data.digests_saved = data.digests_done;
4368
4369 save_hash ();
4370 }
4371
4372 remove_left = data.remove_timer;
4373 }
4374 }
4375
4376 if (status_check == 1)
4377 {
4378 status_left--;
4379
4380 if (status_left == 0)
4381 {
4382 hc_thread_mutex_lock (mux_display);
4383
4384 if (data.quiet == 0) clear_prompt ();
4385
4386 if (data.quiet == 0) log_info ("");
4387
4388 status_display ();
4389
4390 if (data.quiet == 0) log_info ("");
4391
4392 hc_thread_mutex_unlock (mux_display);
4393
4394 status_left = data.status_timer;
4395 }
4396 }
4397 }
4398
4399 #ifdef HAVE_HWMON
4400 myfree (fan_speed_chgd);
4401
4402 myfree (temp_diff_old);
4403 myfree (temp_diff_sum);
4404 #endif
4405
4406 p = NULL;
4407
4408 return (p);
4409 }
4410
4411 static void *thread_outfile_remove (void *p)
4412 {
4413 // some hash-dependent constants
4414 char *outfile_dir = data.outfile_check_directory;
4415 uint dgst_size = data.dgst_size;
4416 uint isSalted = data.isSalted;
4417 uint esalt_size = data.esalt_size;
4418 uint hash_mode = data.hash_mode;
4419
4420 uint outfile_check_timer = data.outfile_check_timer;
4421
4422 char separator = data.separator;
4423
4424 // some hash-dependent functions
4425 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4426 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4427
4428 // buffers
4429 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4430
4431 hash_buf.digest = mymalloc (dgst_size);
4432
4433 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4434
4435 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4436
4437 uint digest_buf[64] = { 0 };
4438
4439 outfile_data_t *out_info = NULL;
4440
4441 char **out_files = NULL;
4442
4443 time_t folder_mtime = 0;
4444
4445 int out_cnt = 0;
4446
4447 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4448
4449 while (data.shutdown_inner == 0)
4450 {
4451 hc_sleep (1);
4452
4453 if (data.devices_status != STATUS_RUNNING) continue;
4454
4455 check_left--;
4456
4457 if (check_left == 0)
4458 {
4459 struct stat outfile_check_stat;
4460
4461 if (stat (outfile_dir, &outfile_check_stat) == 0)
4462 {
4463 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4464
4465 if (is_dir == 1)
4466 {
4467 if (outfile_check_stat.st_mtime > folder_mtime)
4468 {
4469 char **out_files_new = scan_directory (outfile_dir);
4470
4471 int out_cnt_new = count_dictionaries (out_files_new);
4472
4473 outfile_data_t *out_info_new = NULL;
4474
4475 if (out_cnt_new > 0)
4476 {
4477 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4478
4479 for (int i = 0; i < out_cnt_new; i++)
4480 {
4481 out_info_new[i].file_name = out_files_new[i];
4482
4483 // check if there are files that we have seen/checked before (and not changed)
4484
4485 for (int j = 0; j < out_cnt; j++)
4486 {
4487 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4488 {
4489 struct stat outfile_stat;
4490
4491 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4492 {
4493 if (outfile_stat.st_ctime == out_info[j].ctime)
4494 {
4495 out_info_new[i].ctime = out_info[j].ctime;
4496 out_info_new[i].seek = out_info[j].seek;
4497 }
4498 }
4499 }
4500 }
4501 }
4502 }
4503
4504 local_free (out_info);
4505 local_free (out_files);
4506
4507 out_files = out_files_new;
4508 out_cnt = out_cnt_new;
4509 out_info = out_info_new;
4510
4511 folder_mtime = outfile_check_stat.st_mtime;
4512 }
4513
4514 for (int j = 0; j < out_cnt; j++)
4515 {
4516 FILE *fp = fopen (out_info[j].file_name, "rb");
4517
4518 if (fp != NULL)
4519 {
4520 //hc_thread_mutex_lock (mux_display);
4521
4522 #ifdef _POSIX
4523 struct stat outfile_stat;
4524
4525 fstat (fileno (fp), &outfile_stat);
4526 #endif
4527
4528 #ifdef _WIN
4529 struct stat64 outfile_stat;
4530
4531 _fstat64 (fileno (fp), &outfile_stat);
4532 #endif
4533
4534 if (outfile_stat.st_ctime > out_info[j].ctime)
4535 {
4536 out_info[j].ctime = outfile_stat.st_ctime;
4537 out_info[j].seek = 0;
4538 }
4539
4540 fseek (fp, out_info[j].seek, SEEK_SET);
4541
4542 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4543
4544 while (!feof (fp))
4545 {
4546 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4547
4548 if (ptr == NULL) break;
4549
4550 int line_len = strlen (line_buf);
4551
4552 if (line_len <= 0) continue;
4553
4554 int iter = MAX_CUT_TRIES;
4555
4556 for (uint i = line_len - 1; i && iter; i--, line_len--)
4557 {
4558 if (line_buf[i] != separator) continue;
4559
4560 int parser_status = PARSER_OK;
4561
4562 if ((hash_mode != 2500) && (hash_mode != 6800))
4563 {
4564 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4565 }
4566
4567 uint found = 0;
4568
4569 if (parser_status == PARSER_OK)
4570 {
4571 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4572 {
4573 if (data.salts_shown[salt_pos] == 1) continue;
4574
4575 salt_t *salt_buf = &data.salts_buf[salt_pos];
4576
4577 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4578 {
4579 uint idx = salt_buf->digests_offset + digest_pos;
4580
4581 if (data.digests_shown[idx] == 1) continue;
4582
4583 uint cracked = 0;
4584
4585 if (hash_mode == 6800)
4586 {
4587 if (i == salt_buf->salt_len)
4588 {
4589 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4590 }
4591 }
4592 else if (hash_mode == 2500)
4593 {
4594 // BSSID : MAC1 : MAC2 (:plain)
4595 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4596 {
4597 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4598
4599 if (!cracked) continue;
4600
4601 // now compare MAC1 and MAC2 too, since we have this additional info
4602 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4603 char *mac2_pos = mac1_pos + 12 + 1;
4604
4605 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4606 wpa_t *wpa = &wpas[salt_pos];
4607
4608 // compare hex string(s) vs binary MAC address(es)
4609
4610 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4611 {
4612 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4613 {
4614 cracked = 0;
4615
4616 break;
4617 }
4618 }
4619
4620 // early skip ;)
4621 if (!cracked) continue;
4622
4623 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4624 {
4625 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4626 {
4627 cracked = 0;
4628
4629 break;
4630 }
4631 }
4632 }
4633 }
4634 else
4635 {
4636 char *digests_buf_ptr = (char *) data.digests_buf;
4637
4638 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4639
4640 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4641 }
4642
4643 if (cracked == 1)
4644 {
4645 found = 1;
4646
4647 data.digests_shown[idx] = 1;
4648
4649 data.digests_done++;
4650
4651 salt_buf->digests_done++;
4652
4653 if (salt_buf->digests_done == salt_buf->digests_cnt)
4654 {
4655 data.salts_shown[salt_pos] = 1;
4656
4657 data.salts_done++;
4658
4659 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4660 }
4661 }
4662 }
4663
4664 if (data.devices_status == STATUS_CRACKED) break;
4665 }
4666 }
4667
4668 if (found) break;
4669
4670 if (data.devices_status == STATUS_CRACKED) break;
4671
4672 iter--;
4673 }
4674
4675 if (data.devices_status == STATUS_CRACKED) break;
4676 }
4677
4678 myfree (line_buf);
4679
4680 out_info[j].seek = ftell (fp);
4681
4682 //hc_thread_mutex_unlock (mux_display);
4683
4684 fclose (fp);
4685 }
4686 }
4687 }
4688 }
4689
4690 check_left = outfile_check_timer;
4691 }
4692 }
4693
4694 if (esalt_size) local_free (hash_buf.esalt);
4695
4696 if (isSalted) local_free (hash_buf.salt);
4697
4698 local_free (hash_buf.digest);
4699
4700 local_free (out_info);
4701
4702 local_free (out_files);
4703
4704 p = NULL;
4705
4706 return (p);
4707 }
4708
4709 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4710 {
4711 //if (device_param->pws_cnt < device_param->kernel_power)
4712 //{
4713 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4714
4715 u8 *ptr = (u8 *) pw->i;
4716
4717 memcpy (ptr, pw_buf, pw_len);
4718
4719 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4720
4721 pw->pw_len = pw_len;
4722
4723 device_param->pws_cnt++;
4724 //}
4725 //else
4726 //{
4727 // fprintf (stderr, "BUG pw_add()!!\n");
4728 //
4729 // return;
4730 //}
4731 }
4732
4733 static void set_kernel_power_final (const u64 kernel_power_final)
4734 {
4735 if (data.quiet == 0)
4736 {
4737 clear_prompt ();
4738
4739 //log_info ("");
4740
4741 log_info ("INFO: approaching final keyspace, workload adjusted");
4742 log_info ("");
4743
4744 fprintf (stdout, "%s", PROMPT);
4745
4746 fflush (stdout);
4747 }
4748
4749 data.kernel_power_final = kernel_power_final;
4750 }
4751
4752 static u32 get_power (hc_device_param_t *device_param)
4753 {
4754 const u64 kernel_power_final = data.kernel_power_final;
4755
4756 if (kernel_power_final)
4757 {
4758 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4759
4760 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4761
4762 // work should be at least the hardware power available without any accelerator
4763
4764 const u64 work = MAX (words_left_device, device_param->hardware_power);
4765
4766 return work;
4767 }
4768
4769 return device_param->kernel_power;
4770 }
4771
4772 static uint get_work (hc_device_param_t *device_param, const u64 max)
4773 {
4774 hc_thread_mutex_lock (mux_dispatcher);
4775
4776 const u64 words_cur = data.words_cur;
4777 const u64 words_base = (data.limit == 0) ? data.words_base : MIN (data.limit, data.words_base);
4778
4779 device_param->words_off = words_cur;
4780
4781 const u64 kernel_power_all = data.kernel_power_all;
4782
4783 const u64 words_left = words_base - words_cur;
4784
4785 if (words_left < kernel_power_all)
4786 {
4787 if (data.kernel_power_final == 0)
4788 {
4789 set_kernel_power_final (words_left);
4790 }
4791 }
4792
4793 const u32 kernel_power = get_power (device_param);
4794
4795 uint work = MIN (words_left, kernel_power);
4796
4797 work = MIN (work, max);
4798
4799 data.words_cur += work;
4800
4801 hc_thread_mutex_unlock (mux_dispatcher);
4802
4803 return work;
4804 }
4805
4806 static void *thread_autotune (void *p)
4807 {
4808 hc_device_param_t *device_param = (hc_device_param_t *) p;
4809
4810 if (device_param->skipped) return NULL;
4811
4812 autotune (device_param);
4813
4814 return NULL;
4815 }
4816
4817 static void *thread_calc_stdin (void *p)
4818 {
4819 hc_device_param_t *device_param = (hc_device_param_t *) p;
4820
4821 if (device_param->skipped) return NULL;
4822
4823 char *buf = (char *) mymalloc (HCBUFSIZ);
4824
4825 const uint attack_kern = data.attack_kern;
4826
4827 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4828 {
4829 hc_thread_mutex_lock (mux_dispatcher);
4830
4831 if (feof (stdin) != 0)
4832 {
4833 hc_thread_mutex_unlock (mux_dispatcher);
4834
4835 break;
4836 }
4837
4838 uint words_cur = 0;
4839
4840 while (words_cur < device_param->kernel_power)
4841 {
4842 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4843
4844 if (line_buf == NULL) break;
4845
4846 uint line_len = in_superchop (line_buf);
4847
4848 line_len = convert_from_hex (line_buf, line_len);
4849
4850 // post-process rule engine
4851
4852 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4853 {
4854 char rule_buf_out[BLOCK_SIZE] = { 0 };
4855
4856 int rule_len_out = -1;
4857
4858 if (line_len < BLOCK_SIZE)
4859 {
4860 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4861 }
4862
4863 if (rule_len_out < 0) continue;
4864
4865 line_buf = rule_buf_out;
4866 line_len = rule_len_out;
4867 }
4868
4869 if (line_len > PW_MAX)
4870 {
4871 continue;
4872 }
4873
4874 // hmm that's always the case, or?
4875
4876 if (attack_kern == ATTACK_KERN_STRAIGHT)
4877 {
4878 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4879 {
4880 hc_thread_mutex_lock (mux_counter);
4881
4882 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4883 {
4884 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4885 }
4886
4887 hc_thread_mutex_unlock (mux_counter);
4888
4889 continue;
4890 }
4891 }
4892
4893 pw_add (device_param, (u8 *) line_buf, line_len);
4894
4895 words_cur++;
4896
4897 if (data.devices_status == STATUS_CRACKED) break;
4898 if (data.devices_status == STATUS_ABORTED) break;
4899 if (data.devices_status == STATUS_QUIT) break;
4900 if (data.devices_status == STATUS_BYPASS) break;
4901 }
4902
4903 hc_thread_mutex_unlock (mux_dispatcher);
4904
4905 if (data.devices_status == STATUS_CRACKED) break;
4906 if (data.devices_status == STATUS_ABORTED) break;
4907 if (data.devices_status == STATUS_QUIT) break;
4908 if (data.devices_status == STATUS_BYPASS) break;
4909
4910 // flush
4911
4912 const uint pws_cnt = device_param->pws_cnt;
4913
4914 if (pws_cnt)
4915 {
4916 run_copy (device_param, pws_cnt);
4917
4918 run_cracker (device_param, pws_cnt);
4919
4920 device_param->pws_cnt = 0;
4921
4922 /*
4923 still required?
4924 if (attack_kern == ATTACK_KERN_STRAIGHT)
4925 {
4926 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4927 }
4928 else if (attack_kern == ATTACK_KERN_COMBI)
4929 {
4930 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4931 }
4932 */
4933 }
4934 }
4935
4936 device_param->kernel_accel = 0;
4937 device_param->kernel_loops = 0;
4938
4939 myfree (buf);
4940
4941 return NULL;
4942 }
4943
4944 static void *thread_calc (void *p)
4945 {
4946 hc_device_param_t *device_param = (hc_device_param_t *) p;
4947
4948 if (device_param->skipped) return NULL;
4949
4950 const uint attack_mode = data.attack_mode;
4951 const uint attack_kern = data.attack_kern;
4952
4953 if (attack_mode == ATTACK_MODE_BF)
4954 {
4955 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4956 {
4957 const uint work = get_work (device_param, -1);
4958
4959 if (work == 0) break;
4960
4961 const u64 words_off = device_param->words_off;
4962 const u64 words_fin = words_off + work;
4963
4964 const uint pws_cnt = work;
4965
4966 device_param->pws_cnt = pws_cnt;
4967
4968 if (pws_cnt)
4969 {
4970 run_copy (device_param, pws_cnt);
4971
4972 run_cracker (device_param, pws_cnt);
4973
4974 device_param->pws_cnt = 0;
4975
4976 /*
4977 still required?
4978 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4979 */
4980 }
4981
4982 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4983
4984 if (data.devices_status == STATUS_CRACKED) break;
4985 if (data.devices_status == STATUS_ABORTED) break;
4986 if (data.devices_status == STATUS_QUIT) break;
4987 if (data.devices_status == STATUS_BYPASS) break;
4988
4989 if (data.benchmark == 1) break;
4990
4991 device_param->words_done = words_fin;
4992 }
4993 }
4994 else
4995 {
4996 const uint segment_size = data.segment_size;
4997
4998 char *dictfile = data.dictfile;
4999
5000 if (attack_mode == ATTACK_MODE_COMBI)
5001 {
5002 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5003 {
5004 dictfile = data.dictfile2;
5005 }
5006 }
5007
5008 FILE *fd = fopen (dictfile, "rb");
5009
5010 if (fd == NULL)
5011 {
5012 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5013
5014 return NULL;
5015 }
5016
5017 if (attack_mode == ATTACK_MODE_COMBI)
5018 {
5019 const uint combs_mode = data.combs_mode;
5020
5021 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5022 {
5023 const char *dictfilec = data.dictfile2;
5024
5025 FILE *combs_fp = fopen (dictfilec, "rb");
5026
5027 if (combs_fp == NULL)
5028 {
5029 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5030
5031 fclose (fd);
5032
5033 return NULL;
5034 }
5035
5036 device_param->combs_fp = combs_fp;
5037 }
5038 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5039 {
5040 const char *dictfilec = data.dictfile;
5041
5042 FILE *combs_fp = fopen (dictfilec, "rb");
5043
5044 if (combs_fp == NULL)
5045 {
5046 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5047
5048 fclose (fd);
5049
5050 return NULL;
5051 }
5052
5053 device_param->combs_fp = combs_fp;
5054 }
5055 }
5056
5057 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5058
5059 wl_data->buf = (char *) mymalloc (segment_size);
5060 wl_data->avail = segment_size;
5061 wl_data->incr = segment_size;
5062 wl_data->cnt = 0;
5063 wl_data->pos = 0;
5064
5065 u64 words_cur = 0;
5066
5067 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5068 {
5069 u64 words_off = 0;
5070 u64 words_fin = 0;
5071
5072 u64 max = -1;
5073
5074 while (max)
5075 {
5076 const uint work = get_work (device_param, max);
5077
5078 if (work == 0) break;
5079
5080 max = 0;
5081
5082 words_off = device_param->words_off;
5083 words_fin = words_off + work;
5084
5085 char *line_buf;
5086 uint line_len;
5087
5088 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5089
5090 for ( ; words_cur < words_fin; words_cur++)
5091 {
5092 get_next_word (wl_data, fd, &line_buf, &line_len);
5093
5094 line_len = convert_from_hex (line_buf, line_len);
5095
5096 // post-process rule engine
5097
5098 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5099 {
5100 char rule_buf_out[BLOCK_SIZE] = { 0 };
5101
5102 int rule_len_out = -1;
5103
5104 if (line_len < BLOCK_SIZE)
5105 {
5106 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5107 }
5108
5109 if (rule_len_out < 0) continue;
5110
5111 line_buf = rule_buf_out;
5112 line_len = rule_len_out;
5113 }
5114
5115 if (attack_kern == ATTACK_KERN_STRAIGHT)
5116 {
5117 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5118 {
5119 max++;
5120
5121 hc_thread_mutex_lock (mux_counter);
5122
5123 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5124 {
5125 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5126 }
5127
5128 hc_thread_mutex_unlock (mux_counter);
5129
5130 continue;
5131 }
5132 }
5133 else if (attack_kern == ATTACK_KERN_COMBI)
5134 {
5135 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5136 // since we still need to combine the plains
5137
5138 if (line_len > data.pw_max)
5139 {
5140 max++;
5141
5142 hc_thread_mutex_lock (mux_counter);
5143
5144 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5145 {
5146 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5147 }
5148
5149 hc_thread_mutex_unlock (mux_counter);
5150
5151 continue;
5152 }
5153 }
5154
5155 pw_add (device_param, (u8 *) line_buf, line_len);
5156
5157 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5158
5159 if (data.devices_status == STATUS_CRACKED) break;
5160 if (data.devices_status == STATUS_ABORTED) break;
5161 if (data.devices_status == STATUS_QUIT) break;
5162 if (data.devices_status == STATUS_BYPASS) break;
5163 }
5164
5165 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5166
5167 if (data.devices_status == STATUS_CRACKED) break;
5168 if (data.devices_status == STATUS_ABORTED) break;
5169 if (data.devices_status == STATUS_QUIT) break;
5170 if (data.devices_status == STATUS_BYPASS) break;
5171 }
5172
5173 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5174
5175 if (data.devices_status == STATUS_CRACKED) break;
5176 if (data.devices_status == STATUS_ABORTED) break;
5177 if (data.devices_status == STATUS_QUIT) break;
5178 if (data.devices_status == STATUS_BYPASS) break;
5179
5180 //
5181 // flush
5182 //
5183
5184 const uint pws_cnt = device_param->pws_cnt;
5185
5186 if (pws_cnt)
5187 {
5188 run_copy (device_param, pws_cnt);
5189
5190 run_cracker (device_param, pws_cnt);
5191
5192 device_param->pws_cnt = 0;
5193
5194 /*
5195 still required?
5196 if (attack_kern == ATTACK_KERN_STRAIGHT)
5197 {
5198 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5199 }
5200 else if (attack_kern == ATTACK_KERN_COMBI)
5201 {
5202 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5203 }
5204 */
5205 }
5206
5207 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5208
5209 if (data.devices_status == STATUS_CRACKED) break;
5210 if (data.devices_status == STATUS_ABORTED) break;
5211 if (data.devices_status == STATUS_QUIT) break;
5212 if (data.devices_status == STATUS_BYPASS) break;
5213
5214 if (words_fin == 0) break;
5215
5216 device_param->words_done = words_fin;
5217 }
5218
5219 if (attack_mode == ATTACK_MODE_COMBI)
5220 {
5221 fclose (device_param->combs_fp);
5222 }
5223
5224 free (wl_data->buf);
5225 free (wl_data);
5226
5227 fclose (fd);
5228 }
5229
5230 device_param->kernel_accel = 0;
5231 device_param->kernel_loops = 0;
5232
5233 return NULL;
5234 }
5235
5236 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5237 {
5238 if (!device_param)
5239 {
5240 log_error ("ERROR: %s : Invalid argument", __func__);
5241
5242 exit (-1);
5243 }
5244
5245 salt_t *salt_buf = &data.salts_buf[salt_pos];
5246
5247 device_param->kernel_params_buf32[27] = salt_pos;
5248 device_param->kernel_params_buf32[30] = 1;
5249 device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
5250 device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
5251 device_param->kernel_params_buf32[33] = 0;
5252 device_param->kernel_params_buf32[34] = 1;
5253
5254 char *dictfile_old = data.dictfile;
5255
5256 const char *weak_hash_check = "weak-hash-check";
5257
5258 data.dictfile = (char *) weak_hash_check;
5259
5260 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5261
5262 data.kernel_rules_buf[0].cmds[0] = 0;
5263
5264 /**
5265 * run the kernel
5266 */
5267
5268 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5269 {
5270 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5271 }
5272 else
5273 {
5274 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5275
5276 uint loop_step = 16;
5277
5278 const uint iter = salt_buf->salt_iter;
5279
5280 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5281 {
5282 uint loop_left = iter - loop_pos;
5283
5284 loop_left = MIN (loop_left, loop_step);
5285
5286 device_param->kernel_params_buf32[28] = loop_pos;
5287 device_param->kernel_params_buf32[29] = loop_left;
5288
5289 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5290 }
5291
5292 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5293 }
5294
5295 /**
5296 * result
5297 */
5298
5299 check_cracked (device_param, salt_pos);
5300
5301 /**
5302 * cleanup
5303 */
5304
5305 device_param->kernel_params_buf32[27] = 0;
5306 device_param->kernel_params_buf32[28] = 0;
5307 device_param->kernel_params_buf32[29] = 0;
5308 device_param->kernel_params_buf32[30] = 0;
5309 device_param->kernel_params_buf32[31] = 0;
5310 device_param->kernel_params_buf32[32] = 0;
5311 device_param->kernel_params_buf32[33] = 0;
5312 device_param->kernel_params_buf32[34] = 0;
5313
5314 data.dictfile = dictfile_old;
5315
5316 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5317 }
5318
5319 // hlfmt hashcat
5320
5321 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5322 {
5323 if (data.username == 0)
5324 {
5325 *hashbuf_pos = line_buf;
5326 *hashbuf_len = line_len;
5327 }
5328 else
5329 {
5330 char *pos = line_buf;
5331 int len = line_len;
5332
5333 for (int i = 0; i < line_len; i++, pos++, len--)
5334 {
5335 if (line_buf[i] == data.separator)
5336 {
5337 pos++;
5338
5339 len--;
5340
5341 break;
5342 }
5343 }
5344
5345 *hashbuf_pos = pos;
5346 *hashbuf_len = len;
5347 }
5348 }
5349
5350 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5351 {
5352 char *pos = NULL;
5353 int len = 0;
5354
5355 int sep_cnt = 0;
5356
5357 for (int i = 0; i < line_len; i++)
5358 {
5359 if (line_buf[i] == data.separator)
5360 {
5361 sep_cnt++;
5362
5363 continue;
5364 }
5365
5366 if (sep_cnt == 0)
5367 {
5368 if (pos == NULL) pos = line_buf + i;
5369
5370 len++;
5371 }
5372 }
5373
5374 *userbuf_pos = pos;
5375 *userbuf_len = len;
5376 }
5377
5378 // hlfmt pwdump
5379
5380 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5381 {
5382 int sep_cnt = 0;
5383
5384 int sep2_len = 0;
5385 int sep3_len = 0;
5386
5387 for (int i = 0; i < line_len; i++)
5388 {
5389 if (line_buf[i] == ':')
5390 {
5391 sep_cnt++;
5392
5393 continue;
5394 }
5395
5396 if (sep_cnt == 2) sep2_len++;
5397 if (sep_cnt == 3) sep3_len++;
5398 }
5399
5400 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5401
5402 return 0;
5403 }
5404
5405 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5406 {
5407 char *pos = NULL;
5408 int len = 0;
5409
5410 int sep_cnt = 0;
5411
5412 for (int i = 0; i < line_len; i++)
5413 {
5414 if (line_buf[i] == ':')
5415 {
5416 sep_cnt++;
5417
5418 continue;
5419 }
5420
5421 if (data.hash_mode == 1000)
5422 {
5423 if (sep_cnt == 3)
5424 {
5425 if (pos == NULL) pos = line_buf + i;
5426
5427 len++;
5428 }
5429 }
5430 else if (data.hash_mode == 3000)
5431 {
5432 if (sep_cnt == 2)
5433 {
5434 if (pos == NULL) pos = line_buf + i;
5435
5436 len++;
5437 }
5438 }
5439 }
5440
5441 *hashbuf_pos = pos;
5442 *hashbuf_len = len;
5443 }
5444
5445 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5446 {
5447 char *pos = NULL;
5448 int len = 0;
5449
5450 int sep_cnt = 0;
5451
5452 for (int i = 0; i < line_len; i++)
5453 {
5454 if (line_buf[i] == ':')
5455 {
5456 sep_cnt++;
5457
5458 continue;
5459 }
5460
5461 if (sep_cnt == 0)
5462 {
5463 if (pos == NULL) pos = line_buf + i;
5464
5465 len++;
5466 }
5467 }
5468
5469 *userbuf_pos = pos;
5470 *userbuf_len = len;
5471 }
5472
5473 // hlfmt passwd
5474
5475 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5476 {
5477 int sep_cnt = 0;
5478
5479 char sep5_first = 0;
5480 char sep6_first = 0;
5481
5482 for (int i = 0; i < line_len; i++)
5483 {
5484 if (line_buf[i] == ':')
5485 {
5486 sep_cnt++;
5487
5488 continue;
5489 }
5490
5491 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5492 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5493 }
5494
5495 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5496
5497 return 0;
5498 }
5499
5500 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5501 {
5502 char *pos = NULL;
5503 int len = 0;
5504
5505 int sep_cnt = 0;
5506
5507 for (int i = 0; i < line_len; i++)
5508 {
5509 if (line_buf[i] == ':')
5510 {
5511 sep_cnt++;
5512
5513 continue;
5514 }
5515
5516 if (sep_cnt == 1)
5517 {
5518 if (pos == NULL) pos = line_buf + i;
5519
5520 len++;
5521 }
5522 }
5523
5524 *hashbuf_pos = pos;
5525 *hashbuf_len = len;
5526 }
5527
5528 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5529 {
5530 char *pos = NULL;
5531 int len = 0;
5532
5533 int sep_cnt = 0;
5534
5535 for (int i = 0; i < line_len; i++)
5536 {
5537 if (line_buf[i] == ':')
5538 {
5539 sep_cnt++;
5540
5541 continue;
5542 }
5543
5544 if (sep_cnt == 0)
5545 {
5546 if (pos == NULL) pos = line_buf + i;
5547
5548 len++;
5549 }
5550 }
5551
5552 *userbuf_pos = pos;
5553 *userbuf_len = len;
5554 }
5555
5556 // hlfmt shadow
5557
5558 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5559 {
5560 int sep_cnt = 0;
5561
5562 for (int i = 0; i < line_len; i++)
5563 {
5564 if (line_buf[i] == ':') sep_cnt++;
5565 }
5566
5567 if (sep_cnt == 8) return 1;
5568
5569 return 0;
5570 }
5571
5572 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5573 {
5574 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5575 }
5576
5577 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5578 {
5579 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5580 }
5581
5582 // hlfmt main
5583
5584 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5585 {
5586 switch (hashfile_format)
5587 {
5588 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5589 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5590 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5591 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5592 }
5593 }
5594
5595 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5596 {
5597 switch (hashfile_format)
5598 {
5599 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5600 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5601 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5602 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5603 }
5604 }
5605
5606 char *strhlfmt (const uint hashfile_format)
5607 {
5608 switch (hashfile_format)
5609 {
5610 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5611 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5612 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5613 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5614 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5615 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5616 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5617 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5618 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5619 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5620 }
5621
5622 return ((char *) "Unknown");
5623 }
5624
5625 static uint hlfmt_detect (FILE *fp, uint max_check)
5626 {
5627 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5628
5629 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5630 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5631
5632 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5633
5634 uint num_check = 0;
5635
5636 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5637
5638 while (!feof (fp))
5639 {
5640 int line_len = fgetl (fp, line_buf);
5641
5642 if (line_len == 0) continue;
5643
5644 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5645 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5646 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5647
5648 if (num_check == max_check) break;
5649
5650 num_check++;
5651 }
5652
5653 myfree (line_buf);
5654
5655 uint hashlist_format = HLFMT_HASHCAT;
5656
5657 for (int i = 1; i < HLFMTS_CNT; i++)
5658 {
5659 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5660
5661 hashlist_format = i;
5662 }
5663
5664 free (formats_cnt);
5665
5666 return hashlist_format;
5667 }
5668
5669 /**
5670 * some further helper function
5671 */
5672
5673 // wrapper around mymalloc for ADL
5674
5675 #if defined(HAVE_HWMON)
5676 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5677 {
5678 return mymalloc (iSize);
5679 }
5680 #endif
5681
5682 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)
5683 {
5684 u64 collisions = 0;
5685
5686 const uint dgst_pos0 = data.dgst_pos0;
5687 const uint dgst_pos1 = data.dgst_pos1;
5688 const uint dgst_pos2 = data.dgst_pos2;
5689 const uint dgst_pos3 = data.dgst_pos3;
5690
5691 memset (bitmap_a, 0, bitmap_size);
5692 memset (bitmap_b, 0, bitmap_size);
5693 memset (bitmap_c, 0, bitmap_size);
5694 memset (bitmap_d, 0, bitmap_size);
5695
5696 for (uint i = 0; i < digests_cnt; i++)
5697 {
5698 uint *digest_ptr = (uint *) digests_buf_ptr;
5699
5700 digests_buf_ptr += dgst_size;
5701
5702 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5703 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5704 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5705 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5706
5707 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5708 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5709 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5710 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5711
5712 if (bitmap_a[idx0] & val0) collisions++;
5713 if (bitmap_b[idx1] & val1) collisions++;
5714 if (bitmap_c[idx2] & val2) collisions++;
5715 if (bitmap_d[idx3] & val3) collisions++;
5716
5717 bitmap_a[idx0] |= val0;
5718 bitmap_b[idx1] |= val1;
5719 bitmap_c[idx2] |= val2;
5720 bitmap_d[idx3] |= val3;
5721
5722 if (collisions >= collisions_max) return 0x7fffffff;
5723 }
5724
5725 return collisions;
5726 }
5727
5728 /**
5729 * main
5730 */
5731
5732 #ifdef WIN
5733 void SetConsoleWindowSize (const int x)
5734 {
5735 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5736
5737 if (h == INVALID_HANDLE_VALUE) return;
5738
5739 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5740
5741 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5742
5743 SMALL_RECT *sr = &bufferInfo.srWindow;
5744
5745 sr->Right = MAX (sr->Right, x - 1);
5746
5747 COORD co;
5748
5749 co.X = sr->Right + 1;
5750 co.Y = 9999;
5751
5752 if (!SetConsoleScreenBufferSize (h, co)) return;
5753
5754 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5755 }
5756 #endif
5757
5758 int main (int argc, char **argv)
5759 {
5760 #ifdef WIN
5761 SetConsoleWindowSize (132);
5762 #endif
5763
5764 /**
5765 * To help users a bit
5766 */
5767
5768 char *compute = getenv ("COMPUTE");
5769
5770 if (compute)
5771 {
5772 static char display[100];
5773
5774 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5775
5776 putenv (display);
5777 }
5778 else
5779 {
5780 if (getenv ("DISPLAY") == NULL)
5781 putenv ((char *) "DISPLAY=:0");
5782 }
5783
5784 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5785 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5786
5787 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5788 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5789
5790 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5791 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5792
5793 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5794 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5795
5796 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5797 putenv ((char *) "POCL_KERNEL_CACHE=0");
5798
5799 umask (077);
5800
5801 /**
5802 * Real init
5803 */
5804
5805 memset (&data, 0, sizeof (hc_global_data_t));
5806
5807 time_t proc_start;
5808
5809 time (&proc_start);
5810
5811 data.proc_start = proc_start;
5812
5813 int myargc = argc;
5814 char **myargv = argv;
5815
5816 hc_thread_mutex_init (mux_dispatcher);
5817 hc_thread_mutex_init (mux_counter);
5818 hc_thread_mutex_init (mux_display);
5819 hc_thread_mutex_init (mux_adl);
5820
5821 /**
5822 * commandline parameters
5823 */
5824
5825 uint usage = USAGE;
5826 uint version = VERSION;
5827 uint quiet = QUIET;
5828 uint benchmark = BENCHMARK;
5829 uint stdout_flag = STDOUT_FLAG;
5830 uint show = SHOW;
5831 uint left = LEFT;
5832 uint username = USERNAME;
5833 uint remove = REMOVE;
5834 uint remove_timer = REMOVE_TIMER;
5835 u64 skip = SKIP;
5836 u64 limit = LIMIT;
5837 uint keyspace = KEYSPACE;
5838 uint potfile_disable = POTFILE_DISABLE;
5839 char *potfile_path = NULL;
5840 uint debug_mode = DEBUG_MODE;
5841 char *debug_file = NULL;
5842 char *induction_dir = NULL;
5843 char *outfile_check_dir = NULL;
5844 uint force = FORCE;
5845 uint runtime = RUNTIME;
5846 uint hash_mode = HASH_MODE;
5847 uint attack_mode = ATTACK_MODE;
5848 uint markov_disable = MARKOV_DISABLE;
5849 uint markov_classic = MARKOV_CLASSIC;
5850 uint markov_threshold = MARKOV_THRESHOLD;
5851 char *markov_hcstat = NULL;
5852 char *outfile = NULL;
5853 uint outfile_format = OUTFILE_FORMAT;
5854 uint outfile_autohex = OUTFILE_AUTOHEX;
5855 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5856 uint restore = RESTORE;
5857 uint restore_timer = RESTORE_TIMER;
5858 uint restore_disable = RESTORE_DISABLE;
5859 uint status = STATUS;
5860 uint status_timer = STATUS_TIMER;
5861 uint machine_readable = MACHINE_READABLE;
5862 uint loopback = LOOPBACK;
5863 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5864 char *session = NULL;
5865 uint hex_charset = HEX_CHARSET;
5866 uint hex_salt = HEX_SALT;
5867 uint hex_wordlist = HEX_WORDLIST;
5868 uint rp_gen = RP_GEN;
5869 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5870 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5871 uint rp_gen_seed = RP_GEN_SEED;
5872 char *rule_buf_l = (char *) RULE_BUF_L;
5873 char *rule_buf_r = (char *) RULE_BUF_R;
5874 uint increment = INCREMENT;
5875 uint increment_min = INCREMENT_MIN;
5876 uint increment_max = INCREMENT_MAX;
5877 char *cpu_affinity = NULL;
5878 OCL_PTR *ocl = NULL;
5879 char *opencl_devices = NULL;
5880 char *opencl_platforms = NULL;
5881 char *opencl_device_types = NULL;
5882 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5883 char *truecrypt_keyfiles = NULL;
5884 char *veracrypt_keyfiles = NULL;
5885 uint veracrypt_pim = 0;
5886 uint workload_profile = WORKLOAD_PROFILE;
5887 uint kernel_accel = KERNEL_ACCEL;
5888 uint kernel_loops = KERNEL_LOOPS;
5889 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5890 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5891 #ifdef HAVE_HWMON
5892 uint gpu_temp_abort = GPU_TEMP_ABORT;
5893 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5894 uint powertune_enable = POWERTUNE_ENABLE;
5895 #endif
5896 uint logfile_disable = LOGFILE_DISABLE;
5897 uint segment_size = SEGMENT_SIZE;
5898 uint scrypt_tmto = SCRYPT_TMTO;
5899 char separator = SEPARATOR;
5900 uint bitmap_min = BITMAP_MIN;
5901 uint bitmap_max = BITMAP_MAX;
5902 char *custom_charset_1 = NULL;
5903 char *custom_charset_2 = NULL;
5904 char *custom_charset_3 = NULL;
5905 char *custom_charset_4 = NULL;
5906
5907 #define IDX_HELP 'h'
5908 #define IDX_VERSION 'V'
5909 #define IDX_VERSION_LOWER 'v'
5910 #define IDX_QUIET 0xff02
5911 #define IDX_SHOW 0xff03
5912 #define IDX_LEFT 0xff04
5913 #define IDX_REMOVE 0xff05
5914 #define IDX_REMOVE_TIMER 0xff37
5915 #define IDX_SKIP 's'
5916 #define IDX_LIMIT 'l'
5917 #define IDX_KEYSPACE 0xff35
5918 #define IDX_POTFILE_DISABLE 0xff06
5919 #define IDX_POTFILE_PATH 0xffe0
5920 #define IDX_DEBUG_MODE 0xff43
5921 #define IDX_DEBUG_FILE 0xff44
5922 #define IDX_INDUCTION_DIR 0xff46
5923 #define IDX_OUTFILE_CHECK_DIR 0xff47
5924 #define IDX_USERNAME 0xff07
5925 #define IDX_FORCE 0xff08
5926 #define IDX_RUNTIME 0xff09
5927 #define IDX_BENCHMARK 'b'
5928 #define IDX_STDOUT_FLAG 0xff77
5929 #define IDX_HASH_MODE 'm'
5930 #define IDX_ATTACK_MODE 'a'
5931 #define IDX_RP_FILE 'r'
5932 #define IDX_RP_GEN 'g'
5933 #define IDX_RP_GEN_FUNC_MIN 0xff10
5934 #define IDX_RP_GEN_FUNC_MAX 0xff11
5935 #define IDX_RP_GEN_SEED 0xff34
5936 #define IDX_RULE_BUF_L 'j'
5937 #define IDX_RULE_BUF_R 'k'
5938 #define IDX_INCREMENT 'i'
5939 #define IDX_INCREMENT_MIN 0xff12
5940 #define IDX_INCREMENT_MAX 0xff13
5941 #define IDX_OUTFILE 'o'
5942 #define IDX_OUTFILE_FORMAT 0xff14
5943 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5944 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5945 #define IDX_RESTORE 0xff15
5946 #define IDX_RESTORE_DISABLE 0xff27
5947 #define IDX_STATUS 0xff17
5948 #define IDX_STATUS_TIMER 0xff18
5949 #define IDX_MACHINE_READABLE 0xff50
5950 #define IDX_LOOPBACK 0xff38
5951 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5952 #define IDX_SESSION 0xff19
5953 #define IDX_HEX_CHARSET 0xff20
5954 #define IDX_HEX_SALT 0xff21
5955 #define IDX_HEX_WORDLIST 0xff40
5956 #define IDX_MARKOV_DISABLE 0xff22
5957 #define IDX_MARKOV_CLASSIC 0xff23
5958 #define IDX_MARKOV_THRESHOLD 't'
5959 #define IDX_MARKOV_HCSTAT 0xff24
5960 #define IDX_CPU_AFFINITY 0xff25
5961 #define IDX_OPENCL_DEVICES 'd'
5962 #define IDX_OPENCL_PLATFORMS 0xff72
5963 #define IDX_OPENCL_DEVICE_TYPES 'D'
5964 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5965 #define IDX_WORKLOAD_PROFILE 'w'
5966 #define IDX_KERNEL_ACCEL 'n'
5967 #define IDX_KERNEL_LOOPS 'u'
5968 #define IDX_NVIDIA_SPIN_DAMP 0xff79
5969 #define IDX_GPU_TEMP_DISABLE 0xff29
5970 #define IDX_GPU_TEMP_ABORT 0xff30
5971 #define IDX_GPU_TEMP_RETAIN 0xff31
5972 #define IDX_POWERTUNE_ENABLE 0xff41
5973 #define IDX_LOGFILE_DISABLE 0xff51
5974 #define IDX_TRUECRYPT_KEYFILES 0xff52
5975 #define IDX_VERACRYPT_KEYFILES 0xff53
5976 #define IDX_VERACRYPT_PIM 0xff54
5977 #define IDX_SCRYPT_TMTO 0xff61
5978 #define IDX_SEGMENT_SIZE 'c'
5979 #define IDX_SEPARATOR 'p'
5980 #define IDX_BITMAP_MIN 0xff70
5981 #define IDX_BITMAP_MAX 0xff71
5982 #define IDX_CUSTOM_CHARSET_1 '1'
5983 #define IDX_CUSTOM_CHARSET_2 '2'
5984 #define IDX_CUSTOM_CHARSET_3 '3'
5985 #define IDX_CUSTOM_CHARSET_4 '4'
5986
5987 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
5988
5989 struct option long_options[] =
5990 {
5991 {"help", no_argument, 0, IDX_HELP},
5992 {"version", no_argument, 0, IDX_VERSION},
5993 {"quiet", no_argument, 0, IDX_QUIET},
5994 {"show", no_argument, 0, IDX_SHOW},
5995 {"left", no_argument, 0, IDX_LEFT},
5996 {"username", no_argument, 0, IDX_USERNAME},
5997 {"remove", no_argument, 0, IDX_REMOVE},
5998 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5999 {"skip", required_argument, 0, IDX_SKIP},
6000 {"limit", required_argument, 0, IDX_LIMIT},
6001 {"keyspace", no_argument, 0, IDX_KEYSPACE},
6002 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
6003 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
6004 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
6005 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
6006 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
6007 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6008 {"force", no_argument, 0, IDX_FORCE},
6009 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6010 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
6011 {"restore", no_argument, 0, IDX_RESTORE},
6012 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6013 {"status", no_argument, 0, IDX_STATUS},
6014 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6015 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
6016 {"loopback", no_argument, 0, IDX_LOOPBACK},
6017 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6018 {"session", required_argument, 0, IDX_SESSION},
6019 {"runtime", required_argument, 0, IDX_RUNTIME},
6020 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6021 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6022 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6023 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
6024 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6025 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6026 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6027 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6028 {"rules-file", required_argument, 0, IDX_RP_FILE},
6029 {"outfile", required_argument, 0, IDX_OUTFILE},
6030 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6031 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6032 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6033 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6034 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6035 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6036 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6037 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6038 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6039 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6040 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6041 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
6042 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
6043 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6044 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6045 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6046 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6047 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6048 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6049 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6050 #ifdef HAVE_HWMON
6051 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6052 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6053 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6054 #endif // HAVE_HWMON
6055 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6056 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6057 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6058 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6059 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6060 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6061 {"seperator", required_argument, 0, IDX_SEPARATOR},
6062 {"separator", required_argument, 0, IDX_SEPARATOR},
6063 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6064 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6065 {"increment", no_argument, 0, IDX_INCREMENT},
6066 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6067 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6068 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6069 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6070 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6071 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6072 {0, 0, 0, 0}
6073 };
6074
6075 uint rp_files_cnt = 0;
6076
6077 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6078
6079 int option_index = 0;
6080 int c = -1;
6081
6082 optind = 1;
6083 optopt = 0;
6084
6085 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6086 {
6087 switch (c)
6088 {
6089 case IDX_HELP: usage = 1; break;
6090 case IDX_VERSION:
6091 case IDX_VERSION_LOWER: version = 1; break;
6092 case IDX_RESTORE: restore = 1; break;
6093 case IDX_SESSION: session = optarg; break;
6094 case IDX_SHOW: show = 1; break;
6095 case IDX_LEFT: left = 1; break;
6096 case '?': return (-1);
6097 }
6098 }
6099
6100 if (optopt != 0)
6101 {
6102 log_error ("ERROR: Invalid argument specified");
6103
6104 return (-1);
6105 }
6106
6107 /**
6108 * exit functions
6109 */
6110
6111 if (version)
6112 {
6113 log_info ("%s", VERSION_TAG);
6114
6115 return (0);
6116 }
6117
6118 if (usage)
6119 {
6120 usage_big_print (PROGNAME);
6121
6122 return (0);
6123 }
6124
6125 /**
6126 * session needs to be set, always!
6127 */
6128
6129 if (session == NULL) session = (char *) PROGNAME;
6130
6131 /**
6132 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6133 */
6134
6135 char *exec_path = get_exec_path ();
6136
6137 #ifdef LINUX
6138
6139 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6140 char *resolved_exec_path = realpath (exec_path, NULL);
6141
6142 if (resolved_install_folder == NULL)
6143 {
6144 log_error ("ERROR: %s: %s", resolved_install_folder, strerror (errno));
6145
6146 return (-1);
6147 }
6148
6149 if (resolved_exec_path == NULL)
6150 {
6151 log_error ("ERROR: %s: %s", resolved_exec_path, strerror (errno));
6152
6153 return (-1);
6154 }
6155
6156 char *install_dir = get_install_dir (resolved_exec_path);
6157 char *profile_dir = NULL;
6158 char *session_dir = NULL;
6159 char *shared_dir = NULL;
6160
6161 if (strcmp (install_dir, resolved_install_folder) == 0)
6162 {
6163 struct passwd *pw = getpwuid (getuid ());
6164
6165 const char *homedir = pw->pw_dir;
6166
6167 profile_dir = get_profile_dir (homedir);
6168 session_dir = get_session_dir (profile_dir);
6169 shared_dir = strdup (SHARED_FOLDER);
6170
6171 mkdir (profile_dir, 0700);
6172 mkdir (session_dir, 0700);
6173 }
6174 else
6175 {
6176 profile_dir = install_dir;
6177 session_dir = install_dir;
6178 shared_dir = install_dir;
6179 }
6180
6181 myfree (resolved_install_folder);
6182 myfree (resolved_exec_path);
6183
6184 #else
6185
6186 char *install_dir = get_install_dir (exec_path);
6187 char *profile_dir = install_dir;
6188 char *session_dir = install_dir;
6189 char *shared_dir = install_dir;
6190
6191 #endif
6192
6193 data.install_dir = install_dir;
6194 data.profile_dir = profile_dir;
6195 data.session_dir = session_dir;
6196 data.shared_dir = shared_dir;
6197
6198 myfree (exec_path);
6199
6200 /**
6201 * kernel cache, we need to make sure folder exist
6202 */
6203
6204 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6205
6206 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6207
6208 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6209
6210 mkdir (kernels_folder, 0700);
6211
6212 myfree (kernels_folder);
6213
6214 /**
6215 * session
6216 */
6217
6218 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6219
6220 data.session = session;
6221
6222 char *eff_restore_file = (char *) mymalloc (session_size);
6223 char *new_restore_file = (char *) mymalloc (session_size);
6224
6225 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6226 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6227
6228 data.eff_restore_file = eff_restore_file;
6229 data.new_restore_file = new_restore_file;
6230
6231 if (((show == 1) || (left == 1)) && (restore == 1))
6232 {
6233 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6234 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6235
6236 return (-1);
6237 }
6238
6239 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6240 if ((show == 1) || (left == 1))
6241 {
6242 restore_disable = 1;
6243
6244 restore = 0;
6245 }
6246
6247 data.restore_disable = restore_disable;
6248
6249 restore_data_t *rd = init_restore (argc, argv);
6250
6251 data.rd = rd;
6252
6253 /**
6254 * restore file
6255 */
6256
6257 if (restore == 1)
6258 {
6259 read_restore (eff_restore_file, rd);
6260
6261 if (rd->version_bin < RESTORE_MIN)
6262 {
6263 log_error ("ERROR: Incompatible restore-file version");
6264
6265 return (-1);
6266 }
6267
6268 myargc = rd->argc;
6269 myargv = rd->argv;
6270
6271 #ifdef _POSIX
6272 rd->pid = getpid ();
6273 #elif _WIN
6274 rd->pid = GetCurrentProcessId ();
6275 #endif
6276 }
6277
6278 uint hash_mode_chgd = 0;
6279 uint runtime_chgd = 0;
6280 uint kernel_loops_chgd = 0;
6281 uint kernel_accel_chgd = 0;
6282 uint nvidia_spin_damp_chgd = 0;
6283 uint attack_mode_chgd = 0;
6284 uint outfile_format_chgd = 0;
6285 uint rp_gen_seed_chgd = 0;
6286 uint remove_timer_chgd = 0;
6287 uint increment_min_chgd = 0;
6288 uint increment_max_chgd = 0;
6289 uint workload_profile_chgd = 0;
6290 uint opencl_vector_width_chgd = 0;
6291
6292 optind = 1;
6293 optopt = 0;
6294 option_index = 0;
6295
6296 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6297 {
6298 switch (c)
6299 {
6300 //case IDX_HELP: usage = 1; break;
6301 //case IDX_VERSION: version = 1; break;
6302 //case IDX_RESTORE: restore = 1; break;
6303 case IDX_QUIET: quiet = 1; break;
6304 //case IDX_SHOW: show = 1; break;
6305 case IDX_SHOW: break;
6306 //case IDX_LEFT: left = 1; break;
6307 case IDX_LEFT: break;
6308 case IDX_USERNAME: username = 1; break;
6309 case IDX_REMOVE: remove = 1; break;
6310 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6311 remove_timer_chgd = 1; break;
6312 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6313 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6314 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6315 case IDX_DEBUG_FILE: debug_file = optarg; break;
6316 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6317 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6318 case IDX_FORCE: force = 1; break;
6319 case IDX_SKIP: skip = atoll (optarg); break;
6320 case IDX_LIMIT: limit = atoll (optarg); break;
6321 case IDX_KEYSPACE: keyspace = 1; break;
6322 case IDX_BENCHMARK: benchmark = 1; break;
6323 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6324 case IDX_RESTORE: break;
6325 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6326 case IDX_STATUS: status = 1; break;
6327 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6328 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6329 case IDX_LOOPBACK: loopback = 1; break;
6330 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6331 //case IDX_SESSION: session = optarg; break;
6332 case IDX_SESSION: break;
6333 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6334 hash_mode_chgd = 1; break;
6335 case IDX_RUNTIME: runtime = atoi (optarg);
6336 runtime_chgd = 1; break;
6337 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6338 attack_mode_chgd = 1; break;
6339 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6340 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6341 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6342 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6343 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6344 rp_gen_seed_chgd = 1; break;
6345 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6346 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6347 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6348 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6349 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6350 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6351 case IDX_OUTFILE: outfile = optarg; break;
6352 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6353 outfile_format_chgd = 1; break;
6354 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6355 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6356 case IDX_HEX_CHARSET: hex_charset = 1; break;
6357 case IDX_HEX_SALT: hex_salt = 1; break;
6358 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6359 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6360 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6361 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6362 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6363 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6364 opencl_vector_width_chgd = 1; break;
6365 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6366 workload_profile_chgd = 1; break;
6367 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6368 kernel_accel_chgd = 1; break;
6369 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6370 kernel_loops_chgd = 1; break;
6371 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6372 nvidia_spin_damp_chgd = 1; break;
6373 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6374 #ifdef HAVE_HWMON
6375 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6376 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6377 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6378 #endif // HAVE_HWMON
6379 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6380 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6381 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6382 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6383 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6384 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6385 case IDX_SEPARATOR: separator = optarg[0]; break;
6386 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6387 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6388 case IDX_INCREMENT: increment = 1; break;
6389 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6390 increment_min_chgd = 1; break;
6391 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6392 increment_max_chgd = 1; break;
6393 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6394 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6395 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6396 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6397
6398 default:
6399 log_error ("ERROR: Invalid argument specified");
6400 return (-1);
6401 }
6402 }
6403
6404 if (optopt != 0)
6405 {
6406 log_error ("ERROR: Invalid argument specified");
6407
6408 return (-1);
6409 }
6410
6411 /**
6412 * Inform user things getting started,
6413 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6414 * - we do not need to check algorithm_pos
6415 */
6416
6417 if (quiet == 0)
6418 {
6419 if (benchmark == 1)
6420 {
6421 if (machine_readable == 0)
6422 {
6423 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6424 log_info ("");
6425 }
6426 else
6427 {
6428 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6429 }
6430 }
6431 else if (restore == 1)
6432 {
6433 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6434 log_info ("");
6435 }
6436 else if (stdout_flag == 1)
6437 {
6438 // do nothing
6439 }
6440 else if (keyspace == 1)
6441 {
6442 // do nothing
6443 }
6444 else
6445 {
6446 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6447 log_info ("");
6448 }
6449 }
6450
6451 /**
6452 * sanity check
6453 */
6454
6455 if (attack_mode > 7)
6456 {
6457 log_error ("ERROR: Invalid attack-mode specified");
6458
6459 return (-1);
6460 }
6461
6462 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6463 {
6464 log_error ("ERROR: Invalid runtime specified");
6465
6466 return (-1);
6467 }
6468
6469 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6470 {
6471 log_error ("ERROR: Invalid hash-type specified");
6472
6473 return (-1);
6474 }
6475
6476 // renamed hash modes
6477
6478 if (hash_mode_chgd)
6479 {
6480 int n = -1;
6481
6482 switch (hash_mode)
6483 {
6484 case 123: n = 124;
6485 break;
6486 }
6487
6488 if (n >= 0)
6489 {
6490 log_error ("Old -m specified, use -m %d instead", n);
6491
6492 return (-1);
6493 }
6494 }
6495
6496 if (username == 1)
6497 {
6498 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6499 {
6500 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6501
6502 return (-1);
6503 }
6504 }
6505
6506 if (outfile_format > 16)
6507 {
6508 log_error ("ERROR: Invalid outfile-format specified");
6509
6510 return (-1);
6511 }
6512
6513 if (left == 1)
6514 {
6515 if (outfile_format_chgd == 1)
6516 {
6517 if (outfile_format > 1)
6518 {
6519 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6520
6521 return (-1);
6522 }
6523 }
6524 else
6525 {
6526 outfile_format = OUTFILE_FMT_HASH;
6527 }
6528 }
6529
6530 if (show == 1)
6531 {
6532 if (outfile_format_chgd == 1)
6533 {
6534 if ((outfile_format > 7) && (outfile_format < 16))
6535 {
6536 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6537
6538 return (-1);
6539 }
6540 }
6541 }
6542
6543 if (increment_min < INCREMENT_MIN)
6544 {
6545 log_error ("ERROR: Invalid increment-min specified");
6546
6547 return (-1);
6548 }
6549
6550 if (increment_max > INCREMENT_MAX)
6551 {
6552 log_error ("ERROR: Invalid increment-max specified");
6553
6554 return (-1);
6555 }
6556
6557 if (increment_min > increment_max)
6558 {
6559 log_error ("ERROR: Invalid increment-min specified");
6560
6561 return (-1);
6562 }
6563
6564 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6565 {
6566 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6567
6568 return (-1);
6569 }
6570
6571 if ((increment == 0) && (increment_min_chgd == 1))
6572 {
6573 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6574
6575 return (-1);
6576 }
6577
6578 if ((increment == 0) && (increment_max_chgd == 1))
6579 {
6580 log_error ("ERROR: Increment-max is only supported combined with increment switch");
6581
6582 return (-1);
6583 }
6584
6585 if (rp_files_cnt && rp_gen)
6586 {
6587 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6588
6589 return (-1);
6590 }
6591
6592 if (rp_files_cnt || rp_gen)
6593 {
6594 if (attack_mode != ATTACK_MODE_STRAIGHT)
6595 {
6596 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6597
6598 return (-1);
6599 }
6600 }
6601
6602 if (rp_gen_func_min > rp_gen_func_max)
6603 {
6604 log_error ("ERROR: Invalid rp-gen-func-min specified");
6605
6606 return (-1);
6607 }
6608
6609 if (kernel_accel_chgd == 1)
6610 {
6611 if (force == 0)
6612 {
6613 log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6614 log_info ("Please consider using the -w option instead");
6615 log_info ("You can use --force to override this but do not post error reports if you do so");
6616 log_info ("");
6617
6618 return (-1);
6619 }
6620
6621 if (kernel_accel < 1)
6622 {
6623 log_error ("ERROR: Invalid kernel-accel specified");
6624
6625 return (-1);
6626 }
6627
6628 if (kernel_accel > 1024)
6629 {
6630 log_error ("ERROR: Invalid kernel-accel specified");
6631
6632 return (-1);
6633 }
6634 }
6635
6636 if (kernel_loops_chgd == 1)
6637 {
6638 if (force == 0)
6639 {
6640 log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
6641 log_info ("Please consider using the -w option instead");
6642 log_info ("You can use --force to override this but do not post error reports if you do so");
6643 log_info ("");
6644
6645 return (-1);
6646 }
6647
6648 if (kernel_loops < 1)
6649 {
6650 log_error ("ERROR: Invalid kernel-loops specified");
6651
6652 return (-1);
6653 }
6654
6655 if (kernel_loops > 1024)
6656 {
6657 log_error ("ERROR: Invalid kernel-loops specified");
6658
6659 return (-1);
6660 }
6661 }
6662
6663 if ((workload_profile < 1) || (workload_profile > 4))
6664 {
6665 log_error ("ERROR: workload-profile %i not available", workload_profile);
6666
6667 return (-1);
6668 }
6669
6670 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6671 {
6672 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6673
6674 return (-1);
6675 }
6676
6677 if (show == 1 || left == 1)
6678 {
6679 attack_mode = ATTACK_MODE_NONE;
6680
6681 if (remove == 1)
6682 {
6683 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6684
6685 return (-1);
6686 }
6687
6688 if (potfile_disable == 1)
6689 {
6690 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6691
6692 return (-1);
6693 }
6694 }
6695
6696 uint attack_kern = ATTACK_KERN_NONE;
6697
6698 switch (attack_mode)
6699 {
6700 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6701 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6702 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6703 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6704 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6705 }
6706
6707 if (benchmark == 1)
6708 {
6709 if (myargv[optind] != 0)
6710 {
6711 log_error ("ERROR: Invalid argument for benchmark mode specified");
6712
6713 return (-1);
6714 }
6715
6716 if (attack_mode_chgd == 1)
6717 {
6718 if (attack_mode != ATTACK_MODE_BF)
6719 {
6720 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6721
6722 return (-1);
6723 }
6724 }
6725 }
6726 else
6727 {
6728 if (stdout_flag == 1) // no hash here
6729 {
6730 optind--;
6731 }
6732
6733 if (keyspace == 1)
6734 {
6735 int num_additional_params = 1;
6736
6737 if (attack_kern == ATTACK_KERN_COMBI)
6738 {
6739 num_additional_params = 2;
6740 }
6741
6742 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6743
6744 if (keyspace_wordlist_specified == 0) optind--;
6745 }
6746
6747 if (attack_kern == ATTACK_KERN_NONE)
6748 {
6749 if ((optind + 1) != myargc)
6750 {
6751 usage_mini_print (myargv[0]);
6752
6753 return (-1);
6754 }
6755 }
6756 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6757 {
6758 if ((optind + 1) > myargc)
6759 {
6760 usage_mini_print (myargv[0]);
6761
6762 return (-1);
6763 }
6764 }
6765 else if (attack_kern == ATTACK_KERN_COMBI)
6766 {
6767 if ((optind + 3) != myargc)
6768 {
6769 usage_mini_print (myargv[0]);
6770
6771 return (-1);
6772 }
6773 }
6774 else if (attack_kern == ATTACK_KERN_BF)
6775 {
6776 if ((optind + 1) > myargc)
6777 {
6778 usage_mini_print (myargv[0]);
6779
6780 return (-1);
6781 }
6782 }
6783 else
6784 {
6785 usage_mini_print (myargv[0]);
6786
6787 return (-1);
6788 }
6789 }
6790
6791 if (skip != 0 && limit != 0)
6792 {
6793 limit += skip;
6794 }
6795
6796 if (keyspace == 1)
6797 {
6798 if (show == 1)
6799 {
6800 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6801
6802 return (-1);
6803 }
6804 else if (left == 1)
6805 {
6806 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6807
6808 return (-1);
6809 }
6810
6811 potfile_disable = 1;
6812
6813 restore_disable = 1;
6814
6815 restore = 0;
6816
6817 weak_hash_threshold = 0;
6818
6819 quiet = 1;
6820 }
6821
6822 if (stdout_flag == 1)
6823 {
6824 status_timer = 0;
6825 restore_timer = 0;
6826 restore_disable = 1;
6827 restore = 0;
6828 potfile_disable = 1;
6829 weak_hash_threshold = 0;
6830 gpu_temp_disable = 1;
6831 hash_mode = 2000;
6832 quiet = 1;
6833 outfile_format = OUTFILE_FMT_PLAIN;
6834 kernel_accel = 1024;
6835 kernel_loops = 1024;
6836 force = 1;
6837 outfile_check_timer = 0;
6838 session = "stdout";
6839 opencl_vector_width = 1;
6840 }
6841
6842 if (remove_timer_chgd == 1)
6843 {
6844 if (remove == 0)
6845 {
6846 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6847
6848 return (-1);
6849 }
6850
6851 if (remove_timer < 1)
6852 {
6853 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6854
6855 return (-1);
6856 }
6857 }
6858
6859 if (loopback == 1)
6860 {
6861 if (attack_mode == ATTACK_MODE_STRAIGHT)
6862 {
6863 if ((rp_files_cnt == 0) && (rp_gen == 0))
6864 {
6865 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6866
6867 return (-1);
6868 }
6869 }
6870 else
6871 {
6872 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6873
6874 return (-1);
6875 }
6876 }
6877
6878 if (debug_mode > 0)
6879 {
6880 if (attack_mode != ATTACK_MODE_STRAIGHT)
6881 {
6882 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6883
6884 return (-1);
6885 }
6886
6887 if ((rp_files_cnt == 0) && (rp_gen == 0))
6888 {
6889 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6890
6891 return (-1);
6892 }
6893 }
6894
6895 if (debug_mode > 4)
6896 {
6897 log_error ("ERROR: Invalid debug-mode specified");
6898
6899 return (-1);
6900 }
6901
6902 if (debug_file != NULL)
6903 {
6904 if (debug_mode < 1)
6905 {
6906 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6907
6908 return (-1);
6909 }
6910 }
6911
6912 if (induction_dir != NULL)
6913 {
6914 if (attack_mode == ATTACK_MODE_BF)
6915 {
6916 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6917
6918 return (-1);
6919 }
6920 }
6921
6922 if (attack_mode != ATTACK_MODE_STRAIGHT)
6923 {
6924 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6925 {
6926 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6927
6928 return (-1);
6929 }
6930
6931 weak_hash_threshold = 0;
6932 }
6933
6934 if (nvidia_spin_damp > 100)
6935 {
6936 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6937
6938 return (-1);
6939 }
6940
6941
6942 /**
6943 * induction directory
6944 */
6945
6946 char *induction_directory = NULL;
6947
6948 if (attack_mode != ATTACK_MODE_BF)
6949 {
6950 if (induction_dir == NULL)
6951 {
6952 induction_directory = (char *) mymalloc (session_size);
6953
6954 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6955
6956 // create induction folder if it does not already exist
6957
6958 if (keyspace == 0)
6959 {
6960 if (rmdir (induction_directory) == -1)
6961 {
6962 if (errno == ENOENT)
6963 {
6964 // good, we can ignore
6965 }
6966 else if (errno == ENOTEMPTY)
6967 {
6968 char *induction_directory_mv = (char *) mymalloc (session_size);
6969
6970 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6971
6972 if (rename (induction_directory, induction_directory_mv) != 0)
6973 {
6974 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6975
6976 return (-1);
6977 }
6978 }
6979 else
6980 {
6981 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6982
6983 return (-1);
6984 }
6985 }
6986
6987 if (mkdir (induction_directory, 0700) == -1)
6988 {
6989 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6990
6991 return (-1);
6992 }
6993 }
6994 }
6995 else
6996 {
6997 induction_directory = induction_dir;
6998 }
6999 }
7000
7001 data.induction_directory = induction_directory;
7002
7003 /**
7004 * loopback
7005 */
7006
7007 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
7008
7009 char *loopback_file = (char *) mymalloc (loopback_size);
7010
7011 /**
7012 * tuning db
7013 */
7014
7015 char tuning_db_file[256] = { 0 };
7016
7017 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
7018
7019 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7020
7021 /**
7022 * outfile-check directory
7023 */
7024
7025 char *outfile_check_directory = NULL;
7026
7027 if (outfile_check_dir == NULL)
7028 {
7029 outfile_check_directory = (char *) mymalloc (session_size);
7030
7031 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7032 }
7033 else
7034 {
7035 outfile_check_directory = outfile_check_dir;
7036 }
7037
7038 data.outfile_check_directory = outfile_check_directory;
7039
7040 if (keyspace == 0)
7041 {
7042 struct stat outfile_check_stat;
7043
7044 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7045 {
7046 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7047
7048 if (is_dir == 0)
7049 {
7050 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7051
7052 return (-1);
7053 }
7054 }
7055 else if (outfile_check_dir == NULL)
7056 {
7057 if (mkdir (outfile_check_directory, 0700) == -1)
7058 {
7059 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7060
7061 return (-1);
7062 }
7063 }
7064 }
7065
7066 /**
7067 * special other stuff
7068 */
7069
7070 if (hash_mode == 9710)
7071 {
7072 outfile_format = 5;
7073 outfile_format_chgd = 1;
7074 }
7075
7076 if (hash_mode == 9810)
7077 {
7078 outfile_format = 5;
7079 outfile_format_chgd = 1;
7080 }
7081
7082 if (hash_mode == 10410)
7083 {
7084 outfile_format = 5;
7085 outfile_format_chgd = 1;
7086 }
7087
7088 /**
7089 * store stuff
7090 */
7091
7092 data.hash_mode = hash_mode;
7093 data.restore = restore;
7094 data.restore_timer = restore_timer;
7095 data.restore_disable = restore_disable;
7096 data.status = status;
7097 data.status_timer = status_timer;
7098 data.machine_readable = machine_readable;
7099 data.loopback = loopback;
7100 data.runtime = runtime;
7101 data.remove = remove;
7102 data.remove_timer = remove_timer;
7103 data.debug_mode = debug_mode;
7104 data.debug_file = debug_file;
7105 data.username = username;
7106 data.quiet = quiet;
7107 data.outfile = outfile;
7108 data.outfile_format = outfile_format;
7109 data.outfile_autohex = outfile_autohex;
7110 data.hex_charset = hex_charset;
7111 data.hex_salt = hex_salt;
7112 data.hex_wordlist = hex_wordlist;
7113 data.separator = separator;
7114 data.rp_files = rp_files;
7115 data.rp_files_cnt = rp_files_cnt;
7116 data.rp_gen = rp_gen;
7117 data.rp_gen_seed = rp_gen_seed;
7118 data.force = force;
7119 data.benchmark = benchmark;
7120 data.skip = skip;
7121 data.limit = limit;
7122 #ifdef HAVE_HWMON
7123 data.powertune_enable = powertune_enable;
7124 #endif
7125 data.logfile_disable = logfile_disable;
7126 data.truecrypt_keyfiles = truecrypt_keyfiles;
7127 data.veracrypt_keyfiles = veracrypt_keyfiles;
7128 data.veracrypt_pim = veracrypt_pim;
7129 data.scrypt_tmto = scrypt_tmto;
7130 data.workload_profile = workload_profile;
7131
7132 /**
7133 * cpu affinity
7134 */
7135
7136 if (cpu_affinity)
7137 {
7138 set_cpu_affinity (cpu_affinity);
7139 }
7140
7141 if (rp_gen_seed_chgd == 0)
7142 {
7143 srand (proc_start);
7144 }
7145 else
7146 {
7147 srand (rp_gen_seed);
7148 }
7149
7150 /**
7151 * logfile init
7152 */
7153
7154 if (logfile_disable == 0)
7155 {
7156 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7157
7158 char *logfile = (char *) mymalloc (logfile_size);
7159
7160 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7161
7162 data.logfile = logfile;
7163
7164 char *topid = logfile_generate_topid ();
7165
7166 data.topid = topid;
7167 }
7168
7169 // logfile_append() checks for logfile_disable internally to make it easier from here
7170
7171 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7172 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7173 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7174 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7175 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7176 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7177 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7178 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7179 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7180 #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));
7181
7182 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7183 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7184 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7185 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7186 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7187 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7188 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7189 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7190
7191 logfile_top_msg ("START");
7192
7193 logfile_top_uint (attack_mode);
7194 logfile_top_uint (attack_kern);
7195 logfile_top_uint (benchmark);
7196 logfile_top_uint (stdout_flag);
7197 logfile_top_uint (bitmap_min);
7198 logfile_top_uint (bitmap_max);
7199 logfile_top_uint (debug_mode);
7200 logfile_top_uint (force);
7201 logfile_top_uint (kernel_accel);
7202 logfile_top_uint (kernel_loops);
7203 logfile_top_uint (nvidia_spin_damp);
7204 logfile_top_uint (gpu_temp_disable);
7205 #ifdef HAVE_HWMON
7206 logfile_top_uint (gpu_temp_abort);
7207 logfile_top_uint (gpu_temp_retain);
7208 #endif
7209 logfile_top_uint (hash_mode);
7210 logfile_top_uint (hex_charset);
7211 logfile_top_uint (hex_salt);
7212 logfile_top_uint (hex_wordlist);
7213 logfile_top_uint (increment);
7214 logfile_top_uint (increment_max);
7215 logfile_top_uint (increment_min);
7216 logfile_top_uint (keyspace);
7217 logfile_top_uint (left);
7218 logfile_top_uint (logfile_disable);
7219 logfile_top_uint (loopback);
7220 logfile_top_uint (markov_classic);
7221 logfile_top_uint (markov_disable);
7222 logfile_top_uint (markov_threshold);
7223 logfile_top_uint (outfile_autohex);
7224 logfile_top_uint (outfile_check_timer);
7225 logfile_top_uint (outfile_format);
7226 logfile_top_uint (potfile_disable);
7227 logfile_top_string (potfile_path);
7228 #if defined(HAVE_HWMON)
7229 logfile_top_uint (powertune_enable);
7230 #endif
7231 logfile_top_uint (scrypt_tmto);
7232 logfile_top_uint (quiet);
7233 logfile_top_uint (remove);
7234 logfile_top_uint (remove_timer);
7235 logfile_top_uint (restore);
7236 logfile_top_uint (restore_disable);
7237 logfile_top_uint (restore_timer);
7238 logfile_top_uint (rp_gen);
7239 logfile_top_uint (rp_gen_func_max);
7240 logfile_top_uint (rp_gen_func_min);
7241 logfile_top_uint (rp_gen_seed);
7242 logfile_top_uint (runtime);
7243 logfile_top_uint (segment_size);
7244 logfile_top_uint (show);
7245 logfile_top_uint (status);
7246 logfile_top_uint (machine_readable);
7247 logfile_top_uint (status_timer);
7248 logfile_top_uint (usage);
7249 logfile_top_uint (username);
7250 logfile_top_uint (version);
7251 logfile_top_uint (weak_hash_threshold);
7252 logfile_top_uint (workload_profile);
7253 logfile_top_uint64 (limit);
7254 logfile_top_uint64 (skip);
7255 logfile_top_char (separator);
7256 logfile_top_string (cpu_affinity);
7257 logfile_top_string (custom_charset_1);
7258 logfile_top_string (custom_charset_2);
7259 logfile_top_string (custom_charset_3);
7260 logfile_top_string (custom_charset_4);
7261 logfile_top_string (debug_file);
7262 logfile_top_string (opencl_devices);
7263 logfile_top_string (opencl_platforms);
7264 logfile_top_string (opencl_device_types);
7265 logfile_top_uint (opencl_vector_width);
7266 logfile_top_string (induction_dir);
7267 logfile_top_string (markov_hcstat);
7268 logfile_top_string (outfile);
7269 logfile_top_string (outfile_check_dir);
7270 logfile_top_string (rule_buf_l);
7271 logfile_top_string (rule_buf_r);
7272 logfile_top_string (session);
7273 logfile_top_string (truecrypt_keyfiles);
7274 logfile_top_string (veracrypt_keyfiles);
7275 logfile_top_uint (veracrypt_pim);
7276
7277 /**
7278 * Init OpenCL library loader
7279 */
7280
7281 if (keyspace == 0)
7282 {
7283 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7284
7285 ocl_init (ocl);
7286
7287 data.ocl = ocl;
7288 }
7289
7290 /**
7291 * OpenCL platform selection
7292 */
7293
7294 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7295
7296 /**
7297 * OpenCL device selection
7298 */
7299
7300 u32 devices_filter = setup_devices_filter (opencl_devices);
7301
7302 /**
7303 * OpenCL device type selection
7304 */
7305
7306 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7307
7308 /**
7309 * benchmark
7310 */
7311
7312 if (benchmark == 1)
7313 {
7314 /**
7315 * disable useless stuff for benchmark
7316 */
7317
7318 status_timer = 0;
7319 restore_timer = 0;
7320 restore_disable = 1;
7321 potfile_disable = 1;
7322 weak_hash_threshold = 0;
7323 nvidia_spin_damp = 0;
7324 gpu_temp_disable = 1;
7325 outfile_check_timer = 0;
7326
7327 #ifdef HAVE_HWMON
7328 if (powertune_enable == 1)
7329 {
7330 gpu_temp_disable = 0;
7331 }
7332 #endif
7333
7334 data.status_timer = status_timer;
7335 data.restore_timer = restore_timer;
7336 data.restore_disable = restore_disable;
7337 data.outfile_check_timer = outfile_check_timer;
7338
7339 /**
7340 * force attack mode to be bruteforce
7341 */
7342
7343 attack_mode = ATTACK_MODE_BF;
7344 attack_kern = ATTACK_KERN_BF;
7345
7346 if (workload_profile_chgd == 0)
7347 {
7348 workload_profile = 3;
7349
7350 data.workload_profile = workload_profile;
7351 }
7352 }
7353
7354 /**
7355 * status, monitor and outfile remove threads
7356 */
7357
7358 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
7359
7360 data.wordlist_mode = wordlist_mode;
7361
7362 if (wordlist_mode == WL_MODE_STDIN)
7363 {
7364 status = 1;
7365
7366 data.status = status;
7367 }
7368
7369 uint outer_threads_cnt = 0;
7370
7371 hc_thread_t *outer_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
7372
7373 data.shutdown_outer = 0;
7374
7375 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
7376 {
7377 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
7378 {
7379 hc_thread_create (outer_threads[outer_threads_cnt], thread_keypress, NULL);
7380
7381 outer_threads_cnt++;
7382 }
7383 }
7384
7385 /**
7386 * config
7387 */
7388
7389 uint hash_type = 0;
7390 uint salt_type = 0;
7391 uint attack_exec = 0;
7392 uint opts_type = 0;
7393 uint kern_type = 0;
7394 uint dgst_size = 0;
7395 uint esalt_size = 0;
7396 uint opti_type = 0;
7397 uint dgst_pos0 = -1;
7398 uint dgst_pos1 = -1;
7399 uint dgst_pos2 = -1;
7400 uint dgst_pos3 = -1;
7401
7402 int (*parse_func) (char *, uint, hash_t *);
7403 int (*sort_by_digest) (const void *, const void *);
7404
7405 uint algorithm_pos = 0;
7406 uint algorithm_max = 1;
7407
7408 uint *algorithms = default_benchmark_algorithms;
7409
7410 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7411
7412 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7413 {
7414 /*
7415 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7416 * the following algos are skipped entirely
7417 */
7418
7419 if (algorithm_pos > 0)
7420 {
7421 local_free (rd);
7422
7423 rd = init_restore (argc, argv);
7424
7425 data.rd = rd;
7426 }
7427
7428 /**
7429 * update hash_mode in case of multihash benchmark
7430 */
7431
7432 if (benchmark == 1)
7433 {
7434 if (hash_mode_chgd == 0)
7435 {
7436 hash_mode = algorithms[algorithm_pos];
7437
7438 data.hash_mode = hash_mode;
7439 }
7440
7441 quiet = 1;
7442
7443 data.quiet = quiet;
7444 }
7445
7446 switch (hash_mode)
7447 {
7448 case 0: hash_type = HASH_TYPE_MD5;
7449 salt_type = SALT_TYPE_NONE;
7450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7451 opts_type = OPTS_TYPE_PT_GENERATE_LE
7452 | OPTS_TYPE_PT_ADD80
7453 | OPTS_TYPE_PT_ADDBITS14;
7454 kern_type = KERN_TYPE_MD5;
7455 dgst_size = DGST_SIZE_4_4;
7456 parse_func = md5_parse_hash;
7457 sort_by_digest = sort_by_digest_4_4;
7458 opti_type = OPTI_TYPE_ZERO_BYTE
7459 | OPTI_TYPE_PRECOMPUTE_INIT
7460 | OPTI_TYPE_PRECOMPUTE_MERKLE
7461 | OPTI_TYPE_MEET_IN_MIDDLE
7462 | OPTI_TYPE_EARLY_SKIP
7463 | OPTI_TYPE_NOT_ITERATED
7464 | OPTI_TYPE_NOT_SALTED
7465 | OPTI_TYPE_RAW_HASH;
7466 dgst_pos0 = 0;
7467 dgst_pos1 = 3;
7468 dgst_pos2 = 2;
7469 dgst_pos3 = 1;
7470 break;
7471
7472 case 10: hash_type = HASH_TYPE_MD5;
7473 salt_type = SALT_TYPE_INTERN;
7474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7475 opts_type = OPTS_TYPE_PT_GENERATE_LE
7476 | OPTS_TYPE_ST_ADD80
7477 | OPTS_TYPE_ST_ADDBITS14;
7478 kern_type = KERN_TYPE_MD5_PWSLT;
7479 dgst_size = DGST_SIZE_4_4;
7480 parse_func = md5s_parse_hash;
7481 sort_by_digest = sort_by_digest_4_4;
7482 opti_type = OPTI_TYPE_ZERO_BYTE
7483 | OPTI_TYPE_PRECOMPUTE_INIT
7484 | OPTI_TYPE_PRECOMPUTE_MERKLE
7485 | OPTI_TYPE_MEET_IN_MIDDLE
7486 | OPTI_TYPE_EARLY_SKIP
7487 | OPTI_TYPE_NOT_ITERATED
7488 | OPTI_TYPE_APPENDED_SALT
7489 | OPTI_TYPE_RAW_HASH;
7490 dgst_pos0 = 0;
7491 dgst_pos1 = 3;
7492 dgst_pos2 = 2;
7493 dgst_pos3 = 1;
7494 break;
7495
7496 case 11: hash_type = HASH_TYPE_MD5;
7497 salt_type = SALT_TYPE_INTERN;
7498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7499 opts_type = OPTS_TYPE_PT_GENERATE_LE
7500 | OPTS_TYPE_ST_ADD80
7501 | OPTS_TYPE_ST_ADDBITS14;
7502 kern_type = KERN_TYPE_MD5_PWSLT;
7503 dgst_size = DGST_SIZE_4_4;
7504 parse_func = joomla_parse_hash;
7505 sort_by_digest = sort_by_digest_4_4;
7506 opti_type = OPTI_TYPE_ZERO_BYTE
7507 | OPTI_TYPE_PRECOMPUTE_INIT
7508 | OPTI_TYPE_PRECOMPUTE_MERKLE
7509 | OPTI_TYPE_MEET_IN_MIDDLE
7510 | OPTI_TYPE_EARLY_SKIP
7511 | OPTI_TYPE_NOT_ITERATED
7512 | OPTI_TYPE_APPENDED_SALT
7513 | OPTI_TYPE_RAW_HASH;
7514 dgst_pos0 = 0;
7515 dgst_pos1 = 3;
7516 dgst_pos2 = 2;
7517 dgst_pos3 = 1;
7518 break;
7519
7520 case 12: hash_type = HASH_TYPE_MD5;
7521 salt_type = SALT_TYPE_INTERN;
7522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7523 opts_type = OPTS_TYPE_PT_GENERATE_LE
7524 | OPTS_TYPE_ST_ADD80
7525 | OPTS_TYPE_ST_ADDBITS14;
7526 kern_type = KERN_TYPE_MD5_PWSLT;
7527 dgst_size = DGST_SIZE_4_4;
7528 parse_func = postgresql_parse_hash;
7529 sort_by_digest = sort_by_digest_4_4;
7530 opti_type = OPTI_TYPE_ZERO_BYTE
7531 | OPTI_TYPE_PRECOMPUTE_INIT
7532 | OPTI_TYPE_PRECOMPUTE_MERKLE
7533 | OPTI_TYPE_MEET_IN_MIDDLE
7534 | OPTI_TYPE_EARLY_SKIP
7535 | OPTI_TYPE_NOT_ITERATED
7536 | OPTI_TYPE_APPENDED_SALT
7537 | OPTI_TYPE_RAW_HASH;
7538 dgst_pos0 = 0;
7539 dgst_pos1 = 3;
7540 dgst_pos2 = 2;
7541 dgst_pos3 = 1;
7542 break;
7543
7544 case 20: hash_type = HASH_TYPE_MD5;
7545 salt_type = SALT_TYPE_INTERN;
7546 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7547 opts_type = OPTS_TYPE_PT_GENERATE_LE
7548 | OPTS_TYPE_PT_ADD80
7549 | OPTS_TYPE_PT_ADDBITS14;
7550 kern_type = KERN_TYPE_MD5_SLTPW;
7551 dgst_size = DGST_SIZE_4_4;
7552 parse_func = md5s_parse_hash;
7553 sort_by_digest = sort_by_digest_4_4;
7554 opti_type = OPTI_TYPE_ZERO_BYTE
7555 | OPTI_TYPE_PRECOMPUTE_INIT
7556 | OPTI_TYPE_PRECOMPUTE_MERKLE
7557 | OPTI_TYPE_EARLY_SKIP
7558 | OPTI_TYPE_NOT_ITERATED
7559 | OPTI_TYPE_PREPENDED_SALT
7560 | OPTI_TYPE_RAW_HASH;
7561 dgst_pos0 = 0;
7562 dgst_pos1 = 3;
7563 dgst_pos2 = 2;
7564 dgst_pos3 = 1;
7565 break;
7566
7567 case 21: hash_type = HASH_TYPE_MD5;
7568 salt_type = SALT_TYPE_INTERN;
7569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7570 opts_type = OPTS_TYPE_PT_GENERATE_LE
7571 | OPTS_TYPE_PT_ADD80
7572 | OPTS_TYPE_PT_ADDBITS14;
7573 kern_type = KERN_TYPE_MD5_SLTPW;
7574 dgst_size = DGST_SIZE_4_4;
7575 parse_func = osc_parse_hash;
7576 sort_by_digest = sort_by_digest_4_4;
7577 opti_type = OPTI_TYPE_ZERO_BYTE
7578 | OPTI_TYPE_PRECOMPUTE_INIT
7579 | OPTI_TYPE_PRECOMPUTE_MERKLE
7580 | OPTI_TYPE_EARLY_SKIP
7581 | OPTI_TYPE_NOT_ITERATED
7582 | OPTI_TYPE_PREPENDED_SALT
7583 | OPTI_TYPE_RAW_HASH;
7584 dgst_pos0 = 0;
7585 dgst_pos1 = 3;
7586 dgst_pos2 = 2;
7587 dgst_pos3 = 1;
7588 break;
7589
7590 case 22: hash_type = HASH_TYPE_MD5;
7591 salt_type = SALT_TYPE_EMBEDDED;
7592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7593 opts_type = OPTS_TYPE_PT_GENERATE_LE
7594 | OPTS_TYPE_PT_ADD80
7595 | OPTS_TYPE_PT_ADDBITS14;
7596 kern_type = KERN_TYPE_MD5_SLTPW;
7597 dgst_size = DGST_SIZE_4_4;
7598 parse_func = netscreen_parse_hash;
7599 sort_by_digest = sort_by_digest_4_4;
7600 opti_type = OPTI_TYPE_ZERO_BYTE
7601 | OPTI_TYPE_PRECOMPUTE_INIT
7602 | OPTI_TYPE_PRECOMPUTE_MERKLE
7603 | OPTI_TYPE_EARLY_SKIP
7604 | OPTI_TYPE_NOT_ITERATED
7605 | OPTI_TYPE_PREPENDED_SALT
7606 | OPTI_TYPE_RAW_HASH;
7607 dgst_pos0 = 0;
7608 dgst_pos1 = 3;
7609 dgst_pos2 = 2;
7610 dgst_pos3 = 1;
7611 break;
7612
7613 case 23: hash_type = HASH_TYPE_MD5;
7614 salt_type = SALT_TYPE_EMBEDDED;
7615 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7616 opts_type = OPTS_TYPE_PT_GENERATE_LE
7617 | OPTS_TYPE_PT_ADD80
7618 | OPTS_TYPE_PT_ADDBITS14;
7619 kern_type = KERN_TYPE_MD5_SLTPW;
7620 dgst_size = DGST_SIZE_4_4;
7621 parse_func = skype_parse_hash;
7622 sort_by_digest = sort_by_digest_4_4;
7623 opti_type = OPTI_TYPE_ZERO_BYTE
7624 | OPTI_TYPE_PRECOMPUTE_INIT
7625 | OPTI_TYPE_PRECOMPUTE_MERKLE
7626 | OPTI_TYPE_EARLY_SKIP
7627 | OPTI_TYPE_NOT_ITERATED
7628 | OPTI_TYPE_PREPENDED_SALT
7629 | OPTI_TYPE_RAW_HASH;
7630 dgst_pos0 = 0;
7631 dgst_pos1 = 3;
7632 dgst_pos2 = 2;
7633 dgst_pos3 = 1;
7634 break;
7635
7636 case 30: hash_type = HASH_TYPE_MD5;
7637 salt_type = SALT_TYPE_INTERN;
7638 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7639 opts_type = OPTS_TYPE_PT_GENERATE_LE
7640 | OPTS_TYPE_PT_UNICODE
7641 | OPTS_TYPE_ST_ADD80
7642 | OPTS_TYPE_ST_ADDBITS14;
7643 kern_type = KERN_TYPE_MD5_PWUSLT;
7644 dgst_size = DGST_SIZE_4_4;
7645 parse_func = md5s_parse_hash;
7646 sort_by_digest = sort_by_digest_4_4;
7647 opti_type = OPTI_TYPE_ZERO_BYTE
7648 | OPTI_TYPE_PRECOMPUTE_INIT
7649 | OPTI_TYPE_PRECOMPUTE_MERKLE
7650 | OPTI_TYPE_MEET_IN_MIDDLE
7651 | OPTI_TYPE_EARLY_SKIP
7652 | OPTI_TYPE_NOT_ITERATED
7653 | OPTI_TYPE_APPENDED_SALT
7654 | OPTI_TYPE_RAW_HASH;
7655 dgst_pos0 = 0;
7656 dgst_pos1 = 3;
7657 dgst_pos2 = 2;
7658 dgst_pos3 = 1;
7659 break;
7660
7661 case 40: hash_type = HASH_TYPE_MD5;
7662 salt_type = SALT_TYPE_INTERN;
7663 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7664 opts_type = OPTS_TYPE_PT_GENERATE_LE
7665 | OPTS_TYPE_PT_ADD80
7666 | OPTS_TYPE_PT_ADDBITS14
7667 | OPTS_TYPE_PT_UNICODE;
7668 kern_type = KERN_TYPE_MD5_SLTPWU;
7669 dgst_size = DGST_SIZE_4_4;
7670 parse_func = md5s_parse_hash;
7671 sort_by_digest = sort_by_digest_4_4;
7672 opti_type = OPTI_TYPE_ZERO_BYTE
7673 | OPTI_TYPE_PRECOMPUTE_INIT
7674 | OPTI_TYPE_PRECOMPUTE_MERKLE
7675 | OPTI_TYPE_EARLY_SKIP
7676 | OPTI_TYPE_NOT_ITERATED
7677 | OPTI_TYPE_PREPENDED_SALT
7678 | OPTI_TYPE_RAW_HASH;
7679 dgst_pos0 = 0;
7680 dgst_pos1 = 3;
7681 dgst_pos2 = 2;
7682 dgst_pos3 = 1;
7683 break;
7684
7685 case 50: hash_type = HASH_TYPE_MD5;
7686 salt_type = SALT_TYPE_INTERN;
7687 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7688 opts_type = OPTS_TYPE_PT_GENERATE_LE
7689 | OPTS_TYPE_ST_ADD80
7690 | OPTS_TYPE_ST_ADDBITS14;
7691 kern_type = KERN_TYPE_HMACMD5_PW;
7692 dgst_size = DGST_SIZE_4_4;
7693 parse_func = hmacmd5_parse_hash;
7694 sort_by_digest = sort_by_digest_4_4;
7695 opti_type = OPTI_TYPE_ZERO_BYTE
7696 | OPTI_TYPE_NOT_ITERATED;
7697 dgst_pos0 = 0;
7698 dgst_pos1 = 3;
7699 dgst_pos2 = 2;
7700 dgst_pos3 = 1;
7701 break;
7702
7703 case 60: hash_type = HASH_TYPE_MD5;
7704 salt_type = SALT_TYPE_INTERN;
7705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7706 opts_type = OPTS_TYPE_PT_GENERATE_LE
7707 | OPTS_TYPE_PT_ADD80
7708 | OPTS_TYPE_PT_ADDBITS14;
7709 kern_type = KERN_TYPE_HMACMD5_SLT;
7710 dgst_size = DGST_SIZE_4_4;
7711 parse_func = hmacmd5_parse_hash;
7712 sort_by_digest = sort_by_digest_4_4;
7713 opti_type = OPTI_TYPE_ZERO_BYTE
7714 | OPTI_TYPE_NOT_ITERATED;
7715 dgst_pos0 = 0;
7716 dgst_pos1 = 3;
7717 dgst_pos2 = 2;
7718 dgst_pos3 = 1;
7719 break;
7720
7721 case 100: hash_type = HASH_TYPE_SHA1;
7722 salt_type = SALT_TYPE_NONE;
7723 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7724 opts_type = OPTS_TYPE_PT_GENERATE_BE
7725 | OPTS_TYPE_PT_ADD80
7726 | OPTS_TYPE_PT_ADDBITS15;
7727 kern_type = KERN_TYPE_SHA1;
7728 dgst_size = DGST_SIZE_4_5;
7729 parse_func = sha1_parse_hash;
7730 sort_by_digest = sort_by_digest_4_5;
7731 opti_type = OPTI_TYPE_ZERO_BYTE
7732 | OPTI_TYPE_PRECOMPUTE_INIT
7733 | OPTI_TYPE_PRECOMPUTE_MERKLE
7734 | OPTI_TYPE_EARLY_SKIP
7735 | OPTI_TYPE_NOT_ITERATED
7736 | OPTI_TYPE_NOT_SALTED
7737 | OPTI_TYPE_RAW_HASH;
7738 dgst_pos0 = 3;
7739 dgst_pos1 = 4;
7740 dgst_pos2 = 2;
7741 dgst_pos3 = 1;
7742 break;
7743
7744 case 101: hash_type = HASH_TYPE_SHA1;
7745 salt_type = SALT_TYPE_NONE;
7746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7747 opts_type = OPTS_TYPE_PT_GENERATE_BE
7748 | OPTS_TYPE_PT_ADD80
7749 | OPTS_TYPE_PT_ADDBITS15;
7750 kern_type = KERN_TYPE_SHA1;
7751 dgst_size = DGST_SIZE_4_5;
7752 parse_func = sha1b64_parse_hash;
7753 sort_by_digest = sort_by_digest_4_5;
7754 opti_type = OPTI_TYPE_ZERO_BYTE
7755 | OPTI_TYPE_PRECOMPUTE_INIT
7756 | OPTI_TYPE_PRECOMPUTE_MERKLE
7757 | OPTI_TYPE_EARLY_SKIP
7758 | OPTI_TYPE_NOT_ITERATED
7759 | OPTI_TYPE_NOT_SALTED
7760 | OPTI_TYPE_RAW_HASH;
7761 dgst_pos0 = 3;
7762 dgst_pos1 = 4;
7763 dgst_pos2 = 2;
7764 dgst_pos3 = 1;
7765 break;
7766
7767 case 110: hash_type = HASH_TYPE_SHA1;
7768 salt_type = SALT_TYPE_INTERN;
7769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7770 opts_type = OPTS_TYPE_PT_GENERATE_BE
7771 | OPTS_TYPE_ST_ADD80
7772 | OPTS_TYPE_ST_ADDBITS15;
7773 kern_type = KERN_TYPE_SHA1_PWSLT;
7774 dgst_size = DGST_SIZE_4_5;
7775 parse_func = sha1s_parse_hash;
7776 sort_by_digest = sort_by_digest_4_5;
7777 opti_type = OPTI_TYPE_ZERO_BYTE
7778 | OPTI_TYPE_PRECOMPUTE_INIT
7779 | OPTI_TYPE_PRECOMPUTE_MERKLE
7780 | OPTI_TYPE_EARLY_SKIP
7781 | OPTI_TYPE_NOT_ITERATED
7782 | OPTI_TYPE_APPENDED_SALT
7783 | OPTI_TYPE_RAW_HASH;
7784 dgst_pos0 = 3;
7785 dgst_pos1 = 4;
7786 dgst_pos2 = 2;
7787 dgst_pos3 = 1;
7788 break;
7789
7790 case 111: hash_type = HASH_TYPE_SHA1;
7791 salt_type = SALT_TYPE_EMBEDDED;
7792 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7793 opts_type = OPTS_TYPE_PT_GENERATE_BE
7794 | OPTS_TYPE_ST_ADD80
7795 | OPTS_TYPE_ST_ADDBITS15;
7796 kern_type = KERN_TYPE_SHA1_PWSLT;
7797 dgst_size = DGST_SIZE_4_5;
7798 parse_func = sha1b64s_parse_hash;
7799 sort_by_digest = sort_by_digest_4_5;
7800 opti_type = OPTI_TYPE_ZERO_BYTE
7801 | OPTI_TYPE_PRECOMPUTE_INIT
7802 | OPTI_TYPE_PRECOMPUTE_MERKLE
7803 | OPTI_TYPE_EARLY_SKIP
7804 | OPTI_TYPE_NOT_ITERATED
7805 | OPTI_TYPE_APPENDED_SALT
7806 | OPTI_TYPE_RAW_HASH;
7807 dgst_pos0 = 3;
7808 dgst_pos1 = 4;
7809 dgst_pos2 = 2;
7810 dgst_pos3 = 1;
7811 break;
7812
7813 case 112: hash_type = HASH_TYPE_SHA1;
7814 salt_type = SALT_TYPE_INTERN;
7815 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7816 opts_type = OPTS_TYPE_PT_GENERATE_BE
7817 | OPTS_TYPE_ST_ADD80
7818 | OPTS_TYPE_ST_ADDBITS15
7819 | OPTS_TYPE_ST_HEX;
7820 kern_type = KERN_TYPE_SHA1_PWSLT;
7821 dgst_size = DGST_SIZE_4_5;
7822 parse_func = oracles_parse_hash;
7823 sort_by_digest = sort_by_digest_4_5;
7824 opti_type = OPTI_TYPE_ZERO_BYTE
7825 | OPTI_TYPE_PRECOMPUTE_INIT
7826 | OPTI_TYPE_PRECOMPUTE_MERKLE
7827 | OPTI_TYPE_EARLY_SKIP
7828 | OPTI_TYPE_NOT_ITERATED
7829 | OPTI_TYPE_APPENDED_SALT
7830 | OPTI_TYPE_RAW_HASH;
7831 dgst_pos0 = 3;
7832 dgst_pos1 = 4;
7833 dgst_pos2 = 2;
7834 dgst_pos3 = 1;
7835 break;
7836
7837 case 120: hash_type = HASH_TYPE_SHA1;
7838 salt_type = SALT_TYPE_INTERN;
7839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7840 opts_type = OPTS_TYPE_PT_GENERATE_BE
7841 | OPTS_TYPE_PT_ADD80
7842 | OPTS_TYPE_PT_ADDBITS15;
7843 kern_type = KERN_TYPE_SHA1_SLTPW;
7844 dgst_size = DGST_SIZE_4_5;
7845 parse_func = sha1s_parse_hash;
7846 sort_by_digest = sort_by_digest_4_5;
7847 opti_type = OPTI_TYPE_ZERO_BYTE
7848 | OPTI_TYPE_PRECOMPUTE_INIT
7849 | OPTI_TYPE_PRECOMPUTE_MERKLE
7850 | OPTI_TYPE_EARLY_SKIP
7851 | OPTI_TYPE_NOT_ITERATED
7852 | OPTI_TYPE_PREPENDED_SALT
7853 | OPTI_TYPE_RAW_HASH;
7854 dgst_pos0 = 3;
7855 dgst_pos1 = 4;
7856 dgst_pos2 = 2;
7857 dgst_pos3 = 1;
7858 break;
7859
7860 case 121: hash_type = HASH_TYPE_SHA1;
7861 salt_type = SALT_TYPE_INTERN;
7862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7863 opts_type = OPTS_TYPE_PT_GENERATE_BE
7864 | OPTS_TYPE_PT_ADD80
7865 | OPTS_TYPE_PT_ADDBITS15
7866 | OPTS_TYPE_ST_LOWER;
7867 kern_type = KERN_TYPE_SHA1_SLTPW;
7868 dgst_size = DGST_SIZE_4_5;
7869 parse_func = smf_parse_hash;
7870 sort_by_digest = sort_by_digest_4_5;
7871 opti_type = OPTI_TYPE_ZERO_BYTE
7872 | OPTI_TYPE_PRECOMPUTE_INIT
7873 | OPTI_TYPE_PRECOMPUTE_MERKLE
7874 | OPTI_TYPE_EARLY_SKIP
7875 | OPTI_TYPE_NOT_ITERATED
7876 | OPTI_TYPE_PREPENDED_SALT
7877 | OPTI_TYPE_RAW_HASH;
7878 dgst_pos0 = 3;
7879 dgst_pos1 = 4;
7880 dgst_pos2 = 2;
7881 dgst_pos3 = 1;
7882 break;
7883
7884 case 122: hash_type = HASH_TYPE_SHA1;
7885 salt_type = SALT_TYPE_EMBEDDED;
7886 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7887 opts_type = OPTS_TYPE_PT_GENERATE_BE
7888 | OPTS_TYPE_PT_ADD80
7889 | OPTS_TYPE_PT_ADDBITS15
7890 | OPTS_TYPE_ST_HEX;
7891 kern_type = KERN_TYPE_SHA1_SLTPW;
7892 dgst_size = DGST_SIZE_4_5;
7893 parse_func = osx1_parse_hash;
7894 sort_by_digest = sort_by_digest_4_5;
7895 opti_type = OPTI_TYPE_ZERO_BYTE
7896 | OPTI_TYPE_PRECOMPUTE_INIT
7897 | OPTI_TYPE_PRECOMPUTE_MERKLE
7898 | OPTI_TYPE_EARLY_SKIP
7899 | OPTI_TYPE_NOT_ITERATED
7900 | OPTI_TYPE_PREPENDED_SALT
7901 | OPTI_TYPE_RAW_HASH;
7902 dgst_pos0 = 3;
7903 dgst_pos1 = 4;
7904 dgst_pos2 = 2;
7905 dgst_pos3 = 1;
7906 break;
7907
7908 case 124: hash_type = HASH_TYPE_SHA1;
7909 salt_type = SALT_TYPE_EMBEDDED;
7910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7911 opts_type = OPTS_TYPE_PT_GENERATE_BE
7912 | OPTS_TYPE_PT_ADD80
7913 | OPTS_TYPE_PT_ADDBITS15;
7914 kern_type = KERN_TYPE_SHA1_SLTPW;
7915 dgst_size = DGST_SIZE_4_5;
7916 parse_func = djangosha1_parse_hash;
7917 sort_by_digest = sort_by_digest_4_5;
7918 opti_type = OPTI_TYPE_ZERO_BYTE
7919 | OPTI_TYPE_PRECOMPUTE_INIT
7920 | OPTI_TYPE_PRECOMPUTE_MERKLE
7921 | OPTI_TYPE_EARLY_SKIP
7922 | OPTI_TYPE_NOT_ITERATED
7923 | OPTI_TYPE_PREPENDED_SALT
7924 | OPTI_TYPE_RAW_HASH;
7925 dgst_pos0 = 3;
7926 dgst_pos1 = 4;
7927 dgst_pos2 = 2;
7928 dgst_pos3 = 1;
7929 break;
7930
7931 case 125: hash_type = HASH_TYPE_SHA1;
7932 salt_type = SALT_TYPE_EMBEDDED;
7933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7934 opts_type = OPTS_TYPE_PT_GENERATE_BE
7935 | OPTS_TYPE_PT_ADD80
7936 | OPTS_TYPE_PT_ADDBITS15
7937 | OPTS_TYPE_ST_HEX;
7938 kern_type = KERN_TYPE_SHA1_SLTPW;
7939 dgst_size = DGST_SIZE_4_5;
7940 parse_func = arubaos_parse_hash;
7941 sort_by_digest = sort_by_digest_4_5;
7942 opti_type = OPTI_TYPE_ZERO_BYTE
7943 | OPTI_TYPE_PRECOMPUTE_INIT
7944 | OPTI_TYPE_PRECOMPUTE_MERKLE
7945 | OPTI_TYPE_EARLY_SKIP
7946 | OPTI_TYPE_NOT_ITERATED
7947 | OPTI_TYPE_PREPENDED_SALT
7948 | OPTI_TYPE_RAW_HASH;
7949 dgst_pos0 = 3;
7950 dgst_pos1 = 4;
7951 dgst_pos2 = 2;
7952 dgst_pos3 = 1;
7953 break;
7954
7955 case 130: hash_type = HASH_TYPE_SHA1;
7956 salt_type = SALT_TYPE_INTERN;
7957 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7958 opts_type = OPTS_TYPE_PT_GENERATE_BE
7959 | OPTS_TYPE_PT_UNICODE
7960 | OPTS_TYPE_ST_ADD80
7961 | OPTS_TYPE_ST_ADDBITS15;
7962 kern_type = KERN_TYPE_SHA1_PWUSLT;
7963 dgst_size = DGST_SIZE_4_5;
7964 parse_func = sha1s_parse_hash;
7965 sort_by_digest = sort_by_digest_4_5;
7966 opti_type = OPTI_TYPE_ZERO_BYTE
7967 | OPTI_TYPE_PRECOMPUTE_INIT
7968 | OPTI_TYPE_PRECOMPUTE_MERKLE
7969 | OPTI_TYPE_EARLY_SKIP
7970 | OPTI_TYPE_NOT_ITERATED
7971 | OPTI_TYPE_APPENDED_SALT
7972 | OPTI_TYPE_RAW_HASH;
7973 dgst_pos0 = 3;
7974 dgst_pos1 = 4;
7975 dgst_pos2 = 2;
7976 dgst_pos3 = 1;
7977 break;
7978
7979 case 131: hash_type = HASH_TYPE_SHA1;
7980 salt_type = SALT_TYPE_EMBEDDED;
7981 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7982 opts_type = OPTS_TYPE_PT_GENERATE_BE
7983 | OPTS_TYPE_PT_UNICODE
7984 | OPTS_TYPE_PT_UPPER
7985 | OPTS_TYPE_ST_ADD80
7986 | OPTS_TYPE_ST_ADDBITS15
7987 | OPTS_TYPE_ST_HEX;
7988 kern_type = KERN_TYPE_SHA1_PWUSLT;
7989 dgst_size = DGST_SIZE_4_5;
7990 parse_func = mssql2000_parse_hash;
7991 sort_by_digest = sort_by_digest_4_5;
7992 opti_type = OPTI_TYPE_ZERO_BYTE
7993 | OPTI_TYPE_PRECOMPUTE_INIT
7994 | OPTI_TYPE_PRECOMPUTE_MERKLE
7995 | OPTI_TYPE_EARLY_SKIP
7996 | OPTI_TYPE_NOT_ITERATED
7997 | OPTI_TYPE_APPENDED_SALT
7998 | OPTI_TYPE_RAW_HASH;
7999 dgst_pos0 = 3;
8000 dgst_pos1 = 4;
8001 dgst_pos2 = 2;
8002 dgst_pos3 = 1;
8003 break;
8004
8005 case 132: hash_type = HASH_TYPE_SHA1;
8006 salt_type = SALT_TYPE_EMBEDDED;
8007 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8008 opts_type = OPTS_TYPE_PT_GENERATE_BE
8009 | OPTS_TYPE_PT_UNICODE
8010 | OPTS_TYPE_ST_ADD80
8011 | OPTS_TYPE_ST_ADDBITS15
8012 | OPTS_TYPE_ST_HEX;
8013 kern_type = KERN_TYPE_SHA1_PWUSLT;
8014 dgst_size = DGST_SIZE_4_5;
8015 parse_func = mssql2005_parse_hash;
8016 sort_by_digest = sort_by_digest_4_5;
8017 opti_type = OPTI_TYPE_ZERO_BYTE
8018 | OPTI_TYPE_PRECOMPUTE_INIT
8019 | OPTI_TYPE_PRECOMPUTE_MERKLE
8020 | OPTI_TYPE_EARLY_SKIP
8021 | OPTI_TYPE_NOT_ITERATED
8022 | OPTI_TYPE_APPENDED_SALT
8023 | OPTI_TYPE_RAW_HASH;
8024 dgst_pos0 = 3;
8025 dgst_pos1 = 4;
8026 dgst_pos2 = 2;
8027 dgst_pos3 = 1;
8028 break;
8029
8030 case 133: hash_type = HASH_TYPE_SHA1;
8031 salt_type = SALT_TYPE_EMBEDDED;
8032 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8033 opts_type = OPTS_TYPE_PT_GENERATE_BE
8034 | OPTS_TYPE_PT_UNICODE
8035 | OPTS_TYPE_ST_ADD80
8036 | OPTS_TYPE_ST_ADDBITS15;
8037 kern_type = KERN_TYPE_SHA1_PWUSLT;
8038 dgst_size = DGST_SIZE_4_5;
8039 parse_func = peoplesoft_parse_hash;
8040 sort_by_digest = sort_by_digest_4_5;
8041 opti_type = OPTI_TYPE_ZERO_BYTE
8042 | OPTI_TYPE_PRECOMPUTE_INIT
8043 | OPTI_TYPE_PRECOMPUTE_MERKLE
8044 | OPTI_TYPE_EARLY_SKIP
8045 | OPTI_TYPE_NOT_ITERATED
8046 | OPTI_TYPE_APPENDED_SALT
8047 | OPTI_TYPE_RAW_HASH;
8048 dgst_pos0 = 3;
8049 dgst_pos1 = 4;
8050 dgst_pos2 = 2;
8051 dgst_pos3 = 1;
8052 break;
8053
8054 case 140: hash_type = HASH_TYPE_SHA1;
8055 salt_type = SALT_TYPE_INTERN;
8056 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8057 opts_type = OPTS_TYPE_PT_GENERATE_BE
8058 | OPTS_TYPE_PT_ADD80
8059 | OPTS_TYPE_PT_ADDBITS15
8060 | OPTS_TYPE_PT_UNICODE;
8061 kern_type = KERN_TYPE_SHA1_SLTPWU;
8062 dgst_size = DGST_SIZE_4_5;
8063 parse_func = sha1s_parse_hash;
8064 sort_by_digest = sort_by_digest_4_5;
8065 opti_type = OPTI_TYPE_ZERO_BYTE
8066 | OPTI_TYPE_PRECOMPUTE_INIT
8067 | OPTI_TYPE_PRECOMPUTE_MERKLE
8068 | OPTI_TYPE_EARLY_SKIP
8069 | OPTI_TYPE_NOT_ITERATED
8070 | OPTI_TYPE_PREPENDED_SALT
8071 | OPTI_TYPE_RAW_HASH;
8072 dgst_pos0 = 3;
8073 dgst_pos1 = 4;
8074 dgst_pos2 = 2;
8075 dgst_pos3 = 1;
8076 break;
8077
8078 case 141: hash_type = HASH_TYPE_SHA1;
8079 salt_type = SALT_TYPE_EMBEDDED;
8080 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8081 opts_type = OPTS_TYPE_PT_GENERATE_BE
8082 | OPTS_TYPE_PT_ADD80
8083 | OPTS_TYPE_PT_ADDBITS15
8084 | OPTS_TYPE_PT_UNICODE
8085 | OPTS_TYPE_ST_BASE64;
8086 kern_type = KERN_TYPE_SHA1_SLTPWU;
8087 dgst_size = DGST_SIZE_4_5;
8088 parse_func = episerver_parse_hash;
8089 sort_by_digest = sort_by_digest_4_5;
8090 opti_type = OPTI_TYPE_ZERO_BYTE
8091 | OPTI_TYPE_PRECOMPUTE_INIT
8092 | OPTI_TYPE_PRECOMPUTE_MERKLE
8093 | OPTI_TYPE_EARLY_SKIP
8094 | OPTI_TYPE_NOT_ITERATED
8095 | OPTI_TYPE_PREPENDED_SALT
8096 | OPTI_TYPE_RAW_HASH;
8097 dgst_pos0 = 3;
8098 dgst_pos1 = 4;
8099 dgst_pos2 = 2;
8100 dgst_pos3 = 1;
8101 break;
8102
8103 case 150: hash_type = HASH_TYPE_SHA1;
8104 salt_type = SALT_TYPE_INTERN;
8105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8106 opts_type = OPTS_TYPE_PT_GENERATE_BE
8107 | OPTS_TYPE_ST_ADD80
8108 | OPTS_TYPE_ST_ADDBITS15;
8109 kern_type = KERN_TYPE_HMACSHA1_PW;
8110 dgst_size = DGST_SIZE_4_5;
8111 parse_func = hmacsha1_parse_hash;
8112 sort_by_digest = sort_by_digest_4_5;
8113 opti_type = OPTI_TYPE_ZERO_BYTE
8114 | OPTI_TYPE_NOT_ITERATED;
8115 dgst_pos0 = 3;
8116 dgst_pos1 = 4;
8117 dgst_pos2 = 2;
8118 dgst_pos3 = 1;
8119 break;
8120
8121 case 160: hash_type = HASH_TYPE_SHA1;
8122 salt_type = SALT_TYPE_INTERN;
8123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8124 opts_type = OPTS_TYPE_PT_GENERATE_BE
8125 | OPTS_TYPE_PT_ADD80
8126 | OPTS_TYPE_PT_ADDBITS15;
8127 kern_type = KERN_TYPE_HMACSHA1_SLT;
8128 dgst_size = DGST_SIZE_4_5;
8129 parse_func = hmacsha1_parse_hash;
8130 sort_by_digest = sort_by_digest_4_5;
8131 opti_type = OPTI_TYPE_ZERO_BYTE
8132 | OPTI_TYPE_NOT_ITERATED;
8133 dgst_pos0 = 3;
8134 dgst_pos1 = 4;
8135 dgst_pos2 = 2;
8136 dgst_pos3 = 1;
8137 break;
8138
8139 case 200: hash_type = HASH_TYPE_MYSQL;
8140 salt_type = SALT_TYPE_NONE;
8141 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8142 opts_type = 0;
8143 kern_type = KERN_TYPE_MYSQL;
8144 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8145 parse_func = mysql323_parse_hash;
8146 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8147 opti_type = OPTI_TYPE_ZERO_BYTE;
8148 dgst_pos0 = 0;
8149 dgst_pos1 = 1;
8150 dgst_pos2 = 2;
8151 dgst_pos3 = 3;
8152 break;
8153
8154 case 300: hash_type = HASH_TYPE_SHA1;
8155 salt_type = SALT_TYPE_NONE;
8156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8157 opts_type = OPTS_TYPE_PT_GENERATE_BE
8158 | OPTS_TYPE_PT_ADD80
8159 | OPTS_TYPE_PT_ADDBITS15;
8160 kern_type = KERN_TYPE_MYSQL41;
8161 dgst_size = DGST_SIZE_4_5;
8162 parse_func = sha1_parse_hash;
8163 sort_by_digest = sort_by_digest_4_5;
8164 opti_type = OPTI_TYPE_ZERO_BYTE
8165 | OPTI_TYPE_PRECOMPUTE_INIT
8166 | OPTI_TYPE_PRECOMPUTE_MERKLE
8167 | OPTI_TYPE_EARLY_SKIP
8168 | OPTI_TYPE_NOT_ITERATED
8169 | OPTI_TYPE_NOT_SALTED;
8170 dgst_pos0 = 3;
8171 dgst_pos1 = 4;
8172 dgst_pos2 = 2;
8173 dgst_pos3 = 1;
8174 break;
8175
8176 case 400: hash_type = HASH_TYPE_MD5;
8177 salt_type = SALT_TYPE_EMBEDDED;
8178 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8179 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8180 kern_type = KERN_TYPE_PHPASS;
8181 dgst_size = DGST_SIZE_4_4;
8182 parse_func = phpass_parse_hash;
8183 sort_by_digest = sort_by_digest_4_4;
8184 opti_type = OPTI_TYPE_ZERO_BYTE
8185 | OPTI_TYPE_SLOW_HASH_SIMD;
8186 dgst_pos0 = 0;
8187 dgst_pos1 = 1;
8188 dgst_pos2 = 2;
8189 dgst_pos3 = 3;
8190 break;
8191
8192 case 500: hash_type = HASH_TYPE_MD5;
8193 salt_type = SALT_TYPE_EMBEDDED;
8194 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8195 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8196 kern_type = KERN_TYPE_MD5CRYPT;
8197 dgst_size = DGST_SIZE_4_4;
8198 parse_func = md5crypt_parse_hash;
8199 sort_by_digest = sort_by_digest_4_4;
8200 opti_type = OPTI_TYPE_ZERO_BYTE;
8201 dgst_pos0 = 0;
8202 dgst_pos1 = 1;
8203 dgst_pos2 = 2;
8204 dgst_pos3 = 3;
8205 break;
8206
8207 case 501: hash_type = HASH_TYPE_MD5;
8208 salt_type = SALT_TYPE_EMBEDDED;
8209 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8210 opts_type = OPTS_TYPE_PT_GENERATE_LE
8211 | OPTS_TYPE_HASH_COPY;
8212 kern_type = KERN_TYPE_MD5CRYPT;
8213 dgst_size = DGST_SIZE_4_4;
8214 parse_func = juniper_parse_hash;
8215 sort_by_digest = sort_by_digest_4_4;
8216 opti_type = OPTI_TYPE_ZERO_BYTE;
8217 dgst_pos0 = 0;
8218 dgst_pos1 = 1;
8219 dgst_pos2 = 2;
8220 dgst_pos3 = 3;
8221 break;
8222
8223 case 900: hash_type = HASH_TYPE_MD4;
8224 salt_type = SALT_TYPE_NONE;
8225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8226 opts_type = OPTS_TYPE_PT_GENERATE_LE
8227 | OPTS_TYPE_PT_ADD80
8228 | OPTS_TYPE_PT_ADDBITS14;
8229 kern_type = KERN_TYPE_MD4;
8230 dgst_size = DGST_SIZE_4_4;
8231 parse_func = md4_parse_hash;
8232 sort_by_digest = sort_by_digest_4_4;
8233 opti_type = OPTI_TYPE_ZERO_BYTE
8234 | OPTI_TYPE_PRECOMPUTE_INIT
8235 | OPTI_TYPE_PRECOMPUTE_MERKLE
8236 | OPTI_TYPE_MEET_IN_MIDDLE
8237 | OPTI_TYPE_EARLY_SKIP
8238 | OPTI_TYPE_NOT_ITERATED
8239 | OPTI_TYPE_NOT_SALTED
8240 | OPTI_TYPE_RAW_HASH;
8241 dgst_pos0 = 0;
8242 dgst_pos1 = 3;
8243 dgst_pos2 = 2;
8244 dgst_pos3 = 1;
8245 break;
8246
8247 case 1000: hash_type = HASH_TYPE_MD4;
8248 salt_type = SALT_TYPE_NONE;
8249 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8250 opts_type = OPTS_TYPE_PT_GENERATE_LE
8251 | OPTS_TYPE_PT_ADD80
8252 | OPTS_TYPE_PT_ADDBITS14
8253 | OPTS_TYPE_PT_UNICODE;
8254 kern_type = KERN_TYPE_MD4_PWU;
8255 dgst_size = DGST_SIZE_4_4;
8256 parse_func = md4_parse_hash;
8257 sort_by_digest = sort_by_digest_4_4;
8258 opti_type = OPTI_TYPE_ZERO_BYTE
8259 | OPTI_TYPE_PRECOMPUTE_INIT
8260 | OPTI_TYPE_PRECOMPUTE_MERKLE
8261 | OPTI_TYPE_MEET_IN_MIDDLE
8262 | OPTI_TYPE_EARLY_SKIP
8263 | OPTI_TYPE_NOT_ITERATED
8264 | OPTI_TYPE_NOT_SALTED
8265 | OPTI_TYPE_RAW_HASH;
8266 dgst_pos0 = 0;
8267 dgst_pos1 = 3;
8268 dgst_pos2 = 2;
8269 dgst_pos3 = 1;
8270 break;
8271
8272 case 1100: hash_type = HASH_TYPE_MD4;
8273 salt_type = SALT_TYPE_INTERN;
8274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8275 opts_type = OPTS_TYPE_PT_GENERATE_LE
8276 | OPTS_TYPE_PT_ADD80
8277 | OPTS_TYPE_PT_ADDBITS14
8278 | OPTS_TYPE_PT_UNICODE
8279 | OPTS_TYPE_ST_ADD80
8280 | OPTS_TYPE_ST_UNICODE
8281 | OPTS_TYPE_ST_LOWER;
8282 kern_type = KERN_TYPE_MD44_PWUSLT;
8283 dgst_size = DGST_SIZE_4_4;
8284 parse_func = dcc_parse_hash;
8285 sort_by_digest = sort_by_digest_4_4;
8286 opti_type = OPTI_TYPE_ZERO_BYTE
8287 | OPTI_TYPE_PRECOMPUTE_INIT
8288 | OPTI_TYPE_PRECOMPUTE_MERKLE
8289 | OPTI_TYPE_EARLY_SKIP
8290 | OPTI_TYPE_NOT_ITERATED;
8291 dgst_pos0 = 0;
8292 dgst_pos1 = 3;
8293 dgst_pos2 = 2;
8294 dgst_pos3 = 1;
8295 break;
8296
8297 case 1400: hash_type = HASH_TYPE_SHA256;
8298 salt_type = SALT_TYPE_NONE;
8299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8300 opts_type = OPTS_TYPE_PT_GENERATE_BE
8301 | OPTS_TYPE_PT_ADD80
8302 | OPTS_TYPE_PT_ADDBITS15;
8303 kern_type = KERN_TYPE_SHA256;
8304 dgst_size = DGST_SIZE_4_8;
8305 parse_func = sha256_parse_hash;
8306 sort_by_digest = sort_by_digest_4_8;
8307 opti_type = OPTI_TYPE_ZERO_BYTE
8308 | OPTI_TYPE_PRECOMPUTE_INIT
8309 | OPTI_TYPE_PRECOMPUTE_MERKLE
8310 | OPTI_TYPE_EARLY_SKIP
8311 | OPTI_TYPE_NOT_ITERATED
8312 | OPTI_TYPE_NOT_SALTED
8313 | OPTI_TYPE_RAW_HASH;
8314 dgst_pos0 = 3;
8315 dgst_pos1 = 7;
8316 dgst_pos2 = 2;
8317 dgst_pos3 = 6;
8318 break;
8319
8320 case 1410: hash_type = HASH_TYPE_SHA256;
8321 salt_type = SALT_TYPE_INTERN;
8322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8323 opts_type = OPTS_TYPE_PT_GENERATE_BE
8324 | OPTS_TYPE_ST_ADD80
8325 | OPTS_TYPE_ST_ADDBITS15;
8326 kern_type = KERN_TYPE_SHA256_PWSLT;
8327 dgst_size = DGST_SIZE_4_8;
8328 parse_func = sha256s_parse_hash;
8329 sort_by_digest = sort_by_digest_4_8;
8330 opti_type = OPTI_TYPE_ZERO_BYTE
8331 | OPTI_TYPE_PRECOMPUTE_INIT
8332 | OPTI_TYPE_PRECOMPUTE_MERKLE
8333 | OPTI_TYPE_EARLY_SKIP
8334 | OPTI_TYPE_NOT_ITERATED
8335 | OPTI_TYPE_APPENDED_SALT
8336 | OPTI_TYPE_RAW_HASH;
8337 dgst_pos0 = 3;
8338 dgst_pos1 = 7;
8339 dgst_pos2 = 2;
8340 dgst_pos3 = 6;
8341 break;
8342
8343 case 1420: hash_type = HASH_TYPE_SHA256;
8344 salt_type = SALT_TYPE_INTERN;
8345 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8346 opts_type = OPTS_TYPE_PT_GENERATE_BE
8347 | OPTS_TYPE_PT_ADD80
8348 | OPTS_TYPE_PT_ADDBITS15;
8349 kern_type = KERN_TYPE_SHA256_SLTPW;
8350 dgst_size = DGST_SIZE_4_8;
8351 parse_func = sha256s_parse_hash;
8352 sort_by_digest = sort_by_digest_4_8;
8353 opti_type = OPTI_TYPE_ZERO_BYTE
8354 | OPTI_TYPE_PRECOMPUTE_INIT
8355 | OPTI_TYPE_PRECOMPUTE_MERKLE
8356 | OPTI_TYPE_EARLY_SKIP
8357 | OPTI_TYPE_NOT_ITERATED
8358 | OPTI_TYPE_PREPENDED_SALT
8359 | OPTI_TYPE_RAW_HASH;
8360 dgst_pos0 = 3;
8361 dgst_pos1 = 7;
8362 dgst_pos2 = 2;
8363 dgst_pos3 = 6;
8364 break;
8365
8366 case 1421: hash_type = HASH_TYPE_SHA256;
8367 salt_type = SALT_TYPE_EMBEDDED;
8368 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8369 opts_type = OPTS_TYPE_PT_GENERATE_BE
8370 | OPTS_TYPE_PT_ADD80
8371 | OPTS_TYPE_PT_ADDBITS15;
8372 kern_type = KERN_TYPE_SHA256_SLTPW;
8373 dgst_size = DGST_SIZE_4_8;
8374 parse_func = hmailserver_parse_hash;
8375 sort_by_digest = sort_by_digest_4_8;
8376 opti_type = OPTI_TYPE_ZERO_BYTE
8377 | OPTI_TYPE_PRECOMPUTE_INIT
8378 | OPTI_TYPE_PRECOMPUTE_MERKLE
8379 | OPTI_TYPE_EARLY_SKIP
8380 | OPTI_TYPE_NOT_ITERATED
8381 | OPTI_TYPE_PREPENDED_SALT
8382 | OPTI_TYPE_RAW_HASH;
8383 dgst_pos0 = 3;
8384 dgst_pos1 = 7;
8385 dgst_pos2 = 2;
8386 dgst_pos3 = 6;
8387 break;
8388
8389 case 1430: hash_type = HASH_TYPE_SHA256;
8390 salt_type = SALT_TYPE_INTERN;
8391 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8392 opts_type = OPTS_TYPE_PT_GENERATE_BE
8393 | OPTS_TYPE_PT_UNICODE
8394 | OPTS_TYPE_ST_ADD80
8395 | OPTS_TYPE_ST_ADDBITS15;
8396 kern_type = KERN_TYPE_SHA256_PWUSLT;
8397 dgst_size = DGST_SIZE_4_8;
8398 parse_func = sha256s_parse_hash;
8399 sort_by_digest = sort_by_digest_4_8;
8400 opti_type = OPTI_TYPE_ZERO_BYTE
8401 | OPTI_TYPE_PRECOMPUTE_INIT
8402 | OPTI_TYPE_PRECOMPUTE_MERKLE
8403 | OPTI_TYPE_EARLY_SKIP
8404 | OPTI_TYPE_NOT_ITERATED
8405 | OPTI_TYPE_APPENDED_SALT
8406 | OPTI_TYPE_RAW_HASH;
8407 dgst_pos0 = 3;
8408 dgst_pos1 = 7;
8409 dgst_pos2 = 2;
8410 dgst_pos3 = 6;
8411 break;
8412
8413 case 1440: hash_type = HASH_TYPE_SHA256;
8414 salt_type = SALT_TYPE_INTERN;
8415 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8416 opts_type = OPTS_TYPE_PT_GENERATE_BE
8417 | OPTS_TYPE_PT_ADD80
8418 | OPTS_TYPE_PT_ADDBITS15
8419 | OPTS_TYPE_PT_UNICODE;
8420 kern_type = KERN_TYPE_SHA256_SLTPWU;
8421 dgst_size = DGST_SIZE_4_8;
8422 parse_func = sha256s_parse_hash;
8423 sort_by_digest = sort_by_digest_4_8;
8424 opti_type = OPTI_TYPE_ZERO_BYTE
8425 | OPTI_TYPE_PRECOMPUTE_INIT
8426 | OPTI_TYPE_PRECOMPUTE_MERKLE
8427 | OPTI_TYPE_EARLY_SKIP
8428 | OPTI_TYPE_NOT_ITERATED
8429 | OPTI_TYPE_PREPENDED_SALT
8430 | OPTI_TYPE_RAW_HASH;
8431 dgst_pos0 = 3;
8432 dgst_pos1 = 7;
8433 dgst_pos2 = 2;
8434 dgst_pos3 = 6;
8435 break;
8436
8437 case 1441: hash_type = HASH_TYPE_SHA256;
8438 salt_type = SALT_TYPE_EMBEDDED;
8439 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8440 opts_type = OPTS_TYPE_PT_GENERATE_BE
8441 | OPTS_TYPE_PT_ADD80
8442 | OPTS_TYPE_PT_ADDBITS15
8443 | OPTS_TYPE_PT_UNICODE
8444 | OPTS_TYPE_ST_BASE64;
8445 kern_type = KERN_TYPE_SHA256_SLTPWU;
8446 dgst_size = DGST_SIZE_4_8;
8447 parse_func = episerver4_parse_hash;
8448 sort_by_digest = sort_by_digest_4_8;
8449 opti_type = OPTI_TYPE_ZERO_BYTE
8450 | OPTI_TYPE_PRECOMPUTE_INIT
8451 | OPTI_TYPE_PRECOMPUTE_MERKLE
8452 | OPTI_TYPE_EARLY_SKIP
8453 | OPTI_TYPE_NOT_ITERATED
8454 | OPTI_TYPE_PREPENDED_SALT
8455 | OPTI_TYPE_RAW_HASH;
8456 dgst_pos0 = 3;
8457 dgst_pos1 = 7;
8458 dgst_pos2 = 2;
8459 dgst_pos3 = 6;
8460 break;
8461
8462 case 1450: hash_type = HASH_TYPE_SHA256;
8463 salt_type = SALT_TYPE_INTERN;
8464 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8465 opts_type = OPTS_TYPE_PT_GENERATE_BE
8466 | OPTS_TYPE_ST_ADD80;
8467 kern_type = KERN_TYPE_HMACSHA256_PW;
8468 dgst_size = DGST_SIZE_4_8;
8469 parse_func = hmacsha256_parse_hash;
8470 sort_by_digest = sort_by_digest_4_8;
8471 opti_type = OPTI_TYPE_ZERO_BYTE
8472 | OPTI_TYPE_NOT_ITERATED;
8473 dgst_pos0 = 3;
8474 dgst_pos1 = 7;
8475 dgst_pos2 = 2;
8476 dgst_pos3 = 6;
8477 break;
8478
8479 case 1460: hash_type = HASH_TYPE_SHA256;
8480 salt_type = SALT_TYPE_INTERN;
8481 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8482 opts_type = OPTS_TYPE_PT_GENERATE_BE
8483 | OPTS_TYPE_PT_ADD80
8484 | OPTS_TYPE_PT_ADDBITS15;
8485 kern_type = KERN_TYPE_HMACSHA256_SLT;
8486 dgst_size = DGST_SIZE_4_8;
8487 parse_func = hmacsha256_parse_hash;
8488 sort_by_digest = sort_by_digest_4_8;
8489 opti_type = OPTI_TYPE_ZERO_BYTE
8490 | OPTI_TYPE_NOT_ITERATED;
8491 dgst_pos0 = 3;
8492 dgst_pos1 = 7;
8493 dgst_pos2 = 2;
8494 dgst_pos3 = 6;
8495 break;
8496
8497 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8498 salt_type = SALT_TYPE_EMBEDDED;
8499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8500 opts_type = OPTS_TYPE_PT_GENERATE_LE
8501 | OPTS_TYPE_PT_BITSLICE;
8502 kern_type = KERN_TYPE_DESCRYPT;
8503 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8504 parse_func = descrypt_parse_hash;
8505 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8506 opti_type = OPTI_TYPE_ZERO_BYTE
8507 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8508 dgst_pos0 = 0;
8509 dgst_pos1 = 1;
8510 dgst_pos2 = 2;
8511 dgst_pos3 = 3;
8512 break;
8513
8514 case 1600: hash_type = HASH_TYPE_MD5;
8515 salt_type = SALT_TYPE_EMBEDDED;
8516 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8517 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8518 kern_type = KERN_TYPE_APR1CRYPT;
8519 dgst_size = DGST_SIZE_4_4;
8520 parse_func = md5apr1_parse_hash;
8521 sort_by_digest = sort_by_digest_4_4;
8522 opti_type = OPTI_TYPE_ZERO_BYTE;
8523 dgst_pos0 = 0;
8524 dgst_pos1 = 1;
8525 dgst_pos2 = 2;
8526 dgst_pos3 = 3;
8527 break;
8528
8529 case 1700: hash_type = HASH_TYPE_SHA512;
8530 salt_type = SALT_TYPE_NONE;
8531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8532 opts_type = OPTS_TYPE_PT_GENERATE_BE
8533 | OPTS_TYPE_PT_ADD80
8534 | OPTS_TYPE_PT_ADDBITS15;
8535 kern_type = KERN_TYPE_SHA512;
8536 dgst_size = DGST_SIZE_8_8;
8537 parse_func = sha512_parse_hash;
8538 sort_by_digest = sort_by_digest_8_8;
8539 opti_type = OPTI_TYPE_ZERO_BYTE
8540 | OPTI_TYPE_PRECOMPUTE_INIT
8541 | OPTI_TYPE_PRECOMPUTE_MERKLE
8542 | OPTI_TYPE_EARLY_SKIP
8543 | OPTI_TYPE_NOT_ITERATED
8544 | OPTI_TYPE_NOT_SALTED
8545 | OPTI_TYPE_USES_BITS_64
8546 | OPTI_TYPE_RAW_HASH;
8547 dgst_pos0 = 14;
8548 dgst_pos1 = 15;
8549 dgst_pos2 = 6;
8550 dgst_pos3 = 7;
8551 break;
8552
8553 case 1710: hash_type = HASH_TYPE_SHA512;
8554 salt_type = SALT_TYPE_INTERN;
8555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8556 opts_type = OPTS_TYPE_PT_GENERATE_BE
8557 | OPTS_TYPE_ST_ADD80
8558 | OPTS_TYPE_ST_ADDBITS15;
8559 kern_type = KERN_TYPE_SHA512_PWSLT;
8560 dgst_size = DGST_SIZE_8_8;
8561 parse_func = sha512s_parse_hash;
8562 sort_by_digest = sort_by_digest_8_8;
8563 opti_type = OPTI_TYPE_ZERO_BYTE
8564 | OPTI_TYPE_PRECOMPUTE_INIT
8565 | OPTI_TYPE_PRECOMPUTE_MERKLE
8566 | OPTI_TYPE_EARLY_SKIP
8567 | OPTI_TYPE_NOT_ITERATED
8568 | OPTI_TYPE_APPENDED_SALT
8569 | OPTI_TYPE_USES_BITS_64
8570 | OPTI_TYPE_RAW_HASH;
8571 dgst_pos0 = 14;
8572 dgst_pos1 = 15;
8573 dgst_pos2 = 6;
8574 dgst_pos3 = 7;
8575 break;
8576
8577 case 1711: hash_type = HASH_TYPE_SHA512;
8578 salt_type = SALT_TYPE_EMBEDDED;
8579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8580 opts_type = OPTS_TYPE_PT_GENERATE_BE
8581 | OPTS_TYPE_ST_ADD80
8582 | OPTS_TYPE_ST_ADDBITS15;
8583 kern_type = KERN_TYPE_SHA512_PWSLT;
8584 dgst_size = DGST_SIZE_8_8;
8585 parse_func = sha512b64s_parse_hash;
8586 sort_by_digest = sort_by_digest_8_8;
8587 opti_type = OPTI_TYPE_ZERO_BYTE
8588 | OPTI_TYPE_PRECOMPUTE_INIT
8589 | OPTI_TYPE_PRECOMPUTE_MERKLE
8590 | OPTI_TYPE_EARLY_SKIP
8591 | OPTI_TYPE_NOT_ITERATED
8592 | OPTI_TYPE_APPENDED_SALT
8593 | OPTI_TYPE_USES_BITS_64
8594 | OPTI_TYPE_RAW_HASH;
8595 dgst_pos0 = 14;
8596 dgst_pos1 = 15;
8597 dgst_pos2 = 6;
8598 dgst_pos3 = 7;
8599 break;
8600
8601 case 1720: hash_type = HASH_TYPE_SHA512;
8602 salt_type = SALT_TYPE_INTERN;
8603 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8604 opts_type = OPTS_TYPE_PT_GENERATE_BE
8605 | OPTS_TYPE_PT_ADD80
8606 | OPTS_TYPE_PT_ADDBITS15;
8607 kern_type = KERN_TYPE_SHA512_SLTPW;
8608 dgst_size = DGST_SIZE_8_8;
8609 parse_func = sha512s_parse_hash;
8610 sort_by_digest = sort_by_digest_8_8;
8611 opti_type = OPTI_TYPE_ZERO_BYTE
8612 | OPTI_TYPE_PRECOMPUTE_INIT
8613 | OPTI_TYPE_PRECOMPUTE_MERKLE
8614 | OPTI_TYPE_EARLY_SKIP
8615 | OPTI_TYPE_NOT_ITERATED
8616 | OPTI_TYPE_PREPENDED_SALT
8617 | OPTI_TYPE_USES_BITS_64
8618 | OPTI_TYPE_RAW_HASH;
8619 dgst_pos0 = 14;
8620 dgst_pos1 = 15;
8621 dgst_pos2 = 6;
8622 dgst_pos3 = 7;
8623 break;
8624
8625 case 1722: hash_type = HASH_TYPE_SHA512;
8626 salt_type = SALT_TYPE_EMBEDDED;
8627 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8628 opts_type = OPTS_TYPE_PT_GENERATE_BE
8629 | OPTS_TYPE_PT_ADD80
8630 | OPTS_TYPE_PT_ADDBITS15
8631 | OPTS_TYPE_ST_HEX;
8632 kern_type = KERN_TYPE_SHA512_SLTPW;
8633 dgst_size = DGST_SIZE_8_8;
8634 parse_func = osx512_parse_hash;
8635 sort_by_digest = sort_by_digest_8_8;
8636 opti_type = OPTI_TYPE_ZERO_BYTE
8637 | OPTI_TYPE_PRECOMPUTE_INIT
8638 | OPTI_TYPE_PRECOMPUTE_MERKLE
8639 | OPTI_TYPE_EARLY_SKIP
8640 | OPTI_TYPE_NOT_ITERATED
8641 | OPTI_TYPE_PREPENDED_SALT
8642 | OPTI_TYPE_USES_BITS_64
8643 | OPTI_TYPE_RAW_HASH;
8644 dgst_pos0 = 14;
8645 dgst_pos1 = 15;
8646 dgst_pos2 = 6;
8647 dgst_pos3 = 7;
8648 break;
8649
8650 case 1730: hash_type = HASH_TYPE_SHA512;
8651 salt_type = SALT_TYPE_INTERN;
8652 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8653 opts_type = OPTS_TYPE_PT_GENERATE_BE
8654 | OPTS_TYPE_PT_UNICODE
8655 | OPTS_TYPE_ST_ADD80
8656 | OPTS_TYPE_ST_ADDBITS15;
8657 kern_type = KERN_TYPE_SHA512_PWSLTU;
8658 dgst_size = DGST_SIZE_8_8;
8659 parse_func = sha512s_parse_hash;
8660 sort_by_digest = sort_by_digest_8_8;
8661 opti_type = OPTI_TYPE_ZERO_BYTE
8662 | OPTI_TYPE_PRECOMPUTE_INIT
8663 | OPTI_TYPE_PRECOMPUTE_MERKLE
8664 | OPTI_TYPE_EARLY_SKIP
8665 | OPTI_TYPE_NOT_ITERATED
8666 | OPTI_TYPE_APPENDED_SALT
8667 | OPTI_TYPE_USES_BITS_64
8668 | OPTI_TYPE_RAW_HASH;
8669 dgst_pos0 = 14;
8670 dgst_pos1 = 15;
8671 dgst_pos2 = 6;
8672 dgst_pos3 = 7;
8673 break;
8674
8675 case 1731: hash_type = HASH_TYPE_SHA512;
8676 salt_type = SALT_TYPE_EMBEDDED;
8677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8678 opts_type = OPTS_TYPE_PT_GENERATE_BE
8679 | OPTS_TYPE_PT_UNICODE
8680 | OPTS_TYPE_ST_ADD80
8681 | OPTS_TYPE_ST_ADDBITS15
8682 | OPTS_TYPE_ST_HEX;
8683 kern_type = KERN_TYPE_SHA512_PWSLTU;
8684 dgst_size = DGST_SIZE_8_8;
8685 parse_func = mssql2012_parse_hash;
8686 sort_by_digest = sort_by_digest_8_8;
8687 opti_type = OPTI_TYPE_ZERO_BYTE
8688 | OPTI_TYPE_PRECOMPUTE_INIT
8689 | OPTI_TYPE_PRECOMPUTE_MERKLE
8690 | OPTI_TYPE_EARLY_SKIP
8691 | OPTI_TYPE_NOT_ITERATED
8692 | OPTI_TYPE_APPENDED_SALT
8693 | OPTI_TYPE_USES_BITS_64
8694 | OPTI_TYPE_RAW_HASH;
8695 dgst_pos0 = 14;
8696 dgst_pos1 = 15;
8697 dgst_pos2 = 6;
8698 dgst_pos3 = 7;
8699 break;
8700
8701 case 1740: hash_type = HASH_TYPE_SHA512;
8702 salt_type = SALT_TYPE_INTERN;
8703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8704 opts_type = OPTS_TYPE_PT_GENERATE_BE
8705 | OPTS_TYPE_PT_ADD80
8706 | OPTS_TYPE_PT_ADDBITS15
8707 | OPTS_TYPE_PT_UNICODE;
8708 kern_type = KERN_TYPE_SHA512_SLTPWU;
8709 dgst_size = DGST_SIZE_8_8;
8710 parse_func = sha512s_parse_hash;
8711 sort_by_digest = sort_by_digest_8_8;
8712 opti_type = OPTI_TYPE_ZERO_BYTE
8713 | OPTI_TYPE_PRECOMPUTE_INIT
8714 | OPTI_TYPE_PRECOMPUTE_MERKLE
8715 | OPTI_TYPE_EARLY_SKIP
8716 | OPTI_TYPE_NOT_ITERATED
8717 | OPTI_TYPE_PREPENDED_SALT
8718 | OPTI_TYPE_USES_BITS_64
8719 | OPTI_TYPE_RAW_HASH;
8720 dgst_pos0 = 14;
8721 dgst_pos1 = 15;
8722 dgst_pos2 = 6;
8723 dgst_pos3 = 7;
8724 break;
8725
8726 case 1750: hash_type = HASH_TYPE_SHA512;
8727 salt_type = SALT_TYPE_INTERN;
8728 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8729 opts_type = OPTS_TYPE_PT_GENERATE_BE
8730 | OPTS_TYPE_ST_ADD80;
8731 kern_type = KERN_TYPE_HMACSHA512_PW;
8732 dgst_size = DGST_SIZE_8_8;
8733 parse_func = hmacsha512_parse_hash;
8734 sort_by_digest = sort_by_digest_8_8;
8735 opti_type = OPTI_TYPE_ZERO_BYTE
8736 | OPTI_TYPE_USES_BITS_64
8737 | OPTI_TYPE_NOT_ITERATED;
8738 dgst_pos0 = 14;
8739 dgst_pos1 = 15;
8740 dgst_pos2 = 6;
8741 dgst_pos3 = 7;
8742 break;
8743
8744 case 1760: hash_type = HASH_TYPE_SHA512;
8745 salt_type = SALT_TYPE_INTERN;
8746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8747 opts_type = OPTS_TYPE_PT_GENERATE_BE
8748 | OPTS_TYPE_PT_ADD80
8749 | OPTS_TYPE_PT_ADDBITS15;
8750 kern_type = KERN_TYPE_HMACSHA512_SLT;
8751 dgst_size = DGST_SIZE_8_8;
8752 parse_func = hmacsha512_parse_hash;
8753 sort_by_digest = sort_by_digest_8_8;
8754 opti_type = OPTI_TYPE_ZERO_BYTE
8755 | OPTI_TYPE_USES_BITS_64
8756 | OPTI_TYPE_NOT_ITERATED;
8757 dgst_pos0 = 14;
8758 dgst_pos1 = 15;
8759 dgst_pos2 = 6;
8760 dgst_pos3 = 7;
8761 break;
8762
8763 case 1800: hash_type = HASH_TYPE_SHA512;
8764 salt_type = SALT_TYPE_EMBEDDED;
8765 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8766 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8767 kern_type = KERN_TYPE_SHA512CRYPT;
8768 dgst_size = DGST_SIZE_8_8;
8769 parse_func = sha512crypt_parse_hash;
8770 sort_by_digest = sort_by_digest_8_8;
8771 opti_type = OPTI_TYPE_ZERO_BYTE
8772 | OPTI_TYPE_USES_BITS_64;
8773 dgst_pos0 = 0;
8774 dgst_pos1 = 1;
8775 dgst_pos2 = 2;
8776 dgst_pos3 = 3;
8777 break;
8778
8779 case 2000: hash_type = HASH_TYPE_STDOUT;
8780 salt_type = SALT_TYPE_NONE;
8781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8782 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8783 kern_type = KERN_TYPE_STDOUT;
8784 dgst_size = DGST_SIZE_4_4;
8785 parse_func = NULL;
8786 sort_by_digest = NULL;
8787 opti_type = 0;
8788 dgst_pos0 = 0;
8789 dgst_pos1 = 0;
8790 dgst_pos2 = 0;
8791 dgst_pos3 = 0;
8792 break;
8793
8794 case 2100: hash_type = HASH_TYPE_DCC2;
8795 salt_type = SALT_TYPE_EMBEDDED;
8796 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8797 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8798 | OPTS_TYPE_ST_LOWER
8799 | OPTS_TYPE_ST_UNICODE;
8800 kern_type = KERN_TYPE_DCC2;
8801 dgst_size = DGST_SIZE_4_4;
8802 parse_func = dcc2_parse_hash;
8803 sort_by_digest = sort_by_digest_4_4;
8804 opti_type = OPTI_TYPE_ZERO_BYTE
8805 | OPTI_TYPE_SLOW_HASH_SIMD;
8806 dgst_pos0 = 0;
8807 dgst_pos1 = 1;
8808 dgst_pos2 = 2;
8809 dgst_pos3 = 3;
8810 break;
8811
8812 case 2400: hash_type = HASH_TYPE_MD5;
8813 salt_type = SALT_TYPE_NONE;
8814 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8815 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8816 kern_type = KERN_TYPE_MD5PIX;
8817 dgst_size = DGST_SIZE_4_4;
8818 parse_func = md5pix_parse_hash;
8819 sort_by_digest = sort_by_digest_4_4;
8820 opti_type = OPTI_TYPE_ZERO_BYTE
8821 | OPTI_TYPE_PRECOMPUTE_INIT
8822 | OPTI_TYPE_PRECOMPUTE_MERKLE
8823 | OPTI_TYPE_EARLY_SKIP
8824 | OPTI_TYPE_NOT_ITERATED
8825 | OPTI_TYPE_NOT_SALTED;
8826 dgst_pos0 = 0;
8827 dgst_pos1 = 3;
8828 dgst_pos2 = 2;
8829 dgst_pos3 = 1;
8830 break;
8831
8832 case 2410: hash_type = HASH_TYPE_MD5;
8833 salt_type = SALT_TYPE_INTERN;
8834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8835 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8836 kern_type = KERN_TYPE_MD5ASA;
8837 dgst_size = DGST_SIZE_4_4;
8838 parse_func = md5asa_parse_hash;
8839 sort_by_digest = sort_by_digest_4_4;
8840 opti_type = OPTI_TYPE_ZERO_BYTE
8841 | OPTI_TYPE_PRECOMPUTE_INIT
8842 | OPTI_TYPE_PRECOMPUTE_MERKLE
8843 | OPTI_TYPE_EARLY_SKIP
8844 | OPTI_TYPE_NOT_ITERATED;
8845 dgst_pos0 = 0;
8846 dgst_pos1 = 3;
8847 dgst_pos2 = 2;
8848 dgst_pos3 = 1;
8849 break;
8850
8851 case 2500: hash_type = HASH_TYPE_WPA;
8852 salt_type = SALT_TYPE_EMBEDDED;
8853 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8854 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8855 kern_type = KERN_TYPE_WPA;
8856 dgst_size = DGST_SIZE_4_4;
8857 parse_func = wpa_parse_hash;
8858 sort_by_digest = sort_by_digest_4_4;
8859 opti_type = OPTI_TYPE_ZERO_BYTE
8860 | OPTI_TYPE_SLOW_HASH_SIMD;
8861 dgst_pos0 = 0;
8862 dgst_pos1 = 1;
8863 dgst_pos2 = 2;
8864 dgst_pos3 = 3;
8865 break;
8866
8867 case 2600: hash_type = HASH_TYPE_MD5;
8868 salt_type = SALT_TYPE_VIRTUAL;
8869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8870 opts_type = OPTS_TYPE_PT_GENERATE_LE
8871 | OPTS_TYPE_PT_ADD80
8872 | OPTS_TYPE_PT_ADDBITS14
8873 | OPTS_TYPE_ST_ADD80;
8874 kern_type = KERN_TYPE_MD55_PWSLT1;
8875 dgst_size = DGST_SIZE_4_4;
8876 parse_func = md5md5_parse_hash;
8877 sort_by_digest = sort_by_digest_4_4;
8878 opti_type = OPTI_TYPE_ZERO_BYTE
8879 | OPTI_TYPE_PRECOMPUTE_INIT
8880 | OPTI_TYPE_PRECOMPUTE_MERKLE
8881 | OPTI_TYPE_EARLY_SKIP;
8882 dgst_pos0 = 0;
8883 dgst_pos1 = 3;
8884 dgst_pos2 = 2;
8885 dgst_pos3 = 1;
8886 break;
8887
8888 case 2611: hash_type = HASH_TYPE_MD5;
8889 salt_type = SALT_TYPE_INTERN;
8890 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8891 opts_type = OPTS_TYPE_PT_GENERATE_LE
8892 | OPTS_TYPE_PT_ADD80
8893 | OPTS_TYPE_PT_ADDBITS14
8894 | OPTS_TYPE_ST_ADD80;
8895 kern_type = KERN_TYPE_MD55_PWSLT1;
8896 dgst_size = DGST_SIZE_4_4;
8897 parse_func = vb3_parse_hash;
8898 sort_by_digest = sort_by_digest_4_4;
8899 opti_type = OPTI_TYPE_ZERO_BYTE
8900 | OPTI_TYPE_PRECOMPUTE_INIT
8901 | OPTI_TYPE_PRECOMPUTE_MERKLE
8902 | OPTI_TYPE_EARLY_SKIP;
8903 dgst_pos0 = 0;
8904 dgst_pos1 = 3;
8905 dgst_pos2 = 2;
8906 dgst_pos3 = 1;
8907 break;
8908
8909 case 2612: hash_type = HASH_TYPE_MD5;
8910 salt_type = SALT_TYPE_EMBEDDED;
8911 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8912 opts_type = OPTS_TYPE_PT_GENERATE_LE
8913 | OPTS_TYPE_PT_ADD80
8914 | OPTS_TYPE_PT_ADDBITS14
8915 | OPTS_TYPE_ST_ADD80
8916 | OPTS_TYPE_ST_HEX;
8917 kern_type = KERN_TYPE_MD55_PWSLT1;
8918 dgst_size = DGST_SIZE_4_4;
8919 parse_func = phps_parse_hash;
8920 sort_by_digest = sort_by_digest_4_4;
8921 opti_type = OPTI_TYPE_ZERO_BYTE
8922 | OPTI_TYPE_PRECOMPUTE_INIT
8923 | OPTI_TYPE_PRECOMPUTE_MERKLE
8924 | OPTI_TYPE_EARLY_SKIP;
8925 dgst_pos0 = 0;
8926 dgst_pos1 = 3;
8927 dgst_pos2 = 2;
8928 dgst_pos3 = 1;
8929 break;
8930
8931 case 2711: hash_type = HASH_TYPE_MD5;
8932 salt_type = SALT_TYPE_INTERN;
8933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8934 opts_type = OPTS_TYPE_PT_GENERATE_LE
8935 | OPTS_TYPE_PT_ADD80
8936 | OPTS_TYPE_PT_ADDBITS14
8937 | OPTS_TYPE_ST_ADD80;
8938 kern_type = KERN_TYPE_MD55_PWSLT2;
8939 dgst_size = DGST_SIZE_4_4;
8940 parse_func = vb30_parse_hash;
8941 sort_by_digest = sort_by_digest_4_4;
8942 opti_type = OPTI_TYPE_ZERO_BYTE
8943 | OPTI_TYPE_PRECOMPUTE_INIT
8944 | OPTI_TYPE_EARLY_SKIP;
8945 dgst_pos0 = 0;
8946 dgst_pos1 = 3;
8947 dgst_pos2 = 2;
8948 dgst_pos3 = 1;
8949 break;
8950
8951 case 2811: hash_type = HASH_TYPE_MD5;
8952 salt_type = SALT_TYPE_INTERN;
8953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8954 opts_type = OPTS_TYPE_PT_GENERATE_LE
8955 | OPTS_TYPE_PT_ADD80
8956 | OPTS_TYPE_PT_ADDBITS14;
8957 kern_type = KERN_TYPE_MD55_SLTPW;
8958 dgst_size = DGST_SIZE_4_4;
8959 parse_func = ipb2_parse_hash;
8960 sort_by_digest = sort_by_digest_4_4;
8961 opti_type = OPTI_TYPE_ZERO_BYTE
8962 | OPTI_TYPE_PRECOMPUTE_INIT
8963 | OPTI_TYPE_EARLY_SKIP;
8964 dgst_pos0 = 0;
8965 dgst_pos1 = 3;
8966 dgst_pos2 = 2;
8967 dgst_pos3 = 1;
8968 break;
8969
8970 case 3000: hash_type = HASH_TYPE_LM;
8971 salt_type = SALT_TYPE_NONE;
8972 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8973 opts_type = OPTS_TYPE_PT_GENERATE_LE
8974 | OPTS_TYPE_PT_UPPER
8975 | OPTS_TYPE_PT_BITSLICE;
8976 kern_type = KERN_TYPE_LM;
8977 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8978 parse_func = lm_parse_hash;
8979 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8980 opti_type = OPTI_TYPE_ZERO_BYTE
8981 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8982 dgst_pos0 = 0;
8983 dgst_pos1 = 1;
8984 dgst_pos2 = 2;
8985 dgst_pos3 = 3;
8986 break;
8987
8988 case 3100: hash_type = HASH_TYPE_ORACLEH;
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_UPPER
8993 | OPTS_TYPE_ST_UPPER;
8994 kern_type = KERN_TYPE_ORACLEH;
8995 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8996 parse_func = oracleh_parse_hash;
8997 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8998 opti_type = OPTI_TYPE_ZERO_BYTE;
8999 dgst_pos0 = 0;
9000 dgst_pos1 = 1;
9001 dgst_pos2 = 2;
9002 dgst_pos3 = 3;
9003 break;
9004
9005 case 3200: hash_type = HASH_TYPE_BCRYPT;
9006 salt_type = SALT_TYPE_EMBEDDED;
9007 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9008 opts_type = OPTS_TYPE_PT_GENERATE_LE
9009 | OPTS_TYPE_ST_GENERATE_LE;
9010 kern_type = KERN_TYPE_BCRYPT;
9011 dgst_size = DGST_SIZE_4_6;
9012 parse_func = bcrypt_parse_hash;
9013 sort_by_digest = sort_by_digest_4_6;
9014 opti_type = OPTI_TYPE_ZERO_BYTE;
9015 dgst_pos0 = 0;
9016 dgst_pos1 = 1;
9017 dgst_pos2 = 2;
9018 dgst_pos3 = 3;
9019 break;
9020
9021 case 3710: hash_type = HASH_TYPE_MD5;
9022 salt_type = SALT_TYPE_INTERN;
9023 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9024 opts_type = OPTS_TYPE_PT_GENERATE_LE
9025 | OPTS_TYPE_PT_ADD80
9026 | OPTS_TYPE_PT_ADDBITS14;
9027 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9028 dgst_size = DGST_SIZE_4_4;
9029 parse_func = md5s_parse_hash;
9030 sort_by_digest = sort_by_digest_4_4;
9031 opti_type = OPTI_TYPE_ZERO_BYTE
9032 | OPTI_TYPE_PRECOMPUTE_INIT
9033 | OPTI_TYPE_PRECOMPUTE_MERKLE
9034 | OPTI_TYPE_EARLY_SKIP;
9035 dgst_pos0 = 0;
9036 dgst_pos1 = 3;
9037 dgst_pos2 = 2;
9038 dgst_pos3 = 1;
9039 break;
9040
9041 case 3711: hash_type = HASH_TYPE_MD5;
9042 salt_type = SALT_TYPE_EMBEDDED;
9043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9044 opts_type = OPTS_TYPE_PT_GENERATE_LE
9045 | OPTS_TYPE_PT_ADD80
9046 | OPTS_TYPE_PT_ADDBITS14;
9047 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9048 dgst_size = DGST_SIZE_4_4;
9049 parse_func = mediawiki_b_parse_hash;
9050 sort_by_digest = sort_by_digest_4_4;
9051 opti_type = OPTI_TYPE_ZERO_BYTE
9052 | OPTI_TYPE_PRECOMPUTE_INIT
9053 | OPTI_TYPE_PRECOMPUTE_MERKLE
9054 | OPTI_TYPE_EARLY_SKIP;
9055 dgst_pos0 = 0;
9056 dgst_pos1 = 3;
9057 dgst_pos2 = 2;
9058 dgst_pos3 = 1;
9059 break;
9060
9061 case 3800: hash_type = HASH_TYPE_MD5;
9062 salt_type = SALT_TYPE_INTERN;
9063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9064 opts_type = OPTS_TYPE_PT_GENERATE_LE
9065 | OPTS_TYPE_ST_ADDBITS14;
9066 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9067 dgst_size = DGST_SIZE_4_4;
9068 parse_func = md5s_parse_hash;
9069 sort_by_digest = sort_by_digest_4_4;
9070 opti_type = OPTI_TYPE_ZERO_BYTE
9071 | OPTI_TYPE_PRECOMPUTE_INIT
9072 | OPTI_TYPE_PRECOMPUTE_MERKLE
9073 | OPTI_TYPE_EARLY_SKIP
9074 | OPTI_TYPE_NOT_ITERATED
9075 | OPTI_TYPE_RAW_HASH;
9076 dgst_pos0 = 0;
9077 dgst_pos1 = 3;
9078 dgst_pos2 = 2;
9079 dgst_pos3 = 1;
9080 break;
9081
9082 case 4300: hash_type = HASH_TYPE_MD5;
9083 salt_type = SALT_TYPE_VIRTUAL;
9084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9085 opts_type = OPTS_TYPE_PT_GENERATE_LE
9086 | OPTS_TYPE_PT_ADD80
9087 | OPTS_TYPE_PT_ADDBITS14
9088 | OPTS_TYPE_ST_ADD80;
9089 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9090 dgst_size = DGST_SIZE_4_4;
9091 parse_func = md5md5_parse_hash;
9092 sort_by_digest = sort_by_digest_4_4;
9093 opti_type = OPTI_TYPE_ZERO_BYTE
9094 | OPTI_TYPE_PRECOMPUTE_INIT
9095 | OPTI_TYPE_PRECOMPUTE_MERKLE
9096 | OPTI_TYPE_EARLY_SKIP;
9097 dgst_pos0 = 0;
9098 dgst_pos1 = 3;
9099 dgst_pos2 = 2;
9100 dgst_pos3 = 1;
9101 break;
9102
9103
9104 case 4400: hash_type = HASH_TYPE_MD5;
9105 salt_type = SALT_TYPE_NONE;
9106 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9107 opts_type = OPTS_TYPE_PT_GENERATE_BE
9108 | OPTS_TYPE_PT_ADD80
9109 | OPTS_TYPE_PT_ADDBITS15;
9110 kern_type = KERN_TYPE_MD5_SHA1;
9111 dgst_size = DGST_SIZE_4_4;
9112 parse_func = md5_parse_hash;
9113 sort_by_digest = sort_by_digest_4_4;
9114 opti_type = OPTI_TYPE_ZERO_BYTE
9115 | OPTI_TYPE_PRECOMPUTE_INIT
9116 | OPTI_TYPE_PRECOMPUTE_MERKLE
9117 | OPTI_TYPE_EARLY_SKIP
9118 | OPTI_TYPE_NOT_ITERATED
9119 | OPTI_TYPE_NOT_SALTED
9120 | OPTI_TYPE_RAW_HASH;
9121 dgst_pos0 = 0;
9122 dgst_pos1 = 3;
9123 dgst_pos2 = 2;
9124 dgst_pos3 = 1;
9125 break;
9126
9127 case 4500: hash_type = HASH_TYPE_SHA1;
9128 salt_type = SALT_TYPE_NONE;
9129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9130 opts_type = OPTS_TYPE_PT_GENERATE_BE
9131 | OPTS_TYPE_PT_ADD80
9132 | OPTS_TYPE_PT_ADDBITS15;
9133 kern_type = KERN_TYPE_SHA11;
9134 dgst_size = DGST_SIZE_4_5;
9135 parse_func = sha1_parse_hash;
9136 sort_by_digest = sort_by_digest_4_5;
9137 opti_type = OPTI_TYPE_ZERO_BYTE
9138 | OPTI_TYPE_PRECOMPUTE_INIT
9139 | OPTI_TYPE_PRECOMPUTE_MERKLE
9140 | OPTI_TYPE_EARLY_SKIP
9141 | OPTI_TYPE_NOT_SALTED;
9142 dgst_pos0 = 3;
9143 dgst_pos1 = 4;
9144 dgst_pos2 = 2;
9145 dgst_pos3 = 1;
9146 break;
9147
9148 case 4700: hash_type = HASH_TYPE_SHA1;
9149 salt_type = SALT_TYPE_NONE;
9150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9151 opts_type = OPTS_TYPE_PT_GENERATE_LE
9152 | OPTS_TYPE_PT_ADD80
9153 | OPTS_TYPE_PT_ADDBITS14;
9154 kern_type = KERN_TYPE_SHA1_MD5;
9155 dgst_size = DGST_SIZE_4_5;
9156 parse_func = sha1_parse_hash;
9157 sort_by_digest = sort_by_digest_4_5;
9158 opti_type = OPTI_TYPE_ZERO_BYTE
9159 | OPTI_TYPE_PRECOMPUTE_INIT
9160 | OPTI_TYPE_PRECOMPUTE_MERKLE
9161 | OPTI_TYPE_EARLY_SKIP
9162 | OPTI_TYPE_NOT_ITERATED
9163 | OPTI_TYPE_NOT_SALTED
9164 | OPTI_TYPE_RAW_HASH;
9165 dgst_pos0 = 3;
9166 dgst_pos1 = 4;
9167 dgst_pos2 = 2;
9168 dgst_pos3 = 1;
9169 break;
9170
9171 case 4800: hash_type = HASH_TYPE_MD5;
9172 salt_type = SALT_TYPE_EMBEDDED;
9173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9174 opts_type = OPTS_TYPE_PT_GENERATE_LE
9175 | OPTS_TYPE_PT_ADDBITS14;
9176 kern_type = KERN_TYPE_MD5_CHAP;
9177 dgst_size = DGST_SIZE_4_4;
9178 parse_func = chap_parse_hash;
9179 sort_by_digest = sort_by_digest_4_4;
9180 opti_type = OPTI_TYPE_ZERO_BYTE
9181 | OPTI_TYPE_PRECOMPUTE_INIT
9182 | OPTI_TYPE_PRECOMPUTE_MERKLE
9183 | OPTI_TYPE_MEET_IN_MIDDLE
9184 | OPTI_TYPE_EARLY_SKIP
9185 | OPTI_TYPE_NOT_ITERATED
9186 | OPTI_TYPE_RAW_HASH;
9187 dgst_pos0 = 0;
9188 dgst_pos1 = 3;
9189 dgst_pos2 = 2;
9190 dgst_pos3 = 1;
9191 break;
9192
9193 case 4900: hash_type = HASH_TYPE_SHA1;
9194 salt_type = SALT_TYPE_INTERN;
9195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9196 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9197 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9198 dgst_size = DGST_SIZE_4_5;
9199 parse_func = sha1s_parse_hash;
9200 sort_by_digest = sort_by_digest_4_5;
9201 opti_type = OPTI_TYPE_ZERO_BYTE
9202 | OPTI_TYPE_PRECOMPUTE_INIT
9203 | OPTI_TYPE_PRECOMPUTE_MERKLE
9204 | OPTI_TYPE_EARLY_SKIP;
9205 dgst_pos0 = 3;
9206 dgst_pos1 = 4;
9207 dgst_pos2 = 2;
9208 dgst_pos3 = 1;
9209 break;
9210
9211 case 5000: hash_type = HASH_TYPE_KECCAK;
9212 salt_type = SALT_TYPE_EMBEDDED;
9213 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9214 opts_type = OPTS_TYPE_PT_GENERATE_LE
9215 | OPTS_TYPE_PT_ADD01;
9216 kern_type = KERN_TYPE_KECCAK;
9217 dgst_size = DGST_SIZE_8_25;
9218 parse_func = keccak_parse_hash;
9219 sort_by_digest = sort_by_digest_8_25;
9220 opti_type = OPTI_TYPE_ZERO_BYTE
9221 | OPTI_TYPE_USES_BITS_64
9222 | OPTI_TYPE_RAW_HASH;
9223 dgst_pos0 = 2;
9224 dgst_pos1 = 3;
9225 dgst_pos2 = 4;
9226 dgst_pos3 = 5;
9227 break;
9228
9229 case 5100: hash_type = HASH_TYPE_MD5H;
9230 salt_type = SALT_TYPE_NONE;
9231 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9232 opts_type = OPTS_TYPE_PT_GENERATE_LE
9233 | OPTS_TYPE_PT_ADD80
9234 | OPTS_TYPE_PT_ADDBITS14;
9235 kern_type = KERN_TYPE_MD5H;
9236 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9237 parse_func = md5half_parse_hash;
9238 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9239 opti_type = OPTI_TYPE_ZERO_BYTE
9240 | OPTI_TYPE_RAW_HASH;
9241 dgst_pos0 = 0;
9242 dgst_pos1 = 1;
9243 dgst_pos2 = 2;
9244 dgst_pos3 = 3;
9245 break;
9246
9247 case 5200: hash_type = HASH_TYPE_SHA256;
9248 salt_type = SALT_TYPE_EMBEDDED;
9249 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9250 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9251 kern_type = KERN_TYPE_PSAFE3;
9252 dgst_size = DGST_SIZE_4_8;
9253 parse_func = psafe3_parse_hash;
9254 sort_by_digest = sort_by_digest_4_8;
9255 opti_type = OPTI_TYPE_ZERO_BYTE;
9256 dgst_pos0 = 0;
9257 dgst_pos1 = 1;
9258 dgst_pos2 = 2;
9259 dgst_pos3 = 3;
9260 break;
9261
9262 case 5300: hash_type = HASH_TYPE_MD5;
9263 salt_type = SALT_TYPE_EMBEDDED;
9264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9265 opts_type = OPTS_TYPE_PT_GENERATE_LE
9266 | OPTS_TYPE_ST_ADD80;
9267 kern_type = KERN_TYPE_IKEPSK_MD5;
9268 dgst_size = DGST_SIZE_4_4;
9269 parse_func = ikepsk_md5_parse_hash;
9270 sort_by_digest = sort_by_digest_4_4;
9271 opti_type = OPTI_TYPE_ZERO_BYTE;
9272 dgst_pos0 = 0;
9273 dgst_pos1 = 3;
9274 dgst_pos2 = 2;
9275 dgst_pos3 = 1;
9276 break;
9277
9278 case 5400: hash_type = HASH_TYPE_SHA1;
9279 salt_type = SALT_TYPE_EMBEDDED;
9280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9281 opts_type = OPTS_TYPE_PT_GENERATE_BE
9282 | OPTS_TYPE_ST_ADD80;
9283 kern_type = KERN_TYPE_IKEPSK_SHA1;
9284 dgst_size = DGST_SIZE_4_5;
9285 parse_func = ikepsk_sha1_parse_hash;
9286 sort_by_digest = sort_by_digest_4_5;
9287 opti_type = OPTI_TYPE_ZERO_BYTE;
9288 dgst_pos0 = 3;
9289 dgst_pos1 = 4;
9290 dgst_pos2 = 2;
9291 dgst_pos3 = 1;
9292 break;
9293
9294 case 5500: hash_type = HASH_TYPE_NETNTLM;
9295 salt_type = SALT_TYPE_EMBEDDED;
9296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9297 opts_type = OPTS_TYPE_PT_GENERATE_LE
9298 | OPTS_TYPE_PT_ADD80
9299 | OPTS_TYPE_PT_ADDBITS14
9300 | OPTS_TYPE_PT_UNICODE
9301 | OPTS_TYPE_ST_HEX;
9302 kern_type = KERN_TYPE_NETNTLMv1;
9303 dgst_size = DGST_SIZE_4_4;
9304 parse_func = netntlmv1_parse_hash;
9305 sort_by_digest = sort_by_digest_4_4;
9306 opti_type = OPTI_TYPE_ZERO_BYTE
9307 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9308 dgst_pos0 = 0;
9309 dgst_pos1 = 1;
9310 dgst_pos2 = 2;
9311 dgst_pos3 = 3;
9312 break;
9313
9314 case 5600: hash_type = HASH_TYPE_MD5;
9315 salt_type = SALT_TYPE_EMBEDDED;
9316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9317 opts_type = OPTS_TYPE_PT_GENERATE_LE
9318 | OPTS_TYPE_PT_ADD80
9319 | OPTS_TYPE_PT_ADDBITS14
9320 | OPTS_TYPE_PT_UNICODE;
9321 kern_type = KERN_TYPE_NETNTLMv2;
9322 dgst_size = DGST_SIZE_4_4;
9323 parse_func = netntlmv2_parse_hash;
9324 sort_by_digest = sort_by_digest_4_4;
9325 opti_type = OPTI_TYPE_ZERO_BYTE;
9326 dgst_pos0 = 0;
9327 dgst_pos1 = 3;
9328 dgst_pos2 = 2;
9329 dgst_pos3 = 1;
9330 break;
9331
9332 case 5700: hash_type = HASH_TYPE_SHA256;
9333 salt_type = SALT_TYPE_NONE;
9334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9335 opts_type = OPTS_TYPE_PT_GENERATE_BE
9336 | OPTS_TYPE_PT_ADD80
9337 | OPTS_TYPE_PT_ADDBITS15;
9338 kern_type = KERN_TYPE_SHA256;
9339 dgst_size = DGST_SIZE_4_8;
9340 parse_func = cisco4_parse_hash;
9341 sort_by_digest = sort_by_digest_4_8;
9342 opti_type = OPTI_TYPE_ZERO_BYTE
9343 | OPTI_TYPE_PRECOMPUTE_INIT
9344 | OPTI_TYPE_PRECOMPUTE_MERKLE
9345 | OPTI_TYPE_EARLY_SKIP
9346 | OPTI_TYPE_NOT_ITERATED
9347 | OPTI_TYPE_NOT_SALTED
9348 | OPTI_TYPE_RAW_HASH;
9349 dgst_pos0 = 3;
9350 dgst_pos1 = 7;
9351 dgst_pos2 = 2;
9352 dgst_pos3 = 6;
9353 break;
9354
9355 case 5800: hash_type = HASH_TYPE_SHA1;
9356 salt_type = SALT_TYPE_INTERN;
9357 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9358 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9359 | OPTS_TYPE_ST_ADD80;
9360 kern_type = KERN_TYPE_ANDROIDPIN;
9361 dgst_size = DGST_SIZE_4_5;
9362 parse_func = androidpin_parse_hash;
9363 sort_by_digest = sort_by_digest_4_5;
9364 opti_type = OPTI_TYPE_ZERO_BYTE;
9365 dgst_pos0 = 0;
9366 dgst_pos1 = 1;
9367 dgst_pos2 = 2;
9368 dgst_pos3 = 3;
9369 break;
9370
9371 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9372 salt_type = SALT_TYPE_NONE;
9373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9374 opts_type = OPTS_TYPE_PT_GENERATE_LE
9375 | OPTS_TYPE_PT_ADD80;
9376 kern_type = KERN_TYPE_RIPEMD160;
9377 dgst_size = DGST_SIZE_4_5;
9378 parse_func = ripemd160_parse_hash;
9379 sort_by_digest = sort_by_digest_4_5;
9380 opti_type = OPTI_TYPE_ZERO_BYTE;
9381 dgst_pos0 = 0;
9382 dgst_pos1 = 1;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 3;
9385 break;
9386
9387 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9388 salt_type = SALT_TYPE_NONE;
9389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9390 opts_type = OPTS_TYPE_PT_GENERATE_BE
9391 | OPTS_TYPE_PT_ADD80;
9392 kern_type = KERN_TYPE_WHIRLPOOL;
9393 dgst_size = DGST_SIZE_4_16;
9394 parse_func = whirlpool_parse_hash;
9395 sort_by_digest = sort_by_digest_4_16;
9396 opti_type = OPTI_TYPE_ZERO_BYTE;
9397 dgst_pos0 = 0;
9398 dgst_pos1 = 1;
9399 dgst_pos2 = 2;
9400 dgst_pos3 = 3;
9401 break;
9402
9403 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9404 salt_type = SALT_TYPE_EMBEDDED;
9405 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9406 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9407 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9408 dgst_size = DGST_SIZE_4_5;
9409 parse_func = truecrypt_parse_hash_2k;
9410 sort_by_digest = sort_by_digest_4_5;
9411 opti_type = OPTI_TYPE_ZERO_BYTE;
9412 dgst_pos0 = 0;
9413 dgst_pos1 = 1;
9414 dgst_pos2 = 2;
9415 dgst_pos3 = 3;
9416 break;
9417
9418 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9419 salt_type = SALT_TYPE_EMBEDDED;
9420 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9421 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9422 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9423 dgst_size = DGST_SIZE_4_5;
9424 parse_func = truecrypt_parse_hash_2k;
9425 sort_by_digest = sort_by_digest_4_5;
9426 opti_type = OPTI_TYPE_ZERO_BYTE;
9427 dgst_pos0 = 0;
9428 dgst_pos1 = 1;
9429 dgst_pos2 = 2;
9430 dgst_pos3 = 3;
9431 break;
9432
9433 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9434 salt_type = SALT_TYPE_EMBEDDED;
9435 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9436 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9437 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9438 dgst_size = DGST_SIZE_4_5;
9439 parse_func = truecrypt_parse_hash_2k;
9440 sort_by_digest = sort_by_digest_4_5;
9441 opti_type = OPTI_TYPE_ZERO_BYTE;
9442 dgst_pos0 = 0;
9443 dgst_pos1 = 1;
9444 dgst_pos2 = 2;
9445 dgst_pos3 = 3;
9446 break;
9447
9448 case 6221: hash_type = HASH_TYPE_SHA512;
9449 salt_type = SALT_TYPE_EMBEDDED;
9450 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9451 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9452 kern_type = KERN_TYPE_TCSHA512_XTS512;
9453 dgst_size = DGST_SIZE_8_8;
9454 parse_func = truecrypt_parse_hash_1k;
9455 sort_by_digest = sort_by_digest_8_8;
9456 opti_type = OPTI_TYPE_ZERO_BYTE
9457 | OPTI_TYPE_USES_BITS_64;
9458 dgst_pos0 = 0;
9459 dgst_pos1 = 1;
9460 dgst_pos2 = 2;
9461 dgst_pos3 = 3;
9462 break;
9463
9464 case 6222: hash_type = HASH_TYPE_SHA512;
9465 salt_type = SALT_TYPE_EMBEDDED;
9466 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9467 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9468 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9469 dgst_size = DGST_SIZE_8_8;
9470 parse_func = truecrypt_parse_hash_1k;
9471 sort_by_digest = sort_by_digest_8_8;
9472 opti_type = OPTI_TYPE_ZERO_BYTE
9473 | OPTI_TYPE_USES_BITS_64;
9474 dgst_pos0 = 0;
9475 dgst_pos1 = 1;
9476 dgst_pos2 = 2;
9477 dgst_pos3 = 3;
9478 break;
9479
9480 case 6223: hash_type = HASH_TYPE_SHA512;
9481 salt_type = SALT_TYPE_EMBEDDED;
9482 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9483 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9484 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9485 dgst_size = DGST_SIZE_8_8;
9486 parse_func = truecrypt_parse_hash_1k;
9487 sort_by_digest = sort_by_digest_8_8;
9488 opti_type = OPTI_TYPE_ZERO_BYTE
9489 | OPTI_TYPE_USES_BITS_64;
9490 dgst_pos0 = 0;
9491 dgst_pos1 = 1;
9492 dgst_pos2 = 2;
9493 dgst_pos3 = 3;
9494 break;
9495
9496 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9497 salt_type = SALT_TYPE_EMBEDDED;
9498 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9499 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9500 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9501 dgst_size = DGST_SIZE_4_8;
9502 parse_func = truecrypt_parse_hash_1k;
9503 sort_by_digest = sort_by_digest_4_8;
9504 opti_type = OPTI_TYPE_ZERO_BYTE;
9505 dgst_pos0 = 0;
9506 dgst_pos1 = 1;
9507 dgst_pos2 = 2;
9508 dgst_pos3 = 3;
9509 break;
9510
9511 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9512 salt_type = SALT_TYPE_EMBEDDED;
9513 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9514 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9515 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9516 dgst_size = DGST_SIZE_4_8;
9517 parse_func = truecrypt_parse_hash_1k;
9518 sort_by_digest = sort_by_digest_4_8;
9519 opti_type = OPTI_TYPE_ZERO_BYTE;
9520 dgst_pos0 = 0;
9521 dgst_pos1 = 1;
9522 dgst_pos2 = 2;
9523 dgst_pos3 = 3;
9524 break;
9525
9526 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9527 salt_type = SALT_TYPE_EMBEDDED;
9528 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9529 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9530 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9531 dgst_size = DGST_SIZE_4_8;
9532 parse_func = truecrypt_parse_hash_1k;
9533 sort_by_digest = sort_by_digest_4_8;
9534 opti_type = OPTI_TYPE_ZERO_BYTE;
9535 dgst_pos0 = 0;
9536 dgst_pos1 = 1;
9537 dgst_pos2 = 2;
9538 dgst_pos3 = 3;
9539 break;
9540
9541 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9542 salt_type = SALT_TYPE_EMBEDDED;
9543 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9544 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9545 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9546 dgst_size = DGST_SIZE_4_5;
9547 parse_func = truecrypt_parse_hash_1k;
9548 sort_by_digest = sort_by_digest_4_5;
9549 opti_type = OPTI_TYPE_ZERO_BYTE;
9550 dgst_pos0 = 0;
9551 dgst_pos1 = 1;
9552 dgst_pos2 = 2;
9553 dgst_pos3 = 3;
9554 break;
9555
9556 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9557 salt_type = SALT_TYPE_EMBEDDED;
9558 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9559 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9560 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9561 dgst_size = DGST_SIZE_4_5;
9562 parse_func = truecrypt_parse_hash_1k;
9563 sort_by_digest = sort_by_digest_4_5;
9564 opti_type = OPTI_TYPE_ZERO_BYTE;
9565 dgst_pos0 = 0;
9566 dgst_pos1 = 1;
9567 dgst_pos2 = 2;
9568 dgst_pos3 = 3;
9569 break;
9570
9571 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9572 salt_type = SALT_TYPE_EMBEDDED;
9573 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9574 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9575 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9576 dgst_size = DGST_SIZE_4_5;
9577 parse_func = truecrypt_parse_hash_1k;
9578 sort_by_digest = sort_by_digest_4_5;
9579 opti_type = OPTI_TYPE_ZERO_BYTE;
9580 dgst_pos0 = 0;
9581 dgst_pos1 = 1;
9582 dgst_pos2 = 2;
9583 dgst_pos3 = 3;
9584 break;
9585
9586 case 6300: hash_type = HASH_TYPE_MD5;
9587 salt_type = SALT_TYPE_EMBEDDED;
9588 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9589 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9590 kern_type = KERN_TYPE_MD5AIX;
9591 dgst_size = DGST_SIZE_4_4;
9592 parse_func = md5aix_parse_hash;
9593 sort_by_digest = sort_by_digest_4_4;
9594 opti_type = OPTI_TYPE_ZERO_BYTE;
9595 dgst_pos0 = 0;
9596 dgst_pos1 = 1;
9597 dgst_pos2 = 2;
9598 dgst_pos3 = 3;
9599 break;
9600
9601 case 6400: hash_type = HASH_TYPE_SHA256;
9602 salt_type = SALT_TYPE_EMBEDDED;
9603 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9604 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9605 kern_type = KERN_TYPE_SHA256AIX;
9606 dgst_size = DGST_SIZE_4_8;
9607 parse_func = sha256aix_parse_hash;
9608 sort_by_digest = sort_by_digest_4_8;
9609 opti_type = OPTI_TYPE_ZERO_BYTE;
9610 dgst_pos0 = 0;
9611 dgst_pos1 = 1;
9612 dgst_pos2 = 2;
9613 dgst_pos3 = 3;
9614 break;
9615
9616 case 6500: hash_type = HASH_TYPE_SHA512;
9617 salt_type = SALT_TYPE_EMBEDDED;
9618 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9619 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9620 kern_type = KERN_TYPE_SHA512AIX;
9621 dgst_size = DGST_SIZE_8_8;
9622 parse_func = sha512aix_parse_hash;
9623 sort_by_digest = sort_by_digest_8_8;
9624 opti_type = OPTI_TYPE_ZERO_BYTE
9625 | OPTI_TYPE_USES_BITS_64;
9626 dgst_pos0 = 0;
9627 dgst_pos1 = 1;
9628 dgst_pos2 = 2;
9629 dgst_pos3 = 3;
9630 break;
9631
9632 case 6600: hash_type = HASH_TYPE_AES;
9633 salt_type = SALT_TYPE_EMBEDDED;
9634 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9635 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9636 kern_type = KERN_TYPE_AGILEKEY;
9637 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9638 parse_func = agilekey_parse_hash;
9639 sort_by_digest = sort_by_digest_4_5;
9640 opti_type = OPTI_TYPE_ZERO_BYTE;
9641 dgst_pos0 = 0;
9642 dgst_pos1 = 1;
9643 dgst_pos2 = 2;
9644 dgst_pos3 = 3;
9645 break;
9646
9647 case 6700: hash_type = HASH_TYPE_SHA1;
9648 salt_type = SALT_TYPE_EMBEDDED;
9649 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9650 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9651 kern_type = KERN_TYPE_SHA1AIX;
9652 dgst_size = DGST_SIZE_4_5;
9653 parse_func = sha1aix_parse_hash;
9654 sort_by_digest = sort_by_digest_4_5;
9655 opti_type = OPTI_TYPE_ZERO_BYTE;
9656 dgst_pos0 = 0;
9657 dgst_pos1 = 1;
9658 dgst_pos2 = 2;
9659 dgst_pos3 = 3;
9660 break;
9661
9662 case 6800: hash_type = HASH_TYPE_AES;
9663 salt_type = SALT_TYPE_EMBEDDED;
9664 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9665 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9666 kern_type = KERN_TYPE_LASTPASS;
9667 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9668 parse_func = lastpass_parse_hash;
9669 sort_by_digest = sort_by_digest_4_8;
9670 opti_type = OPTI_TYPE_ZERO_BYTE;
9671 dgst_pos0 = 0;
9672 dgst_pos1 = 1;
9673 dgst_pos2 = 2;
9674 dgst_pos3 = 3;
9675 break;
9676
9677 case 6900: hash_type = HASH_TYPE_GOST;
9678 salt_type = SALT_TYPE_NONE;
9679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9680 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9681 kern_type = KERN_TYPE_GOST;
9682 dgst_size = DGST_SIZE_4_8;
9683 parse_func = gost_parse_hash;
9684 sort_by_digest = sort_by_digest_4_8;
9685 opti_type = OPTI_TYPE_ZERO_BYTE;
9686 dgst_pos0 = 0;
9687 dgst_pos1 = 1;
9688 dgst_pos2 = 2;
9689 dgst_pos3 = 3;
9690 break;
9691
9692 case 7100: hash_type = HASH_TYPE_SHA512;
9693 salt_type = SALT_TYPE_EMBEDDED;
9694 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9695 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9696 kern_type = KERN_TYPE_PBKDF2_SHA512;
9697 dgst_size = DGST_SIZE_8_16;
9698 parse_func = sha512osx_parse_hash;
9699 sort_by_digest = sort_by_digest_8_16;
9700 opti_type = OPTI_TYPE_ZERO_BYTE
9701 | OPTI_TYPE_USES_BITS_64
9702 | OPTI_TYPE_SLOW_HASH_SIMD;
9703 dgst_pos0 = 0;
9704 dgst_pos1 = 1;
9705 dgst_pos2 = 2;
9706 dgst_pos3 = 3;
9707 break;
9708
9709 case 7200: hash_type = HASH_TYPE_SHA512;
9710 salt_type = SALT_TYPE_EMBEDDED;
9711 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9712 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9713 kern_type = KERN_TYPE_PBKDF2_SHA512;
9714 dgst_size = DGST_SIZE_8_16;
9715 parse_func = sha512grub_parse_hash;
9716 sort_by_digest = sort_by_digest_8_16;
9717 opti_type = OPTI_TYPE_ZERO_BYTE
9718 | OPTI_TYPE_USES_BITS_64
9719 | OPTI_TYPE_SLOW_HASH_SIMD;
9720 dgst_pos0 = 0;
9721 dgst_pos1 = 1;
9722 dgst_pos2 = 2;
9723 dgst_pos3 = 3;
9724 break;
9725
9726 case 7300: hash_type = HASH_TYPE_SHA1;
9727 salt_type = SALT_TYPE_EMBEDDED;
9728 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9729 opts_type = OPTS_TYPE_PT_GENERATE_BE
9730 | OPTS_TYPE_ST_ADD80
9731 | OPTS_TYPE_ST_ADDBITS15;
9732 kern_type = KERN_TYPE_RAKP;
9733 dgst_size = DGST_SIZE_4_5;
9734 parse_func = rakp_parse_hash;
9735 sort_by_digest = sort_by_digest_4_5;
9736 opti_type = OPTI_TYPE_ZERO_BYTE
9737 | OPTI_TYPE_NOT_ITERATED;
9738 dgst_pos0 = 3;
9739 dgst_pos1 = 4;
9740 dgst_pos2 = 2;
9741 dgst_pos3 = 1;
9742 break;
9743
9744 case 7400: hash_type = HASH_TYPE_SHA256;
9745 salt_type = SALT_TYPE_EMBEDDED;
9746 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9747 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9748 kern_type = KERN_TYPE_SHA256CRYPT;
9749 dgst_size = DGST_SIZE_4_8;
9750 parse_func = sha256crypt_parse_hash;
9751 sort_by_digest = sort_by_digest_4_8;
9752 opti_type = OPTI_TYPE_ZERO_BYTE;
9753 dgst_pos0 = 0;
9754 dgst_pos1 = 1;
9755 dgst_pos2 = 2;
9756 dgst_pos3 = 3;
9757 break;
9758
9759 case 7500: hash_type = HASH_TYPE_KRB5PA;
9760 salt_type = SALT_TYPE_EMBEDDED;
9761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9762 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9763 kern_type = KERN_TYPE_KRB5PA;
9764 dgst_size = DGST_SIZE_4_4;
9765 parse_func = krb5pa_parse_hash;
9766 sort_by_digest = sort_by_digest_4_4;
9767 opti_type = OPTI_TYPE_ZERO_BYTE
9768 | OPTI_TYPE_NOT_ITERATED;
9769 dgst_pos0 = 0;
9770 dgst_pos1 = 1;
9771 dgst_pos2 = 2;
9772 dgst_pos3 = 3;
9773 break;
9774
9775 case 7600: hash_type = HASH_TYPE_SHA1;
9776 salt_type = SALT_TYPE_INTERN;
9777 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9778 opts_type = OPTS_TYPE_PT_GENERATE_BE
9779 | OPTS_TYPE_PT_ADD80
9780 | OPTS_TYPE_PT_ADDBITS15;
9781 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9782 dgst_size = DGST_SIZE_4_5;
9783 parse_func = redmine_parse_hash;
9784 sort_by_digest = sort_by_digest_4_5;
9785 opti_type = OPTI_TYPE_ZERO_BYTE
9786 | OPTI_TYPE_PRECOMPUTE_INIT
9787 | OPTI_TYPE_EARLY_SKIP
9788 | OPTI_TYPE_NOT_ITERATED
9789 | OPTI_TYPE_PREPENDED_SALT;
9790 dgst_pos0 = 3;
9791 dgst_pos1 = 4;
9792 dgst_pos2 = 2;
9793 dgst_pos3 = 1;
9794 break;
9795
9796 case 7700: hash_type = HASH_TYPE_SAPB;
9797 salt_type = SALT_TYPE_EMBEDDED;
9798 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9799 opts_type = OPTS_TYPE_PT_GENERATE_LE
9800 | OPTS_TYPE_PT_UPPER
9801 | OPTS_TYPE_ST_UPPER;
9802 kern_type = KERN_TYPE_SAPB;
9803 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9804 parse_func = sapb_parse_hash;
9805 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9806 opti_type = OPTI_TYPE_ZERO_BYTE
9807 | OPTI_TYPE_PRECOMPUTE_INIT
9808 | OPTI_TYPE_NOT_ITERATED;
9809 dgst_pos0 = 0;
9810 dgst_pos1 = 1;
9811 dgst_pos2 = 2;
9812 dgst_pos3 = 3;
9813 break;
9814
9815 case 7800: hash_type = HASH_TYPE_SAPG;
9816 salt_type = SALT_TYPE_EMBEDDED;
9817 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9818 opts_type = OPTS_TYPE_PT_GENERATE_BE
9819 | OPTS_TYPE_ST_ADD80
9820 | OPTS_TYPE_ST_UPPER;
9821 kern_type = KERN_TYPE_SAPG;
9822 dgst_size = DGST_SIZE_4_5;
9823 parse_func = sapg_parse_hash;
9824 sort_by_digest = sort_by_digest_4_5;
9825 opti_type = OPTI_TYPE_ZERO_BYTE
9826 | OPTI_TYPE_PRECOMPUTE_INIT
9827 | OPTI_TYPE_NOT_ITERATED;
9828 dgst_pos0 = 3;
9829 dgst_pos1 = 4;
9830 dgst_pos2 = 2;
9831 dgst_pos3 = 1;
9832 break;
9833
9834 case 7900: hash_type = HASH_TYPE_SHA512;
9835 salt_type = SALT_TYPE_EMBEDDED;
9836 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9837 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9838 kern_type = KERN_TYPE_DRUPAL7;
9839 dgst_size = DGST_SIZE_8_8;
9840 parse_func = drupal7_parse_hash;
9841 sort_by_digest = sort_by_digest_8_8;
9842 opti_type = OPTI_TYPE_ZERO_BYTE
9843 | OPTI_TYPE_USES_BITS_64;
9844 dgst_pos0 = 0;
9845 dgst_pos1 = 1;
9846 dgst_pos2 = 2;
9847 dgst_pos3 = 3;
9848 break;
9849
9850 case 8000: hash_type = HASH_TYPE_SHA256;
9851 salt_type = SALT_TYPE_EMBEDDED;
9852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9853 opts_type = OPTS_TYPE_PT_GENERATE_BE
9854 | OPTS_TYPE_PT_UNICODE
9855 | OPTS_TYPE_ST_ADD80
9856 | OPTS_TYPE_ST_HEX;
9857 kern_type = KERN_TYPE_SYBASEASE;
9858 dgst_size = DGST_SIZE_4_8;
9859 parse_func = sybasease_parse_hash;
9860 sort_by_digest = sort_by_digest_4_8;
9861 opti_type = OPTI_TYPE_ZERO_BYTE
9862 | OPTI_TYPE_PRECOMPUTE_INIT
9863 | OPTI_TYPE_EARLY_SKIP
9864 | OPTI_TYPE_NOT_ITERATED
9865 | OPTI_TYPE_RAW_HASH;
9866 dgst_pos0 = 3;
9867 dgst_pos1 = 7;
9868 dgst_pos2 = 2;
9869 dgst_pos3 = 6;
9870 break;
9871
9872 case 8100: hash_type = HASH_TYPE_SHA1;
9873 salt_type = SALT_TYPE_EMBEDDED;
9874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9875 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9876 kern_type = KERN_TYPE_NETSCALER;
9877 dgst_size = DGST_SIZE_4_5;
9878 parse_func = netscaler_parse_hash;
9879 sort_by_digest = sort_by_digest_4_5;
9880 opti_type = OPTI_TYPE_ZERO_BYTE
9881 | OPTI_TYPE_PRECOMPUTE_INIT
9882 | OPTI_TYPE_PRECOMPUTE_MERKLE
9883 | OPTI_TYPE_EARLY_SKIP
9884 | OPTI_TYPE_NOT_ITERATED
9885 | OPTI_TYPE_PREPENDED_SALT
9886 | OPTI_TYPE_RAW_HASH;
9887 dgst_pos0 = 3;
9888 dgst_pos1 = 4;
9889 dgst_pos2 = 2;
9890 dgst_pos3 = 1;
9891 break;
9892
9893 case 8200: hash_type = HASH_TYPE_SHA256;
9894 salt_type = SALT_TYPE_EMBEDDED;
9895 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9896 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9897 kern_type = KERN_TYPE_CLOUDKEY;
9898 dgst_size = DGST_SIZE_4_8;
9899 parse_func = cloudkey_parse_hash;
9900 sort_by_digest = sort_by_digest_4_8;
9901 opti_type = OPTI_TYPE_ZERO_BYTE;
9902 dgst_pos0 = 0;
9903 dgst_pos1 = 1;
9904 dgst_pos2 = 2;
9905 dgst_pos3 = 3;
9906 break;
9907
9908 case 8300: hash_type = HASH_TYPE_SHA1;
9909 salt_type = SALT_TYPE_EMBEDDED;
9910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9911 opts_type = OPTS_TYPE_PT_GENERATE_BE
9912 | OPTS_TYPE_ST_HEX
9913 | OPTS_TYPE_ST_ADD80;
9914 kern_type = KERN_TYPE_NSEC3;
9915 dgst_size = DGST_SIZE_4_5;
9916 parse_func = nsec3_parse_hash;
9917 sort_by_digest = sort_by_digest_4_5;
9918 opti_type = OPTI_TYPE_ZERO_BYTE;
9919 dgst_pos0 = 3;
9920 dgst_pos1 = 4;
9921 dgst_pos2 = 2;
9922 dgst_pos3 = 1;
9923 break;
9924
9925 case 8400: hash_type = HASH_TYPE_SHA1;
9926 salt_type = SALT_TYPE_INTERN;
9927 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9928 opts_type = OPTS_TYPE_PT_GENERATE_BE
9929 | OPTS_TYPE_PT_ADD80
9930 | OPTS_TYPE_PT_ADDBITS15;
9931 kern_type = KERN_TYPE_WBB3;
9932 dgst_size = DGST_SIZE_4_5;
9933 parse_func = wbb3_parse_hash;
9934 sort_by_digest = sort_by_digest_4_5;
9935 opti_type = OPTI_TYPE_ZERO_BYTE
9936 | OPTI_TYPE_PRECOMPUTE_INIT
9937 | OPTI_TYPE_NOT_ITERATED;
9938 dgst_pos0 = 3;
9939 dgst_pos1 = 4;
9940 dgst_pos2 = 2;
9941 dgst_pos3 = 1;
9942 break;
9943
9944 case 8500: hash_type = HASH_TYPE_DESRACF;
9945 salt_type = SALT_TYPE_EMBEDDED;
9946 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9947 opts_type = OPTS_TYPE_PT_GENERATE_LE
9948 | OPTS_TYPE_ST_UPPER;
9949 kern_type = KERN_TYPE_RACF;
9950 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9951 parse_func = racf_parse_hash;
9952 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9953 opti_type = OPTI_TYPE_ZERO_BYTE
9954 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9955 dgst_pos0 = 0;
9956 dgst_pos1 = 1;
9957 dgst_pos2 = 2;
9958 dgst_pos3 = 3;
9959 break;
9960
9961 case 8600: hash_type = HASH_TYPE_LOTUS5;
9962 salt_type = SALT_TYPE_NONE;
9963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9964 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9965 kern_type = KERN_TYPE_LOTUS5;
9966 dgst_size = DGST_SIZE_4_4;
9967 parse_func = lotus5_parse_hash;
9968 sort_by_digest = sort_by_digest_4_4;
9969 opti_type = OPTI_TYPE_EARLY_SKIP
9970 | OPTI_TYPE_NOT_ITERATED
9971 | OPTI_TYPE_NOT_SALTED
9972 | OPTI_TYPE_RAW_HASH;
9973 dgst_pos0 = 0;
9974 dgst_pos1 = 1;
9975 dgst_pos2 = 2;
9976 dgst_pos3 = 3;
9977 break;
9978
9979 case 8700: hash_type = HASH_TYPE_LOTUS6;
9980 salt_type = SALT_TYPE_EMBEDDED;
9981 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9982 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9983 kern_type = KERN_TYPE_LOTUS6;
9984 dgst_size = DGST_SIZE_4_4;
9985 parse_func = lotus6_parse_hash;
9986 sort_by_digest = sort_by_digest_4_4;
9987 opti_type = OPTI_TYPE_EARLY_SKIP
9988 | OPTI_TYPE_NOT_ITERATED
9989 | OPTI_TYPE_RAW_HASH;
9990 dgst_pos0 = 0;
9991 dgst_pos1 = 1;
9992 dgst_pos2 = 2;
9993 dgst_pos3 = 3;
9994 break;
9995
9996 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9997 salt_type = SALT_TYPE_EMBEDDED;
9998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9999 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10000 kern_type = KERN_TYPE_ANDROIDFDE;
10001 dgst_size = DGST_SIZE_4_4;
10002 parse_func = androidfde_parse_hash;
10003 sort_by_digest = sort_by_digest_4_4;
10004 opti_type = OPTI_TYPE_ZERO_BYTE;
10005 dgst_pos0 = 0;
10006 dgst_pos1 = 1;
10007 dgst_pos2 = 2;
10008 dgst_pos3 = 3;
10009 break;
10010
10011 case 8900: hash_type = HASH_TYPE_SCRYPT;
10012 salt_type = SALT_TYPE_EMBEDDED;
10013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10014 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10015 kern_type = KERN_TYPE_SCRYPT;
10016 dgst_size = DGST_SIZE_4_8;
10017 parse_func = scrypt_parse_hash;
10018 sort_by_digest = sort_by_digest_4_8;
10019 opti_type = OPTI_TYPE_ZERO_BYTE;
10020 dgst_pos0 = 0;
10021 dgst_pos1 = 1;
10022 dgst_pos2 = 2;
10023 dgst_pos3 = 3;
10024 break;
10025
10026 case 9000: hash_type = HASH_TYPE_SHA1;
10027 salt_type = SALT_TYPE_EMBEDDED;
10028 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10029 opts_type = OPTS_TYPE_PT_GENERATE_LE
10030 | OPTS_TYPE_ST_GENERATE_LE;
10031 kern_type = KERN_TYPE_PSAFE2;
10032 dgst_size = DGST_SIZE_4_5;
10033 parse_func = psafe2_parse_hash;
10034 sort_by_digest = sort_by_digest_4_5;
10035 opti_type = OPTI_TYPE_ZERO_BYTE;
10036 dgst_pos0 = 0;
10037 dgst_pos1 = 1;
10038 dgst_pos2 = 2;
10039 dgst_pos3 = 3;
10040 break;
10041
10042 case 9100: hash_type = HASH_TYPE_LOTUS8;
10043 salt_type = SALT_TYPE_EMBEDDED;
10044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10045 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10046 kern_type = KERN_TYPE_LOTUS8;
10047 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10048 parse_func = lotus8_parse_hash;
10049 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10050 opti_type = OPTI_TYPE_ZERO_BYTE;
10051 dgst_pos0 = 0;
10052 dgst_pos1 = 1;
10053 dgst_pos2 = 2;
10054 dgst_pos3 = 3;
10055 break;
10056
10057 case 9200: hash_type = HASH_TYPE_SHA256;
10058 salt_type = SALT_TYPE_EMBEDDED;
10059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10060 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10061 kern_type = KERN_TYPE_PBKDF2_SHA256;
10062 dgst_size = DGST_SIZE_4_32;
10063 parse_func = cisco8_parse_hash;
10064 sort_by_digest = sort_by_digest_4_32;
10065 opti_type = OPTI_TYPE_ZERO_BYTE
10066 | OPTI_TYPE_SLOW_HASH_SIMD;
10067 dgst_pos0 = 0;
10068 dgst_pos1 = 1;
10069 dgst_pos2 = 2;
10070 dgst_pos3 = 3;
10071 break;
10072
10073 case 9300: hash_type = HASH_TYPE_SCRYPT;
10074 salt_type = SALT_TYPE_EMBEDDED;
10075 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10076 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10077 kern_type = KERN_TYPE_SCRYPT;
10078 dgst_size = DGST_SIZE_4_8;
10079 parse_func = cisco9_parse_hash;
10080 sort_by_digest = sort_by_digest_4_8;
10081 opti_type = OPTI_TYPE_ZERO_BYTE;
10082 dgst_pos0 = 0;
10083 dgst_pos1 = 1;
10084 dgst_pos2 = 2;
10085 dgst_pos3 = 3;
10086 break;
10087
10088 case 9400: hash_type = HASH_TYPE_OFFICE2007;
10089 salt_type = SALT_TYPE_EMBEDDED;
10090 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10091 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10092 kern_type = KERN_TYPE_OFFICE2007;
10093 dgst_size = DGST_SIZE_4_4;
10094 parse_func = office2007_parse_hash;
10095 sort_by_digest = sort_by_digest_4_4;
10096 opti_type = OPTI_TYPE_ZERO_BYTE;
10097 dgst_pos0 = 0;
10098 dgst_pos1 = 1;
10099 dgst_pos2 = 2;
10100 dgst_pos3 = 3;
10101 break;
10102
10103 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10104 salt_type = SALT_TYPE_EMBEDDED;
10105 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10106 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10107 kern_type = KERN_TYPE_OFFICE2010;
10108 dgst_size = DGST_SIZE_4_4;
10109 parse_func = office2010_parse_hash;
10110 sort_by_digest = sort_by_digest_4_4;
10111 opti_type = OPTI_TYPE_ZERO_BYTE;
10112 dgst_pos0 = 0;
10113 dgst_pos1 = 1;
10114 dgst_pos2 = 2;
10115 dgst_pos3 = 3;
10116 break;
10117
10118 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10119 salt_type = SALT_TYPE_EMBEDDED;
10120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10121 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10122 kern_type = KERN_TYPE_OFFICE2013;
10123 dgst_size = DGST_SIZE_4_4;
10124 parse_func = office2013_parse_hash;
10125 sort_by_digest = sort_by_digest_4_4;
10126 opti_type = OPTI_TYPE_ZERO_BYTE;
10127 dgst_pos0 = 0;
10128 dgst_pos1 = 1;
10129 dgst_pos2 = 2;
10130 dgst_pos3 = 3;
10131 break;
10132
10133 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10134 salt_type = SALT_TYPE_EMBEDDED;
10135 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10136 opts_type = OPTS_TYPE_PT_GENERATE_LE
10137 | OPTS_TYPE_PT_ADD80
10138 | OPTS_TYPE_PT_UNICODE;
10139 kern_type = KERN_TYPE_OLDOFFICE01;
10140 dgst_size = DGST_SIZE_4_4;
10141 parse_func = oldoffice01_parse_hash;
10142 sort_by_digest = sort_by_digest_4_4;
10143 opti_type = OPTI_TYPE_ZERO_BYTE
10144 | OPTI_TYPE_PRECOMPUTE_INIT
10145 | OPTI_TYPE_NOT_ITERATED;
10146 dgst_pos0 = 0;
10147 dgst_pos1 = 1;
10148 dgst_pos2 = 2;
10149 dgst_pos3 = 3;
10150 break;
10151
10152 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10153 salt_type = SALT_TYPE_EMBEDDED;
10154 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10155 opts_type = OPTS_TYPE_PT_GENERATE_LE
10156 | OPTS_TYPE_PT_ADD80;
10157 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10158 dgst_size = DGST_SIZE_4_4;
10159 parse_func = oldoffice01cm1_parse_hash;
10160 sort_by_digest = sort_by_digest_4_4;
10161 opti_type = OPTI_TYPE_ZERO_BYTE
10162 | OPTI_TYPE_PRECOMPUTE_INIT
10163 | OPTI_TYPE_NOT_ITERATED;
10164 dgst_pos0 = 0;
10165 dgst_pos1 = 1;
10166 dgst_pos2 = 2;
10167 dgst_pos3 = 3;
10168 break;
10169
10170 case 9720: 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 | OPTS_TYPE_PT_NEVERCRACK;
10177 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10178 dgst_size = DGST_SIZE_4_4;
10179 parse_func = oldoffice01cm2_parse_hash;
10180 sort_by_digest = sort_by_digest_4_4;
10181 opti_type = OPTI_TYPE_ZERO_BYTE
10182 | OPTI_TYPE_PRECOMPUTE_INIT
10183 | OPTI_TYPE_NOT_ITERATED;
10184 dgst_pos0 = 0;
10185 dgst_pos1 = 1;
10186 dgst_pos2 = 2;
10187 dgst_pos3 = 3;
10188 break;
10189
10190 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10191 salt_type = SALT_TYPE_EMBEDDED;
10192 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10193 opts_type = OPTS_TYPE_PT_GENERATE_BE
10194 | OPTS_TYPE_PT_ADD80
10195 | OPTS_TYPE_PT_UNICODE;
10196 kern_type = KERN_TYPE_OLDOFFICE34;
10197 dgst_size = DGST_SIZE_4_4;
10198 parse_func = oldoffice34_parse_hash;
10199 sort_by_digest = sort_by_digest_4_4;
10200 opti_type = OPTI_TYPE_ZERO_BYTE
10201 | OPTI_TYPE_PRECOMPUTE_INIT
10202 | OPTI_TYPE_NOT_ITERATED;
10203 dgst_pos0 = 0;
10204 dgst_pos1 = 1;
10205 dgst_pos2 = 2;
10206 dgst_pos3 = 3;
10207 break;
10208
10209 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10210 salt_type = SALT_TYPE_EMBEDDED;
10211 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10212 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10213 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10214 dgst_size = DGST_SIZE_4_4;
10215 parse_func = oldoffice34cm1_parse_hash;
10216 sort_by_digest = sort_by_digest_4_4;
10217 opti_type = OPTI_TYPE_ZERO_BYTE
10218 | OPTI_TYPE_PRECOMPUTE_INIT
10219 | OPTI_TYPE_NOT_ITERATED;
10220 dgst_pos0 = 0;
10221 dgst_pos1 = 1;
10222 dgst_pos2 = 2;
10223 dgst_pos3 = 3;
10224 break;
10225
10226 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10227 salt_type = SALT_TYPE_EMBEDDED;
10228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10229 opts_type = OPTS_TYPE_PT_GENERATE_BE
10230 | OPTS_TYPE_PT_ADD80
10231 | OPTS_TYPE_PT_UNICODE
10232 | OPTS_TYPE_PT_NEVERCRACK;
10233 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10234 dgst_size = DGST_SIZE_4_4;
10235 parse_func = oldoffice34cm2_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 9900: hash_type = HASH_TYPE_MD5;
10247 salt_type = SALT_TYPE_NONE;
10248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10249 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10250 kern_type = KERN_TYPE_RADMIN2;
10251 dgst_size = DGST_SIZE_4_4;
10252 parse_func = radmin2_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_EARLY_SKIP
10257 | OPTI_TYPE_NOT_ITERATED
10258 | OPTI_TYPE_NOT_SALTED;
10259 dgst_pos0 = 0;
10260 dgst_pos1 = 3;
10261 dgst_pos2 = 2;
10262 dgst_pos3 = 1;
10263 break;
10264
10265 case 10000: hash_type = HASH_TYPE_SHA256;
10266 salt_type = SALT_TYPE_EMBEDDED;
10267 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10268 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10269 kern_type = KERN_TYPE_PBKDF2_SHA256;
10270 dgst_size = DGST_SIZE_4_32;
10271 parse_func = djangopbkdf2_parse_hash;
10272 sort_by_digest = sort_by_digest_4_32;
10273 opti_type = OPTI_TYPE_ZERO_BYTE
10274 | OPTI_TYPE_SLOW_HASH_SIMD;
10275 dgst_pos0 = 0;
10276 dgst_pos1 = 1;
10277 dgst_pos2 = 2;
10278 dgst_pos3 = 3;
10279 break;
10280
10281 case 10100: hash_type = HASH_TYPE_SIPHASH;
10282 salt_type = SALT_TYPE_EMBEDDED;
10283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10284 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10285 kern_type = KERN_TYPE_SIPHASH;
10286 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10287 parse_func = siphash_parse_hash;
10288 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10289 opti_type = OPTI_TYPE_ZERO_BYTE
10290 | OPTI_TYPE_NOT_ITERATED
10291 | OPTI_TYPE_RAW_HASH;
10292 dgst_pos0 = 0;
10293 dgst_pos1 = 1;
10294 dgst_pos2 = 2;
10295 dgst_pos3 = 3;
10296 break;
10297
10298 case 10200: hash_type = HASH_TYPE_MD5;
10299 salt_type = SALT_TYPE_EMBEDDED;
10300 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10301 opts_type = OPTS_TYPE_PT_GENERATE_LE
10302 | OPTS_TYPE_ST_ADD80
10303 | OPTS_TYPE_ST_ADDBITS14;
10304 kern_type = KERN_TYPE_HMACMD5_PW;
10305 dgst_size = DGST_SIZE_4_4;
10306 parse_func = crammd5_parse_hash;
10307 sort_by_digest = sort_by_digest_4_4;
10308 opti_type = OPTI_TYPE_ZERO_BYTE
10309 | OPTI_TYPE_NOT_ITERATED;
10310 dgst_pos0 = 0;
10311 dgst_pos1 = 3;
10312 dgst_pos2 = 2;
10313 dgst_pos3 = 1;
10314 break;
10315
10316 case 10300: hash_type = HASH_TYPE_SHA1;
10317 salt_type = SALT_TYPE_EMBEDDED;
10318 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10319 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10320 kern_type = KERN_TYPE_SAPH_SHA1;
10321 dgst_size = DGST_SIZE_4_5;
10322 parse_func = saph_sha1_parse_hash;
10323 sort_by_digest = sort_by_digest_4_5;
10324 opti_type = OPTI_TYPE_ZERO_BYTE;
10325 dgst_pos0 = 0;
10326 dgst_pos1 = 1;
10327 dgst_pos2 = 2;
10328 dgst_pos3 = 3;
10329 break;
10330
10331 case 10400: hash_type = HASH_TYPE_PDFU16;
10332 salt_type = SALT_TYPE_EMBEDDED;
10333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10334 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10335 kern_type = KERN_TYPE_PDF11;
10336 dgst_size = DGST_SIZE_4_4;
10337 parse_func = pdf11_parse_hash;
10338 sort_by_digest = sort_by_digest_4_4;
10339 opti_type = OPTI_TYPE_ZERO_BYTE
10340 | OPTI_TYPE_NOT_ITERATED;
10341 dgst_pos0 = 0;
10342 dgst_pos1 = 1;
10343 dgst_pos2 = 2;
10344 dgst_pos3 = 3;
10345 break;
10346
10347 case 10410: hash_type = HASH_TYPE_PDFU16;
10348 salt_type = SALT_TYPE_EMBEDDED;
10349 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10350 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10351 kern_type = KERN_TYPE_PDF11CM1;
10352 dgst_size = DGST_SIZE_4_4;
10353 parse_func = pdf11cm1_parse_hash;
10354 sort_by_digest = sort_by_digest_4_4;
10355 opti_type = OPTI_TYPE_ZERO_BYTE
10356 | OPTI_TYPE_NOT_ITERATED;
10357 dgst_pos0 = 0;
10358 dgst_pos1 = 1;
10359 dgst_pos2 = 2;
10360 dgst_pos3 = 3;
10361 break;
10362
10363 case 10420: hash_type = HASH_TYPE_PDFU16;
10364 salt_type = SALT_TYPE_EMBEDDED;
10365 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10366 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10367 kern_type = KERN_TYPE_PDF11CM2;
10368 dgst_size = DGST_SIZE_4_4;
10369 parse_func = pdf11cm2_parse_hash;
10370 sort_by_digest = sort_by_digest_4_4;
10371 opti_type = OPTI_TYPE_ZERO_BYTE
10372 | OPTI_TYPE_NOT_ITERATED;
10373 dgst_pos0 = 0;
10374 dgst_pos1 = 1;
10375 dgst_pos2 = 2;
10376 dgst_pos3 = 3;
10377 break;
10378
10379 case 10500: hash_type = HASH_TYPE_PDFU16;
10380 salt_type = SALT_TYPE_EMBEDDED;
10381 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10382 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10383 kern_type = KERN_TYPE_PDF14;
10384 dgst_size = DGST_SIZE_4_4;
10385 parse_func = pdf14_parse_hash;
10386 sort_by_digest = sort_by_digest_4_4;
10387 opti_type = OPTI_TYPE_ZERO_BYTE
10388 | OPTI_TYPE_NOT_ITERATED;
10389 dgst_pos0 = 0;
10390 dgst_pos1 = 1;
10391 dgst_pos2 = 2;
10392 dgst_pos3 = 3;
10393 break;
10394
10395 case 10600: hash_type = HASH_TYPE_SHA256;
10396 salt_type = SALT_TYPE_EMBEDDED;
10397 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10398 opts_type = OPTS_TYPE_PT_GENERATE_BE
10399 | OPTS_TYPE_ST_ADD80
10400 | OPTS_TYPE_ST_ADDBITS15
10401 | OPTS_TYPE_HASH_COPY;
10402 kern_type = KERN_TYPE_SHA256_PWSLT;
10403 dgst_size = DGST_SIZE_4_8;
10404 parse_func = pdf17l3_parse_hash;
10405 sort_by_digest = sort_by_digest_4_8;
10406 opti_type = OPTI_TYPE_ZERO_BYTE
10407 | OPTI_TYPE_PRECOMPUTE_INIT
10408 | OPTI_TYPE_PRECOMPUTE_MERKLE
10409 | OPTI_TYPE_EARLY_SKIP
10410 | OPTI_TYPE_NOT_ITERATED
10411 | OPTI_TYPE_APPENDED_SALT
10412 | OPTI_TYPE_RAW_HASH;
10413 dgst_pos0 = 3;
10414 dgst_pos1 = 7;
10415 dgst_pos2 = 2;
10416 dgst_pos3 = 6;
10417 break;
10418
10419 case 10700: hash_type = HASH_TYPE_PDFU32;
10420 salt_type = SALT_TYPE_EMBEDDED;
10421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10422 opts_type = OPTS_TYPE_PT_GENERATE_LE
10423 | OPTS_TYPE_HASH_COPY;
10424 kern_type = KERN_TYPE_PDF17L8;
10425 dgst_size = DGST_SIZE_4_8;
10426 parse_func = pdf17l8_parse_hash;
10427 sort_by_digest = sort_by_digest_4_8;
10428 opti_type = OPTI_TYPE_ZERO_BYTE
10429 | OPTI_TYPE_NOT_ITERATED;
10430 dgst_pos0 = 0;
10431 dgst_pos1 = 1;
10432 dgst_pos2 = 2;
10433 dgst_pos3 = 3;
10434 break;
10435
10436 case 10800: hash_type = HASH_TYPE_SHA384;
10437 salt_type = SALT_TYPE_NONE;
10438 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10439 opts_type = OPTS_TYPE_PT_GENERATE_BE
10440 | OPTS_TYPE_PT_ADD80
10441 | OPTS_TYPE_PT_ADDBITS15;
10442 kern_type = KERN_TYPE_SHA384;
10443 dgst_size = DGST_SIZE_8_8;
10444 parse_func = sha384_parse_hash;
10445 sort_by_digest = sort_by_digest_8_8;
10446 opti_type = OPTI_TYPE_ZERO_BYTE
10447 | OPTI_TYPE_PRECOMPUTE_INIT
10448 | OPTI_TYPE_PRECOMPUTE_MERKLE
10449 | OPTI_TYPE_EARLY_SKIP
10450 | OPTI_TYPE_NOT_ITERATED
10451 | OPTI_TYPE_NOT_SALTED
10452 | OPTI_TYPE_USES_BITS_64
10453 | OPTI_TYPE_RAW_HASH;
10454 dgst_pos0 = 6;
10455 dgst_pos1 = 7;
10456 dgst_pos2 = 4;
10457 dgst_pos3 = 5;
10458 break;
10459
10460 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10461 salt_type = SALT_TYPE_EMBEDDED;
10462 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10463 opts_type = OPTS_TYPE_PT_GENERATE_LE
10464 | OPTS_TYPE_ST_BASE64
10465 | OPTS_TYPE_HASH_COPY;
10466 kern_type = KERN_TYPE_PBKDF2_SHA256;
10467 dgst_size = DGST_SIZE_4_32;
10468 parse_func = pbkdf2_sha256_parse_hash;
10469 sort_by_digest = sort_by_digest_4_32;
10470 opti_type = OPTI_TYPE_ZERO_BYTE
10471 | OPTI_TYPE_SLOW_HASH_SIMD;
10472 dgst_pos0 = 0;
10473 dgst_pos1 = 1;
10474 dgst_pos2 = 2;
10475 dgst_pos3 = 3;
10476 break;
10477
10478 case 11000: hash_type = HASH_TYPE_MD5;
10479 salt_type = SALT_TYPE_INTERN;
10480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10481 opts_type = OPTS_TYPE_PT_GENERATE_LE
10482 | OPTS_TYPE_PT_ADD80;
10483 kern_type = KERN_TYPE_PRESTASHOP;
10484 dgst_size = DGST_SIZE_4_4;
10485 parse_func = prestashop_parse_hash;
10486 sort_by_digest = sort_by_digest_4_4;
10487 opti_type = OPTI_TYPE_ZERO_BYTE
10488 | OPTI_TYPE_PRECOMPUTE_INIT
10489 | OPTI_TYPE_NOT_ITERATED
10490 | OPTI_TYPE_PREPENDED_SALT;
10491 dgst_pos0 = 0;
10492 dgst_pos1 = 3;
10493 dgst_pos2 = 2;
10494 dgst_pos3 = 1;
10495 break;
10496
10497 case 11100: hash_type = HASH_TYPE_MD5;
10498 salt_type = SALT_TYPE_EMBEDDED;
10499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10500 opts_type = OPTS_TYPE_PT_GENERATE_LE
10501 | OPTS_TYPE_ST_ADD80;
10502 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10503 dgst_size = DGST_SIZE_4_4;
10504 parse_func = postgresql_auth_parse_hash;
10505 sort_by_digest = sort_by_digest_4_4;
10506 opti_type = OPTI_TYPE_ZERO_BYTE
10507 | OPTI_TYPE_PRECOMPUTE_INIT
10508 | OPTI_TYPE_PRECOMPUTE_MERKLE
10509 | OPTI_TYPE_EARLY_SKIP;
10510 dgst_pos0 = 0;
10511 dgst_pos1 = 3;
10512 dgst_pos2 = 2;
10513 dgst_pos3 = 1;
10514 break;
10515
10516 case 11200: hash_type = HASH_TYPE_SHA1;
10517 salt_type = SALT_TYPE_EMBEDDED;
10518 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10519 opts_type = OPTS_TYPE_PT_GENERATE_BE
10520 | OPTS_TYPE_PT_ADD80
10521 | OPTS_TYPE_ST_HEX;
10522 kern_type = KERN_TYPE_MYSQL_AUTH;
10523 dgst_size = DGST_SIZE_4_5;
10524 parse_func = mysql_auth_parse_hash;
10525 sort_by_digest = sort_by_digest_4_5;
10526 opti_type = OPTI_TYPE_ZERO_BYTE
10527 | OPTI_TYPE_EARLY_SKIP;
10528 dgst_pos0 = 3;
10529 dgst_pos1 = 4;
10530 dgst_pos2 = 2;
10531 dgst_pos3 = 1;
10532 break;
10533
10534 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10535 salt_type = SALT_TYPE_EMBEDDED;
10536 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10537 opts_type = OPTS_TYPE_PT_GENERATE_LE
10538 | OPTS_TYPE_ST_HEX
10539 | OPTS_TYPE_ST_ADD80;
10540 kern_type = KERN_TYPE_BITCOIN_WALLET;
10541 dgst_size = DGST_SIZE_4_4;
10542 parse_func = bitcoin_wallet_parse_hash;
10543 sort_by_digest = sort_by_digest_4_4;
10544 opti_type = OPTI_TYPE_ZERO_BYTE;
10545 dgst_pos0 = 0;
10546 dgst_pos1 = 1;
10547 dgst_pos2 = 2;
10548 dgst_pos3 = 3;
10549 break;
10550
10551 case 11400: hash_type = HASH_TYPE_MD5;
10552 salt_type = SALT_TYPE_EMBEDDED;
10553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10554 opts_type = OPTS_TYPE_PT_GENERATE_LE
10555 | OPTS_TYPE_PT_ADD80
10556 | OPTS_TYPE_HASH_COPY;
10557 kern_type = KERN_TYPE_SIP_AUTH;
10558 dgst_size = DGST_SIZE_4_4;
10559 parse_func = sip_auth_parse_hash;
10560 sort_by_digest = sort_by_digest_4_4;
10561 opti_type = OPTI_TYPE_ZERO_BYTE;
10562 dgst_pos0 = 0;
10563 dgst_pos1 = 3;
10564 dgst_pos2 = 2;
10565 dgst_pos3 = 1;
10566 break;
10567
10568 case 11500: hash_type = HASH_TYPE_CRC32;
10569 salt_type = SALT_TYPE_INTERN;
10570 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10571 opts_type = OPTS_TYPE_PT_GENERATE_LE
10572 | OPTS_TYPE_ST_GENERATE_LE
10573 | OPTS_TYPE_ST_HEX;
10574 kern_type = KERN_TYPE_CRC32;
10575 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10576 parse_func = crc32_parse_hash;
10577 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10578 opti_type = OPTI_TYPE_ZERO_BYTE;
10579 dgst_pos0 = 0;
10580 dgst_pos1 = 1;
10581 dgst_pos2 = 2;
10582 dgst_pos3 = 3;
10583 break;
10584
10585 case 11600: hash_type = HASH_TYPE_AES;
10586 salt_type = SALT_TYPE_EMBEDDED;
10587 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10588 opts_type = OPTS_TYPE_PT_GENERATE_LE
10589 | OPTS_TYPE_PT_NEVERCRACK;
10590 kern_type = KERN_TYPE_SEVEN_ZIP;
10591 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10592 parse_func = seven_zip_parse_hash;
10593 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10594 opti_type = OPTI_TYPE_ZERO_BYTE;
10595 dgst_pos0 = 0;
10596 dgst_pos1 = 1;
10597 dgst_pos2 = 2;
10598 dgst_pos3 = 3;
10599 break;
10600
10601 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10602 salt_type = SALT_TYPE_NONE;
10603 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10604 opts_type = OPTS_TYPE_PT_GENERATE_LE
10605 | OPTS_TYPE_PT_ADD01;
10606 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10607 dgst_size = DGST_SIZE_4_8;
10608 parse_func = gost2012sbog_256_parse_hash;
10609 sort_by_digest = sort_by_digest_4_8;
10610 opti_type = OPTI_TYPE_ZERO_BYTE;
10611 dgst_pos0 = 0;
10612 dgst_pos1 = 1;
10613 dgst_pos2 = 2;
10614 dgst_pos3 = 3;
10615 break;
10616
10617 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10618 salt_type = SALT_TYPE_NONE;
10619 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10620 opts_type = OPTS_TYPE_PT_GENERATE_LE
10621 | OPTS_TYPE_PT_ADD01;
10622 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10623 dgst_size = DGST_SIZE_4_16;
10624 parse_func = gost2012sbog_512_parse_hash;
10625 sort_by_digest = sort_by_digest_4_16;
10626 opti_type = OPTI_TYPE_ZERO_BYTE;
10627 dgst_pos0 = 0;
10628 dgst_pos1 = 1;
10629 dgst_pos2 = 2;
10630 dgst_pos3 = 3;
10631 break;
10632
10633 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10634 salt_type = SALT_TYPE_EMBEDDED;
10635 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10636 opts_type = OPTS_TYPE_PT_GENERATE_LE
10637 | OPTS_TYPE_ST_BASE64
10638 | OPTS_TYPE_HASH_COPY;
10639 kern_type = KERN_TYPE_PBKDF2_MD5;
10640 dgst_size = DGST_SIZE_4_32;
10641 parse_func = pbkdf2_md5_parse_hash;
10642 sort_by_digest = sort_by_digest_4_32;
10643 opti_type = OPTI_TYPE_ZERO_BYTE
10644 | OPTI_TYPE_SLOW_HASH_SIMD;
10645 dgst_pos0 = 0;
10646 dgst_pos1 = 1;
10647 dgst_pos2 = 2;
10648 dgst_pos3 = 3;
10649 break;
10650
10651 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10652 salt_type = SALT_TYPE_EMBEDDED;
10653 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10654 opts_type = OPTS_TYPE_PT_GENERATE_LE
10655 | OPTS_TYPE_ST_BASE64
10656 | OPTS_TYPE_HASH_COPY;
10657 kern_type = KERN_TYPE_PBKDF2_SHA1;
10658 dgst_size = DGST_SIZE_4_32;
10659 parse_func = pbkdf2_sha1_parse_hash;
10660 sort_by_digest = sort_by_digest_4_32;
10661 opti_type = OPTI_TYPE_ZERO_BYTE
10662 | OPTI_TYPE_SLOW_HASH_SIMD;
10663 dgst_pos0 = 0;
10664 dgst_pos1 = 1;
10665 dgst_pos2 = 2;
10666 dgst_pos3 = 3;
10667 break;
10668
10669 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10670 salt_type = SALT_TYPE_EMBEDDED;
10671 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10672 opts_type = OPTS_TYPE_PT_GENERATE_LE
10673 | OPTS_TYPE_ST_BASE64
10674 | OPTS_TYPE_HASH_COPY;
10675 kern_type = KERN_TYPE_PBKDF2_SHA512;
10676 dgst_size = DGST_SIZE_8_16;
10677 parse_func = pbkdf2_sha512_parse_hash;
10678 sort_by_digest = sort_by_digest_8_16;
10679 opti_type = OPTI_TYPE_ZERO_BYTE
10680 | OPTI_TYPE_USES_BITS_64
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 12200: hash_type = HASH_TYPE_ECRYPTFS;
10689 salt_type = SALT_TYPE_EMBEDDED;
10690 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10691 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10692 kern_type = KERN_TYPE_ECRYPTFS;
10693 dgst_size = DGST_SIZE_8_8;
10694 parse_func = ecryptfs_parse_hash;
10695 sort_by_digest = sort_by_digest_8_8;
10696 opti_type = OPTI_TYPE_ZERO_BYTE
10697 | OPTI_TYPE_USES_BITS_64;
10698 dgst_pos0 = 0;
10699 dgst_pos1 = 1;
10700 dgst_pos2 = 2;
10701 dgst_pos3 = 3;
10702 break;
10703
10704 case 12300: hash_type = HASH_TYPE_ORACLET;
10705 salt_type = SALT_TYPE_EMBEDDED;
10706 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10707 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10708 kern_type = KERN_TYPE_ORACLET;
10709 dgst_size = DGST_SIZE_8_16;
10710 parse_func = oraclet_parse_hash;
10711 sort_by_digest = sort_by_digest_8_16;
10712 opti_type = OPTI_TYPE_ZERO_BYTE
10713 | OPTI_TYPE_USES_BITS_64;
10714 dgst_pos0 = 0;
10715 dgst_pos1 = 1;
10716 dgst_pos2 = 2;
10717 dgst_pos3 = 3;
10718 break;
10719
10720 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10721 salt_type = SALT_TYPE_EMBEDDED;
10722 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10723 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10724 kern_type = KERN_TYPE_BSDICRYPT;
10725 dgst_size = DGST_SIZE_4_4;
10726 parse_func = bsdicrypt_parse_hash;
10727 sort_by_digest = sort_by_digest_4_4;
10728 opti_type = OPTI_TYPE_ZERO_BYTE
10729 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10730 dgst_pos0 = 0;
10731 dgst_pos1 = 1;
10732 dgst_pos2 = 2;
10733 dgst_pos3 = 3;
10734 break;
10735
10736 case 12500: hash_type = HASH_TYPE_RAR3HP;
10737 salt_type = SALT_TYPE_EMBEDDED;
10738 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10739 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10740 kern_type = KERN_TYPE_RAR3;
10741 dgst_size = DGST_SIZE_4_4;
10742 parse_func = rar3hp_parse_hash;
10743 sort_by_digest = sort_by_digest_4_4;
10744 opti_type = OPTI_TYPE_ZERO_BYTE;
10745 dgst_pos0 = 0;
10746 dgst_pos1 = 1;
10747 dgst_pos2 = 2;
10748 dgst_pos3 = 3;
10749 break;
10750
10751 case 12600: hash_type = HASH_TYPE_SHA256;
10752 salt_type = SALT_TYPE_INTERN;
10753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10754 opts_type = OPTS_TYPE_PT_GENERATE_BE
10755 | OPTS_TYPE_PT_ADD80;
10756 kern_type = KERN_TYPE_CF10;
10757 dgst_size = DGST_SIZE_4_8;
10758 parse_func = cf10_parse_hash;
10759 sort_by_digest = sort_by_digest_4_8;
10760 opti_type = OPTI_TYPE_ZERO_BYTE
10761 | OPTI_TYPE_PRECOMPUTE_INIT
10762 | OPTI_TYPE_EARLY_SKIP
10763 | OPTI_TYPE_NOT_ITERATED;
10764 dgst_pos0 = 3;
10765 dgst_pos1 = 7;
10766 dgst_pos2 = 2;
10767 dgst_pos3 = 6;
10768 break;
10769
10770 case 12700: hash_type = HASH_TYPE_AES;
10771 salt_type = SALT_TYPE_EMBEDDED;
10772 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10773 opts_type = OPTS_TYPE_PT_GENERATE_LE
10774 | OPTS_TYPE_HASH_COPY;
10775 kern_type = KERN_TYPE_MYWALLET;
10776 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10777 parse_func = mywallet_parse_hash;
10778 sort_by_digest = sort_by_digest_4_5;
10779 opti_type = OPTI_TYPE_ZERO_BYTE;
10780 dgst_pos0 = 0;
10781 dgst_pos1 = 1;
10782 dgst_pos2 = 2;
10783 dgst_pos3 = 3;
10784 break;
10785
10786 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10787 salt_type = SALT_TYPE_EMBEDDED;
10788 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10789 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10790 kern_type = KERN_TYPE_MS_DRSR;
10791 dgst_size = DGST_SIZE_4_8;
10792 parse_func = ms_drsr_parse_hash;
10793 sort_by_digest = sort_by_digest_4_8;
10794 opti_type = OPTI_TYPE_ZERO_BYTE;
10795 dgst_pos0 = 0;
10796 dgst_pos1 = 1;
10797 dgst_pos2 = 2;
10798 dgst_pos3 = 3;
10799 break;
10800
10801 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10802 salt_type = SALT_TYPE_EMBEDDED;
10803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10804 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10805 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10806 dgst_size = DGST_SIZE_4_8;
10807 parse_func = androidfde_samsung_parse_hash;
10808 sort_by_digest = sort_by_digest_4_8;
10809 opti_type = OPTI_TYPE_ZERO_BYTE;
10810 dgst_pos0 = 0;
10811 dgst_pos1 = 1;
10812 dgst_pos2 = 2;
10813 dgst_pos3 = 3;
10814 break;
10815
10816 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10817 salt_type = SALT_TYPE_EMBEDDED;
10818 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10819 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10820 kern_type = KERN_TYPE_RAR5;
10821 dgst_size = DGST_SIZE_4_4;
10822 parse_func = rar5_parse_hash;
10823 sort_by_digest = sort_by_digest_4_4;
10824 opti_type = OPTI_TYPE_ZERO_BYTE;
10825 dgst_pos0 = 0;
10826 dgst_pos1 = 1;
10827 dgst_pos2 = 2;
10828 dgst_pos3 = 3;
10829 break;
10830
10831 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10832 salt_type = SALT_TYPE_EMBEDDED;
10833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10834 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10835 kern_type = KERN_TYPE_KRB5TGS;
10836 dgst_size = DGST_SIZE_4_4;
10837 parse_func = krb5tgs_parse_hash;
10838 sort_by_digest = sort_by_digest_4_4;
10839 opti_type = OPTI_TYPE_ZERO_BYTE
10840 | OPTI_TYPE_NOT_ITERATED;
10841 dgst_pos0 = 0;
10842 dgst_pos1 = 1;
10843 dgst_pos2 = 2;
10844 dgst_pos3 = 3;
10845 break;
10846
10847 case 13200: hash_type = HASH_TYPE_AES;
10848 salt_type = SALT_TYPE_EMBEDDED;
10849 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10850 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10851 kern_type = KERN_TYPE_AXCRYPT;
10852 dgst_size = DGST_SIZE_4_4;
10853 parse_func = axcrypt_parse_hash;
10854 sort_by_digest = sort_by_digest_4_4;
10855 opti_type = OPTI_TYPE_ZERO_BYTE;
10856 dgst_pos0 = 0;
10857 dgst_pos1 = 1;
10858 dgst_pos2 = 2;
10859 dgst_pos3 = 3;
10860 break;
10861
10862 case 13300: hash_type = HASH_TYPE_SHA1;
10863 salt_type = SALT_TYPE_NONE;
10864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10865 opts_type = OPTS_TYPE_PT_GENERATE_BE
10866 | OPTS_TYPE_PT_ADD80
10867 | OPTS_TYPE_PT_ADDBITS15;
10868 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10869 dgst_size = DGST_SIZE_4_5;
10870 parse_func = sha1axcrypt_parse_hash;
10871 sort_by_digest = sort_by_digest_4_5;
10872 opti_type = OPTI_TYPE_ZERO_BYTE
10873 | OPTI_TYPE_PRECOMPUTE_INIT
10874 | OPTI_TYPE_EARLY_SKIP
10875 | OPTI_TYPE_NOT_ITERATED
10876 | OPTI_TYPE_NOT_SALTED;
10877 dgst_pos0 = 0;
10878 dgst_pos1 = 4;
10879 dgst_pos2 = 3;
10880 dgst_pos3 = 2;
10881 break;
10882
10883 case 13400: hash_type = HASH_TYPE_AES;
10884 salt_type = SALT_TYPE_EMBEDDED;
10885 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10886 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10887 kern_type = KERN_TYPE_KEEPASS;
10888 dgst_size = DGST_SIZE_4_4;
10889 parse_func = keepass_parse_hash;
10890 sort_by_digest = sort_by_digest_4_4;
10891 opti_type = OPTI_TYPE_ZERO_BYTE;
10892 dgst_pos0 = 0;
10893 dgst_pos1 = 1;
10894 dgst_pos2 = 2;
10895 dgst_pos3 = 3;
10896 break;
10897
10898 case 13500: hash_type = HASH_TYPE_SHA1;
10899 salt_type = SALT_TYPE_EMBEDDED;
10900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10901 opts_type = OPTS_TYPE_PT_GENERATE_BE
10902 | OPTS_TYPE_PT_UNICODE
10903 | OPTS_TYPE_PT_ADD80;
10904 kern_type = KERN_TYPE_PSTOKEN;
10905 dgst_size = DGST_SIZE_4_5;
10906 parse_func = pstoken_parse_hash;
10907 sort_by_digest = sort_by_digest_4_5;
10908 opti_type = OPTI_TYPE_ZERO_BYTE
10909 | OPTI_TYPE_PRECOMPUTE_INIT
10910 | OPTI_TYPE_EARLY_SKIP
10911 | OPTI_TYPE_NOT_ITERATED
10912 | OPTI_TYPE_PREPENDED_SALT
10913 | OPTI_TYPE_RAW_HASH;
10914 dgst_pos0 = 3;
10915 dgst_pos1 = 4;
10916 dgst_pos2 = 2;
10917 dgst_pos3 = 1;
10918 break;
10919
10920 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
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_ZIP2;
10925 dgst_size = DGST_SIZE_4_4;
10926 parse_func = zip2_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 13711: hash_type = HASH_TYPE_RIPEMD160;
10936 salt_type = SALT_TYPE_EMBEDDED;
10937 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10938 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10939 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10940 dgst_size = DGST_SIZE_4_5;
10941 parse_func = veracrypt_parse_hash_655331;
10942 sort_by_digest = sort_by_digest_4_5;
10943 opti_type = OPTI_TYPE_ZERO_BYTE;
10944 dgst_pos0 = 0;
10945 dgst_pos1 = 1;
10946 dgst_pos2 = 2;
10947 dgst_pos3 = 3;
10948 break;
10949
10950 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10951 salt_type = SALT_TYPE_EMBEDDED;
10952 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10953 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10954 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10955 dgst_size = DGST_SIZE_4_5;
10956 parse_func = veracrypt_parse_hash_655331;
10957 sort_by_digest = sort_by_digest_4_5;
10958 opti_type = OPTI_TYPE_ZERO_BYTE;
10959 dgst_pos0 = 0;
10960 dgst_pos1 = 1;
10961 dgst_pos2 = 2;
10962 dgst_pos3 = 3;
10963 break;
10964
10965 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10966 salt_type = SALT_TYPE_EMBEDDED;
10967 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10968 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10969 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10970 dgst_size = DGST_SIZE_4_5;
10971 parse_func = veracrypt_parse_hash_655331;
10972 sort_by_digest = sort_by_digest_4_5;
10973 opti_type = OPTI_TYPE_ZERO_BYTE;
10974 dgst_pos0 = 0;
10975 dgst_pos1 = 1;
10976 dgst_pos2 = 2;
10977 dgst_pos3 = 3;
10978 break;
10979
10980 case 13721: hash_type = HASH_TYPE_SHA512;
10981 salt_type = SALT_TYPE_EMBEDDED;
10982 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10983 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10984 kern_type = KERN_TYPE_TCSHA512_XTS512;
10985 dgst_size = DGST_SIZE_8_8;
10986 parse_func = veracrypt_parse_hash_500000;
10987 sort_by_digest = sort_by_digest_8_8;
10988 opti_type = OPTI_TYPE_ZERO_BYTE
10989 | OPTI_TYPE_USES_BITS_64;
10990 dgst_pos0 = 0;
10991 dgst_pos1 = 1;
10992 dgst_pos2 = 2;
10993 dgst_pos3 = 3;
10994 break;
10995
10996 case 13722: hash_type = HASH_TYPE_SHA512;
10997 salt_type = SALT_TYPE_EMBEDDED;
10998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10999 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11000 kern_type = KERN_TYPE_TCSHA512_XTS1024;
11001 dgst_size = DGST_SIZE_8_8;
11002 parse_func = veracrypt_parse_hash_500000;
11003 sort_by_digest = sort_by_digest_8_8;
11004 opti_type = OPTI_TYPE_ZERO_BYTE
11005 | OPTI_TYPE_USES_BITS_64;
11006 dgst_pos0 = 0;
11007 dgst_pos1 = 1;
11008 dgst_pos2 = 2;
11009 dgst_pos3 = 3;
11010 break;
11011
11012 case 13723: hash_type = HASH_TYPE_SHA512;
11013 salt_type = SALT_TYPE_EMBEDDED;
11014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11015 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11016 kern_type = KERN_TYPE_TCSHA512_XTS1536;
11017 dgst_size = DGST_SIZE_8_8;
11018 parse_func = veracrypt_parse_hash_500000;
11019 sort_by_digest = sort_by_digest_8_8;
11020 opti_type = OPTI_TYPE_ZERO_BYTE
11021 | OPTI_TYPE_USES_BITS_64;
11022 dgst_pos0 = 0;
11023 dgst_pos1 = 1;
11024 dgst_pos2 = 2;
11025 dgst_pos3 = 3;
11026 break;
11027
11028 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
11029 salt_type = SALT_TYPE_EMBEDDED;
11030 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11031 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11032 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
11033 dgst_size = DGST_SIZE_4_8;
11034 parse_func = veracrypt_parse_hash_500000;
11035 sort_by_digest = sort_by_digest_4_8;
11036 opti_type = OPTI_TYPE_ZERO_BYTE;
11037 dgst_pos0 = 0;
11038 dgst_pos1 = 1;
11039 dgst_pos2 = 2;
11040 dgst_pos3 = 3;
11041 break;
11042
11043 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
11044 salt_type = SALT_TYPE_EMBEDDED;
11045 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11046 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11047 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
11048 dgst_size = DGST_SIZE_4_8;
11049 parse_func = veracrypt_parse_hash_500000;
11050 sort_by_digest = sort_by_digest_4_8;
11051 opti_type = OPTI_TYPE_ZERO_BYTE;
11052 dgst_pos0 = 0;
11053 dgst_pos1 = 1;
11054 dgst_pos2 = 2;
11055 dgst_pos3 = 3;
11056 break;
11057
11058 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
11059 salt_type = SALT_TYPE_EMBEDDED;
11060 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11061 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11062 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11063 dgst_size = DGST_SIZE_4_8;
11064 parse_func = veracrypt_parse_hash_500000;
11065 sort_by_digest = sort_by_digest_4_8;
11066 opti_type = OPTI_TYPE_ZERO_BYTE;
11067 dgst_pos0 = 0;
11068 dgst_pos1 = 1;
11069 dgst_pos2 = 2;
11070 dgst_pos3 = 3;
11071 break;
11072
11073 case 13741: hash_type = HASH_TYPE_RIPEMD160;
11074 salt_type = SALT_TYPE_EMBEDDED;
11075 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11076 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11077 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11078 dgst_size = DGST_SIZE_4_5;
11079 parse_func = veracrypt_parse_hash_327661;
11080 sort_by_digest = sort_by_digest_4_5;
11081 opti_type = OPTI_TYPE_ZERO_BYTE;
11082 dgst_pos0 = 0;
11083 dgst_pos1 = 1;
11084 dgst_pos2 = 2;
11085 dgst_pos3 = 3;
11086 break;
11087
11088 case 13742: hash_type = HASH_TYPE_RIPEMD160;
11089 salt_type = SALT_TYPE_EMBEDDED;
11090 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11091 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11092 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11093 dgst_size = DGST_SIZE_4_5;
11094 parse_func = veracrypt_parse_hash_327661;
11095 sort_by_digest = sort_by_digest_4_5;
11096 opti_type = OPTI_TYPE_ZERO_BYTE;
11097 dgst_pos0 = 0;
11098 dgst_pos1 = 1;
11099 dgst_pos2 = 2;
11100 dgst_pos3 = 3;
11101 break;
11102
11103 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11104 salt_type = SALT_TYPE_EMBEDDED;
11105 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11106 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11107 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11108 dgst_size = DGST_SIZE_4_5;
11109 parse_func = veracrypt_parse_hash_327661;
11110 sort_by_digest = sort_by_digest_4_5;
11111 opti_type = OPTI_TYPE_ZERO_BYTE;
11112 dgst_pos0 = 0;
11113 dgst_pos1 = 1;
11114 dgst_pos2 = 2;
11115 dgst_pos3 = 3;
11116 break;
11117
11118 case 13751: hash_type = HASH_TYPE_SHA256;
11119 salt_type = SALT_TYPE_EMBEDDED;
11120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11121 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11122 kern_type = KERN_TYPE_VCSHA256_XTS512;
11123 dgst_size = DGST_SIZE_4_8;
11124 parse_func = veracrypt_parse_hash_500000;
11125 sort_by_digest = sort_by_digest_4_8;
11126 opti_type = OPTI_TYPE_ZERO_BYTE;
11127 dgst_pos0 = 0;
11128 dgst_pos1 = 1;
11129 dgst_pos2 = 2;
11130 dgst_pos3 = 3;
11131 break;
11132
11133 case 13752: hash_type = HASH_TYPE_SHA256;
11134 salt_type = SALT_TYPE_EMBEDDED;
11135 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11136 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11137 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11138 dgst_size = DGST_SIZE_4_8;
11139 parse_func = veracrypt_parse_hash_500000;
11140 sort_by_digest = sort_by_digest_4_8;
11141 opti_type = OPTI_TYPE_ZERO_BYTE;
11142 dgst_pos0 = 0;
11143 dgst_pos1 = 1;
11144 dgst_pos2 = 2;
11145 dgst_pos3 = 3;
11146 break;
11147
11148 case 13753: hash_type = HASH_TYPE_SHA256;
11149 salt_type = SALT_TYPE_EMBEDDED;
11150 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11151 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11152 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11153 dgst_size = DGST_SIZE_4_8;
11154 parse_func = veracrypt_parse_hash_500000;
11155 sort_by_digest = sort_by_digest_4_8;
11156 opti_type = OPTI_TYPE_ZERO_BYTE;
11157 dgst_pos0 = 0;
11158 dgst_pos1 = 1;
11159 dgst_pos2 = 2;
11160 dgst_pos3 = 3;
11161 break;
11162
11163 case 13761: hash_type = HASH_TYPE_SHA256;
11164 salt_type = SALT_TYPE_EMBEDDED;
11165 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11166 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11167 kern_type = KERN_TYPE_VCSHA256_XTS512;
11168 dgst_size = DGST_SIZE_4_8;
11169 parse_func = veracrypt_parse_hash_200000;
11170 sort_by_digest = sort_by_digest_4_8;
11171 opti_type = OPTI_TYPE_ZERO_BYTE;
11172 dgst_pos0 = 0;
11173 dgst_pos1 = 1;
11174 dgst_pos2 = 2;
11175 dgst_pos3 = 3;
11176 break;
11177
11178 case 13762: hash_type = HASH_TYPE_SHA256;
11179 salt_type = SALT_TYPE_EMBEDDED;
11180 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11181 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11182 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11183 dgst_size = DGST_SIZE_4_8;
11184 parse_func = veracrypt_parse_hash_200000;
11185 sort_by_digest = sort_by_digest_4_8;
11186 opti_type = OPTI_TYPE_ZERO_BYTE;
11187 dgst_pos0 = 0;
11188 dgst_pos1 = 1;
11189 dgst_pos2 = 2;
11190 dgst_pos3 = 3;
11191 break;
11192
11193 case 13763: hash_type = HASH_TYPE_SHA256;
11194 salt_type = SALT_TYPE_EMBEDDED;
11195 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11196 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11197 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11198 dgst_size = DGST_SIZE_4_8;
11199 parse_func = veracrypt_parse_hash_200000;
11200 sort_by_digest = sort_by_digest_4_8;
11201 opti_type = OPTI_TYPE_ZERO_BYTE;
11202 dgst_pos0 = 0;
11203 dgst_pos1 = 1;
11204 dgst_pos2 = 2;
11205 dgst_pos3 = 3;
11206 break;
11207
11208 case 13800: hash_type = HASH_TYPE_SHA256;
11209 salt_type = SALT_TYPE_EMBEDDED;
11210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11211 opts_type = OPTS_TYPE_PT_GENERATE_BE
11212 | OPTS_TYPE_PT_UNICODE;
11213 kern_type = KERN_TYPE_WIN8PHONE;
11214 dgst_size = DGST_SIZE_4_8;
11215 parse_func = win8phone_parse_hash;
11216 sort_by_digest = sort_by_digest_4_8;
11217 opti_type = OPTI_TYPE_ZERO_BYTE
11218 | OPTI_TYPE_PRECOMPUTE_INIT
11219 | OPTI_TYPE_EARLY_SKIP
11220 | OPTI_TYPE_NOT_ITERATED
11221 | OPTI_TYPE_RAW_HASH;
11222 dgst_pos0 = 3;
11223 dgst_pos1 = 7;
11224 dgst_pos2 = 2;
11225 dgst_pos3 = 6;
11226 break;
11227
11228 default: usage_mini_print (PROGNAME); return (-1);
11229 }
11230
11231 /**
11232 * parser
11233 */
11234
11235 data.parse_func = parse_func;
11236
11237 /**
11238 * misc stuff
11239 */
11240
11241 if (hex_salt)
11242 {
11243 if (salt_type == SALT_TYPE_INTERN)
11244 {
11245 opts_type |= OPTS_TYPE_ST_HEX;
11246 }
11247 else
11248 {
11249 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11250
11251 return (-1);
11252 }
11253 }
11254
11255 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11256 | (salt_type == SALT_TYPE_EXTERN)
11257 | (salt_type == SALT_TYPE_EMBEDDED)
11258 | (salt_type == SALT_TYPE_VIRTUAL));
11259
11260 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11261
11262 data.hash_type = hash_type;
11263 data.attack_mode = attack_mode;
11264 data.attack_kern = attack_kern;
11265 data.attack_exec = attack_exec;
11266 data.kern_type = kern_type;
11267 data.opts_type = opts_type;
11268 data.dgst_size = dgst_size;
11269 data.salt_type = salt_type;
11270 data.isSalted = isSalted;
11271 data.sort_by_digest = sort_by_digest;
11272 data.dgst_pos0 = dgst_pos0;
11273 data.dgst_pos1 = dgst_pos1;
11274 data.dgst_pos2 = dgst_pos2;
11275 data.dgst_pos3 = dgst_pos3;
11276
11277 esalt_size = 0;
11278
11279 switch (hash_mode)
11280 {
11281 case 2500: esalt_size = sizeof (wpa_t); break;
11282 case 5300: esalt_size = sizeof (ikepsk_t); break;
11283 case 5400: esalt_size = sizeof (ikepsk_t); break;
11284 case 5500: esalt_size = sizeof (netntlm_t); break;
11285 case 5600: esalt_size = sizeof (netntlm_t); break;
11286 case 6211: esalt_size = sizeof (tc_t); break;
11287 case 6212: esalt_size = sizeof (tc_t); break;
11288 case 6213: esalt_size = sizeof (tc_t); break;
11289 case 6221: esalt_size = sizeof (tc_t); break;
11290 case 6222: esalt_size = sizeof (tc_t); break;
11291 case 6223: esalt_size = sizeof (tc_t); break;
11292 case 6231: esalt_size = sizeof (tc_t); break;
11293 case 6232: esalt_size = sizeof (tc_t); break;
11294 case 6233: esalt_size = sizeof (tc_t); break;
11295 case 6241: esalt_size = sizeof (tc_t); break;
11296 case 6242: esalt_size = sizeof (tc_t); break;
11297 case 6243: esalt_size = sizeof (tc_t); break;
11298 case 6600: esalt_size = sizeof (agilekey_t); break;
11299 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11300 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11301 case 7300: esalt_size = sizeof (rakp_t); break;
11302 case 7500: esalt_size = sizeof (krb5pa_t); break;
11303 case 8200: esalt_size = sizeof (cloudkey_t); break;
11304 case 8800: esalt_size = sizeof (androidfde_t); break;
11305 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11306 case 9400: esalt_size = sizeof (office2007_t); break;
11307 case 9500: esalt_size = sizeof (office2010_t); break;
11308 case 9600: esalt_size = sizeof (office2013_t); break;
11309 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11310 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11311 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11312 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11313 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11314 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11315 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11316 case 10200: esalt_size = sizeof (cram_md5_t); break;
11317 case 10400: esalt_size = sizeof (pdf_t); break;
11318 case 10410: esalt_size = sizeof (pdf_t); break;
11319 case 10420: esalt_size = sizeof (pdf_t); break;
11320 case 10500: esalt_size = sizeof (pdf_t); break;
11321 case 10600: esalt_size = sizeof (pdf_t); break;
11322 case 10700: esalt_size = sizeof (pdf_t); break;
11323 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11324 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11325 case 11400: esalt_size = sizeof (sip_t); break;
11326 case 11600: esalt_size = sizeof (seven_zip_t); break;
11327 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11328 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11329 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11330 case 13000: esalt_size = sizeof (rar5_t); break;
11331 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11332 case 13400: esalt_size = sizeof (keepass_t); break;
11333 case 13500: esalt_size = sizeof (pstoken_t); break;
11334 case 13600: esalt_size = sizeof (zip2_t); break;
11335 case 13711: esalt_size = sizeof (tc_t); break;
11336 case 13712: esalt_size = sizeof (tc_t); break;
11337 case 13713: esalt_size = sizeof (tc_t); break;
11338 case 13721: esalt_size = sizeof (tc_t); break;
11339 case 13722: esalt_size = sizeof (tc_t); break;
11340 case 13723: esalt_size = sizeof (tc_t); break;
11341 case 13731: esalt_size = sizeof (tc_t); break;
11342 case 13732: esalt_size = sizeof (tc_t); break;
11343 case 13733: esalt_size = sizeof (tc_t); break;
11344 case 13741: esalt_size = sizeof (tc_t); break;
11345 case 13742: esalt_size = sizeof (tc_t); break;
11346 case 13743: esalt_size = sizeof (tc_t); break;
11347 case 13751: esalt_size = sizeof (tc_t); break;
11348 case 13752: esalt_size = sizeof (tc_t); break;
11349 case 13753: esalt_size = sizeof (tc_t); break;
11350 case 13761: esalt_size = sizeof (tc_t); break;
11351 case 13762: esalt_size = sizeof (tc_t); break;
11352 case 13763: esalt_size = sizeof (tc_t); break;
11353 case 13800: esalt_size = sizeof (win8phone_t); break;
11354 }
11355
11356 data.esalt_size = esalt_size;
11357
11358 /**
11359 * choose dictionary parser
11360 */
11361
11362 if (hash_type == HASH_TYPE_LM)
11363 {
11364 get_next_word_func = get_next_word_lm;
11365 }
11366 else if (opts_type & OPTS_TYPE_PT_UPPER)
11367 {
11368 get_next_word_func = get_next_word_uc;
11369 }
11370 else
11371 {
11372 get_next_word_func = get_next_word_std;
11373 }
11374
11375 /**
11376 * dictstat
11377 */
11378
11379 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11380
11381 #ifdef _POSIX
11382 size_t dictstat_nmemb = 0;
11383 #endif
11384
11385 #ifdef _WIN
11386 uint dictstat_nmemb = 0;
11387 #endif
11388
11389 char dictstat[256] = { 0 };
11390
11391 FILE *dictstat_fp = NULL;
11392
11393 if (keyspace == 0)
11394 {
11395 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11396
11397 dictstat_fp = fopen (dictstat, "rb");
11398
11399 if (dictstat_fp)
11400 {
11401 #ifdef _POSIX
11402 struct stat tmpstat;
11403
11404 fstat (fileno (dictstat_fp), &tmpstat);
11405 #endif
11406
11407 #ifdef _WIN
11408 struct stat64 tmpstat;
11409
11410 _fstat64 (fileno (dictstat_fp), &tmpstat);
11411 #endif
11412
11413 if (tmpstat.st_mtime < COMPTIME)
11414 {
11415 /* with v0.15 the format changed so we have to ensure user is using a good version
11416 since there is no version-header in the dictstat file */
11417
11418 fclose (dictstat_fp);
11419
11420 unlink (dictstat);
11421 }
11422 else
11423 {
11424 while (!feof (dictstat_fp))
11425 {
11426 dictstat_t d;
11427
11428 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11429
11430 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11431
11432 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11433 {
11434 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11435
11436 return -1;
11437 }
11438 }
11439
11440 fclose (dictstat_fp);
11441 }
11442 }
11443 }
11444
11445 /**
11446 * potfile
11447 */
11448
11449 char potfile[256] = { 0 };
11450
11451 if (potfile_path == NULL)
11452 {
11453 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11454 }
11455 else
11456 {
11457 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11458 }
11459
11460 data.pot_fp = NULL;
11461
11462 FILE *out_fp = NULL;
11463 FILE *pot_fp = NULL;
11464
11465 if (show == 1 || left == 1)
11466 {
11467 pot_fp = fopen (potfile, "rb");
11468
11469 if (pot_fp == NULL)
11470 {
11471 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11472
11473 return (-1);
11474 }
11475
11476 if (outfile != NULL)
11477 {
11478 if ((out_fp = fopen (outfile, "ab")) == NULL)
11479 {
11480 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11481
11482 fclose (pot_fp);
11483
11484 return (-1);
11485 }
11486 }
11487 else
11488 {
11489 out_fp = stdout;
11490 }
11491 }
11492 else
11493 {
11494 if (potfile_disable == 0)
11495 {
11496 pot_fp = fopen (potfile, "ab");
11497
11498 if (pot_fp == NULL)
11499 {
11500 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11501
11502 return (-1);
11503 }
11504
11505 data.pot_fp = pot_fp;
11506 }
11507 }
11508
11509 pot_t *pot = NULL;
11510
11511 uint pot_cnt = 0;
11512 uint pot_avail = 0;
11513
11514 if (show == 1 || left == 1)
11515 {
11516 SUPPRESS_OUTPUT = 1;
11517
11518 pot_avail = count_lines (pot_fp);
11519
11520 rewind (pot_fp);
11521
11522 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11523
11524 uint pot_hashes_avail = 0;
11525
11526 uint line_num = 0;
11527
11528 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11529
11530 while (!feof (pot_fp))
11531 {
11532 line_num++;
11533
11534 int line_len = fgetl (pot_fp, line_buf);
11535
11536 if (line_len == 0) continue;
11537
11538 char *plain_buf = line_buf + line_len;
11539
11540 pot_t *pot_ptr = &pot[pot_cnt];
11541
11542 hash_t *hashes_buf = &pot_ptr->hash;
11543
11544 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11545 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11546
11547 if (pot_cnt == pot_hashes_avail)
11548 {
11549 uint pos = 0;
11550
11551 for (pos = 0; pos < INCR_POT; pos++)
11552 {
11553 if ((pot_cnt + pos) >= pot_avail) break;
11554
11555 pot_t *tmp_pot = &pot[pot_cnt + pos];
11556
11557 hash_t *tmp_hash = &tmp_pot->hash;
11558
11559 tmp_hash->digest = mymalloc (dgst_size);
11560
11561 if (isSalted)
11562 {
11563 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11564 }
11565
11566 if (esalt_size)
11567 {
11568 tmp_hash->esalt = mymalloc (esalt_size);
11569 }
11570
11571 pot_hashes_avail++;
11572 }
11573 }
11574
11575 int plain_len = 0;
11576
11577 int parser_status;
11578
11579 int iter = MAX_CUT_TRIES;
11580
11581 do
11582 {
11583 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11584 {
11585 if (line_buf[i] == ':')
11586 {
11587 line_len--;
11588
11589 break;
11590 }
11591 }
11592
11593 if (data.hash_mode != 2500)
11594 {
11595 parser_status = parse_func (line_buf, line_len, hashes_buf);
11596 }
11597 else
11598 {
11599 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11600
11601 if (line_len > max_salt_size)
11602 {
11603 parser_status = PARSER_GLOBAL_LENGTH;
11604 }
11605 else
11606 {
11607 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11608
11609 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11610
11611 hashes_buf->salt->salt_len = line_len;
11612
11613 parser_status = PARSER_OK;
11614 }
11615 }
11616
11617 // if NOT parsed without error, we add the ":" to the plain
11618
11619 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11620 {
11621 plain_len++;
11622 plain_buf--;
11623 }
11624
11625 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11626
11627 if (parser_status < PARSER_GLOBAL_ZERO)
11628 {
11629 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11630
11631 continue;
11632 }
11633
11634 if (plain_len >= 255) continue;
11635
11636 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11637
11638 pot_ptr->plain_len = plain_len;
11639
11640 pot_cnt++;
11641 }
11642
11643 myfree (line_buf);
11644
11645 fclose (pot_fp);
11646
11647 SUPPRESS_OUTPUT = 0;
11648
11649 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11650 }
11651
11652 /**
11653 * word len
11654 */
11655
11656 uint pw_min = PW_MIN;
11657 uint pw_max = PW_MAX;
11658
11659 switch (hash_mode)
11660 {
11661 case 125: if (pw_max > 32) pw_max = 32;
11662 break;
11663 case 400: if (pw_max > 40) pw_max = 40;
11664 break;
11665 case 500: if (pw_max > 16) pw_max = 16;
11666 break;
11667 case 1500: if (pw_max > 8) pw_max = 8;
11668 break;
11669 case 1600: if (pw_max > 16) pw_max = 16;
11670 break;
11671 case 1800: if (pw_max > 16) pw_max = 16;
11672 break;
11673 case 2100: if (pw_max > 16) pw_max = 16;
11674 break;
11675 case 2500: if (pw_min < 8) pw_min = 8;
11676 break;
11677 case 3000: if (pw_max > 7) pw_max = 7;
11678 break;
11679 case 5200: if (pw_max > 24) pw_max = 24;
11680 break;
11681 case 5800: if (pw_max > 16) pw_max = 16;
11682 break;
11683 case 6300: if (pw_max > 16) pw_max = 16;
11684 break;
11685 case 7400: if (pw_max > 16) pw_max = 16;
11686 break;
11687 case 7700: if (pw_max > 8) pw_max = 8;
11688 break;
11689 case 7900: if (pw_max > 48) pw_max = 48;
11690 break;
11691 case 8500: if (pw_max > 8) pw_max = 8;
11692 break;
11693 case 8600: if (pw_max > 16) pw_max = 16;
11694 break;
11695 case 9710: pw_min = 5;
11696 pw_max = 5;
11697 break;
11698 case 9810: pw_min = 5;
11699 pw_max = 5;
11700 break;
11701 case 10410: pw_min = 5;
11702 pw_max = 5;
11703 break;
11704 case 10300: if (pw_max < 3) pw_min = 3;
11705 if (pw_max > 40) pw_max = 40;
11706 break;
11707 case 10500: if (pw_max < 3) pw_min = 3;
11708 if (pw_max > 40) pw_max = 40;
11709 break;
11710 case 10700: if (pw_max > 16) pw_max = 16;
11711 break;
11712 case 11300: if (pw_max > 40) pw_max = 40;
11713 break;
11714 case 11600: if (pw_max > 32) pw_max = 32;
11715 break;
11716 case 12500: if (pw_max > 20) pw_max = 20;
11717 break;
11718 case 12800: if (pw_max > 24) pw_max = 24;
11719 break;
11720 }
11721
11722 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11723 {
11724 switch (attack_kern)
11725 {
11726 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11727 break;
11728 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11729 break;
11730 }
11731 }
11732
11733 /**
11734 * charsets : keep them together for more easy maintainnce
11735 */
11736
11737 cs_t mp_sys[6] = { { { 0 }, 0 } };
11738 cs_t mp_usr[4] = { { { 0 }, 0 } };
11739
11740 mp_setup_sys (mp_sys);
11741
11742 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11743 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11744 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11745 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11746
11747 /**
11748 * load hashes, part I: find input mode, count hashes
11749 */
11750
11751 uint hashlist_mode = 0;
11752 uint hashlist_format = HLFMT_HASHCAT;
11753
11754 uint hashes_avail = 0;
11755
11756 if ((benchmark == 0) && (stdout_flag == 0))
11757 {
11758 struct stat f;
11759
11760 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11761
11762 if ((hash_mode == 2500) ||
11763 (hash_mode == 5200) ||
11764 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11765 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11766 (hash_mode == 9000))
11767 {
11768 hashlist_mode = HL_MODE_ARG;
11769
11770 char *hashfile = myargv[optind];
11771
11772 data.hashfile = hashfile;
11773
11774 logfile_top_var_string ("target", hashfile);
11775 }
11776
11777 if (hashlist_mode == HL_MODE_ARG)
11778 {
11779 if (hash_mode == 2500)
11780 {
11781 struct stat st;
11782
11783 if (stat (data.hashfile, &st) == -1)
11784 {
11785 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11786
11787 return (-1);
11788 }
11789
11790 hashes_avail = st.st_size / sizeof (hccap_t);
11791 }
11792 else
11793 {
11794 hashes_avail = 1;
11795 }
11796 }
11797 else if (hashlist_mode == HL_MODE_FILE)
11798 {
11799 char *hashfile = myargv[optind];
11800
11801 data.hashfile = hashfile;
11802
11803 logfile_top_var_string ("target", hashfile);
11804
11805 FILE *fp = NULL;
11806
11807 if ((fp = fopen (hashfile, "rb")) == NULL)
11808 {
11809 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11810
11811 return (-1);
11812 }
11813
11814 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11815
11816 hashes_avail = count_lines (fp);
11817
11818 rewind (fp);
11819
11820 if (hashes_avail == 0)
11821 {
11822 log_error ("ERROR: hashfile is empty or corrupt");
11823
11824 fclose (fp);
11825
11826 return (-1);
11827 }
11828
11829 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11830
11831 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11832 {
11833 log_error ("ERROR: remove not supported in native hashfile-format mode");
11834
11835 fclose (fp);
11836
11837 return (-1);
11838 }
11839
11840 fclose (fp);
11841 }
11842 }
11843 else
11844 {
11845 hashlist_mode = HL_MODE_ARG;
11846
11847 hashes_avail = 1;
11848 }
11849
11850 if (hash_mode == 3000) hashes_avail *= 2;
11851
11852 data.hashlist_mode = hashlist_mode;
11853 data.hashlist_format = hashlist_format;
11854
11855 logfile_top_uint (hashlist_mode);
11856 logfile_top_uint (hashlist_format);
11857
11858 /**
11859 * load hashes, part II: allocate required memory, set pointers
11860 */
11861
11862 hash_t *hashes_buf = NULL;
11863 void *digests_buf = NULL;
11864 salt_t *salts_buf = NULL;
11865 void *esalts_buf = NULL;
11866
11867 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11868
11869 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11870
11871 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11872 {
11873 u32 hash_pos;
11874
11875 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11876 {
11877 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11878
11879 hashes_buf[hash_pos].hash_info = hash_info;
11880
11881 if (username && (remove || show || left))
11882 {
11883 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11884 }
11885
11886 if (benchmark)
11887 {
11888 hash_info->orighash = (char *) mymalloc (256);
11889 }
11890 }
11891 }
11892
11893 if (isSalted)
11894 {
11895 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11896
11897 if (esalt_size)
11898 {
11899 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11900 }
11901 }
11902 else
11903 {
11904 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11905 }
11906
11907 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11908 {
11909 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11910
11911 if (isSalted)
11912 {
11913 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11914
11915 if (esalt_size)
11916 {
11917 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11918 }
11919 }
11920 else
11921 {
11922 hashes_buf[hash_pos].salt = &salts_buf[0];
11923 }
11924 }
11925
11926 /**
11927 * load hashes, part III: parse hashes or generate them if benchmark
11928 */
11929
11930 uint hashes_cnt = 0;
11931
11932 if (benchmark == 0)
11933 {
11934 if (keyspace == 1)
11935 {
11936 // useless to read hash file for keyspace, cheat a little bit w/ optind
11937 }
11938 else if (stdout_flag == 1)
11939 {
11940 // useless to read hash file for stdout, cheat a little bit w/ optind
11941 }
11942 else if (hashes_avail == 0)
11943 {
11944 }
11945 else if (hashlist_mode == HL_MODE_ARG)
11946 {
11947 char *input_buf = myargv[optind];
11948
11949 uint input_len = strlen (input_buf);
11950
11951 logfile_top_var_string ("target", input_buf);
11952
11953 char *hash_buf = NULL;
11954 int hash_len = 0;
11955
11956 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11957
11958 bool hash_fmt_error = 0;
11959
11960 if (hash_len < 1) hash_fmt_error = 1;
11961 if (hash_buf == NULL) hash_fmt_error = 1;
11962
11963 if (hash_fmt_error)
11964 {
11965 log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11966 }
11967 else
11968 {
11969 if (opts_type & OPTS_TYPE_HASH_COPY)
11970 {
11971 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11972
11973 hash_info_tmp->orighash = mystrdup (hash_buf);
11974 }
11975
11976 if (isSalted)
11977 {
11978 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11979 }
11980
11981 int parser_status = PARSER_OK;
11982
11983 if (hash_mode == 2500)
11984 {
11985 if (hash_len == 0)
11986 {
11987 log_error ("ERROR: hccap file not specified");
11988
11989 return (-1);
11990 }
11991
11992 hashlist_mode = HL_MODE_FILE;
11993
11994 data.hashlist_mode = hashlist_mode;
11995
11996 FILE *fp = fopen (hash_buf, "rb");
11997
11998 if (fp == NULL)
11999 {
12000 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
12001
12002 return (-1);
12003 }
12004
12005 if (hashes_avail < 1)
12006 {
12007 log_error ("ERROR: hccap file is empty or corrupt");
12008
12009 fclose (fp);
12010
12011 return (-1);
12012 }
12013
12014 uint hccap_size = sizeof (hccap_t);
12015
12016 char *in = (char *) mymalloc (hccap_size);
12017
12018 while (!feof (fp))
12019 {
12020 int n = fread (in, hccap_size, 1, fp);
12021
12022 if (n != 1)
12023 {
12024 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
12025
12026 break;
12027 }
12028
12029 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12030
12031 if (parser_status != PARSER_OK)
12032 {
12033 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12034
12035 continue;
12036 }
12037
12038 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12039
12040 if ((show == 1) || (left == 1))
12041 {
12042 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12043
12044 char *salt_ptr = (char *) tmp_salt->salt_buf;
12045
12046 int cur_pos = tmp_salt->salt_len;
12047 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12048
12049 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12050
12051 // do the appending task
12052
12053 snprintf (salt_ptr + cur_pos,
12054 rem_len,
12055 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12056 wpa->orig_mac1[0],
12057 wpa->orig_mac1[1],
12058 wpa->orig_mac1[2],
12059 wpa->orig_mac1[3],
12060 wpa->orig_mac1[4],
12061 wpa->orig_mac1[5],
12062 wpa->orig_mac2[0],
12063 wpa->orig_mac2[1],
12064 wpa->orig_mac2[2],
12065 wpa->orig_mac2[3],
12066 wpa->orig_mac2[4],
12067 wpa->orig_mac2[5]);
12068
12069 // memset () the remaining part of the salt
12070
12071 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12072 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12073
12074 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12075
12076 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12077 }
12078
12079 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);
12080 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);
12081
12082 hashes_cnt++;
12083 }
12084
12085 fclose (fp);
12086
12087 myfree (in);
12088 }
12089 else if (hash_mode == 3000)
12090 {
12091 if (hash_len == 32)
12092 {
12093 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12094
12095 hash_t *lm_hash_left = NULL;
12096
12097 if (parser_status == PARSER_OK)
12098 {
12099 lm_hash_left = &hashes_buf[hashes_cnt];
12100
12101 hashes_cnt++;
12102 }
12103 else
12104 {
12105 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12106 }
12107
12108 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12109
12110 hash_t *lm_hash_right = NULL;
12111
12112 if (parser_status == PARSER_OK)
12113 {
12114 lm_hash_right = &hashes_buf[hashes_cnt];
12115
12116 hashes_cnt++;
12117 }
12118 else
12119 {
12120 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12121 }
12122
12123 // show / left
12124
12125 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12126 {
12127 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);
12128 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);
12129 }
12130 }
12131 else
12132 {
12133 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12134
12135 if (parser_status == PARSER_OK)
12136 {
12137 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12138 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12139 }
12140
12141 if (parser_status == PARSER_OK)
12142 {
12143 hashes_cnt++;
12144 }
12145 else
12146 {
12147 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12148 }
12149 }
12150 }
12151 else
12152 {
12153 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12154
12155 if (parser_status == PARSER_OK)
12156 {
12157 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12158 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12159 }
12160
12161 if (parser_status == PARSER_OK)
12162 {
12163 hashes_cnt++;
12164 }
12165 else
12166 {
12167 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12168 }
12169 }
12170 }
12171 }
12172 else if (hashlist_mode == HL_MODE_FILE)
12173 {
12174 char *hashfile = data.hashfile;
12175
12176 FILE *fp;
12177
12178 if ((fp = fopen (hashfile, "rb")) == NULL)
12179 {
12180 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12181
12182 return (-1);
12183 }
12184
12185 uint line_num = 0;
12186
12187 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12188
12189 while (!feof (fp))
12190 {
12191 line_num++;
12192
12193 int line_len = fgetl (fp, line_buf);
12194
12195 if (line_len == 0) continue;
12196
12197 char *hash_buf = NULL;
12198 int hash_len = 0;
12199
12200 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12201
12202 bool hash_fmt_error = 0;
12203
12204 if (hash_len < 1) hash_fmt_error = 1;
12205 if (hash_buf == NULL) hash_fmt_error = 1;
12206
12207 if (hash_fmt_error)
12208 {
12209 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12210
12211 continue;
12212 }
12213
12214 if (username)
12215 {
12216 char *user_buf = NULL;
12217 int user_len = 0;
12218
12219 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12220
12221 if (remove || show)
12222 {
12223 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12224
12225 *user = (user_t *) mymalloc (sizeof (user_t));
12226
12227 user_t *user_ptr = *user;
12228
12229 if (user_buf != NULL)
12230 {
12231 user_ptr->user_name = mystrdup (user_buf);
12232 }
12233 else
12234 {
12235 user_ptr->user_name = mystrdup ("");
12236 }
12237
12238 user_ptr->user_len = user_len;
12239 }
12240 }
12241
12242 if (opts_type & OPTS_TYPE_HASH_COPY)
12243 {
12244 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12245
12246 hash_info_tmp->orighash = mystrdup (hash_buf);
12247 }
12248
12249 if (isSalted)
12250 {
12251 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12252 }
12253
12254 if (hash_mode == 3000)
12255 {
12256 if (hash_len == 32)
12257 {
12258 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12259
12260 if (parser_status < PARSER_GLOBAL_ZERO)
12261 {
12262 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12263
12264 continue;
12265 }
12266
12267 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12268
12269 hashes_cnt++;
12270
12271 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12272
12273 if (parser_status < PARSER_GLOBAL_ZERO)
12274 {
12275 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12276
12277 continue;
12278 }
12279
12280 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12281
12282 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);
12283
12284 hashes_cnt++;
12285
12286 // show / left
12287
12288 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);
12289 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);
12290 }
12291 else
12292 {
12293 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12294
12295 if (parser_status < PARSER_GLOBAL_ZERO)
12296 {
12297 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12298
12299 continue;
12300 }
12301
12302 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);
12303
12304 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12305 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12306
12307 hashes_cnt++;
12308 }
12309 }
12310 else
12311 {
12312 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12313
12314 if (parser_status < PARSER_GLOBAL_ZERO)
12315 {
12316 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12317
12318 continue;
12319 }
12320
12321 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);
12322
12323 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12324 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12325
12326 hashes_cnt++;
12327 }
12328 }
12329
12330 myfree (line_buf);
12331
12332 fclose (fp);
12333
12334 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12335
12336 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12337 }
12338 }
12339 else
12340 {
12341 if (isSalted)
12342 {
12343 hashes_buf[0].salt->salt_len = 8;
12344
12345 // special salt handling
12346
12347 switch (hash_mode)
12348 {
12349 case 1500: hashes_buf[0].salt->salt_len = 2;
12350 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12351 break;
12352 case 1731: hashes_buf[0].salt->salt_len = 4;
12353 break;
12354 case 2410: hashes_buf[0].salt->salt_len = 4;
12355 break;
12356 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12357 break;
12358 case 3100: hashes_buf[0].salt->salt_len = 1;
12359 break;
12360 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12361 break;
12362 case 5800: hashes_buf[0].salt->salt_len = 16;
12363 break;
12364 case 6800: hashes_buf[0].salt->salt_len = 32;
12365 break;
12366 case 8400: hashes_buf[0].salt->salt_len = 40;
12367 break;
12368 case 8800: hashes_buf[0].salt->salt_len = 16;
12369 break;
12370 case 8900: hashes_buf[0].salt->salt_len = 16;
12371 hashes_buf[0].salt->scrypt_N = 1024;
12372 hashes_buf[0].salt->scrypt_r = 1;
12373 hashes_buf[0].salt->scrypt_p = 1;
12374 break;
12375 case 9100: hashes_buf[0].salt->salt_len = 16;
12376 break;
12377 case 9300: hashes_buf[0].salt->salt_len = 14;
12378 hashes_buf[0].salt->scrypt_N = 16384;
12379 hashes_buf[0].salt->scrypt_r = 1;
12380 hashes_buf[0].salt->scrypt_p = 1;
12381 break;
12382 case 9400: hashes_buf[0].salt->salt_len = 16;
12383 break;
12384 case 9500: hashes_buf[0].salt->salt_len = 16;
12385 break;
12386 case 9600: hashes_buf[0].salt->salt_len = 16;
12387 break;
12388 case 9700: hashes_buf[0].salt->salt_len = 16;
12389 break;
12390 case 9710: hashes_buf[0].salt->salt_len = 16;
12391 break;
12392 case 9720: hashes_buf[0].salt->salt_len = 16;
12393 break;
12394 case 9800: hashes_buf[0].salt->salt_len = 16;
12395 break;
12396 case 9810: hashes_buf[0].salt->salt_len = 16;
12397 break;
12398 case 9820: hashes_buf[0].salt->salt_len = 16;
12399 break;
12400 case 10300: hashes_buf[0].salt->salt_len = 12;
12401 break;
12402 case 11500: hashes_buf[0].salt->salt_len = 4;
12403 break;
12404 case 11600: hashes_buf[0].salt->salt_len = 4;
12405 break;
12406 case 12400: hashes_buf[0].salt->salt_len = 4;
12407 break;
12408 case 12500: hashes_buf[0].salt->salt_len = 8;
12409 break;
12410 case 12600: hashes_buf[0].salt->salt_len = 64;
12411 break;
12412 }
12413
12414 // special esalt handling
12415
12416 switch (hash_mode)
12417 {
12418 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12419 break;
12420 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12421 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12422 break;
12423 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12424 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12425 break;
12426 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12427 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12428 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12429 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12430 break;
12431 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12432 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12433 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12434 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12435 break;
12436 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12437 break;
12438 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12439 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12440 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12441 break;
12442 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12443 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12444 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12445 break;
12446 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12447 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12448 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12449 break;
12450 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12451 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12452 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12453 break;
12454 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12455 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12456 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12457 break;
12458 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12459 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12460 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12461 break;
12462 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12463 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12464 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12465 break;
12466 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12467 break;
12468 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12469 break;
12470 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12471 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12472 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12473 break;
12474 }
12475 }
12476
12477 // set hashfile
12478
12479 switch (hash_mode)
12480 {
12481 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12482 break;
12483 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12484 break;
12485 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12486 break;
12487 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12488 break;
12489 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12490 break;
12491 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12492 break;
12493 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12494 break;
12495 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12496 break;
12497 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12498 break;
12499 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12500 break;
12501 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12502 break;
12503 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12504 break;
12505 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12506 break;
12507 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12508 break;
12509 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12510 break;
12511 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12512 break;
12513 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12514 break;
12515 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12516 break;
12517 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12518 break;
12519 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12520 break;
12521 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12522 break;
12523 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12524 break;
12525 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12526 break;
12527 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12528 break;
12529 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12530 break;
12531 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12532 break;
12533 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12534 break;
12535 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12536 break;
12537 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12538 break;
12539 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12540 break;
12541 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12542 break;
12543 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12544 break;
12545 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12546 break;
12547 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12548 break;
12549 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12550 break;
12551 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12552 break;
12553 }
12554
12555 // set default iterations
12556
12557 switch (hash_mode)
12558 {
12559 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12560 break;
12561 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12562 break;
12563 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12564 break;
12565 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12566 break;
12567 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12568 break;
12569 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12570 break;
12571 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12572 break;
12573 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12574 break;
12575 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12576 break;
12577 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12578 break;
12579 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12580 break;
12581 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12582 break;
12583 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12584 break;
12585 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12586 break;
12587 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12588 break;
12589 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12590 break;
12591 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12592 break;
12593 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12594 break;
12595 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12596 break;
12597 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12598 break;
12599 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12600 break;
12601 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12602 break;
12603 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12604 break;
12605 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12606 break;
12607 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12608 break;
12609 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12610 break;
12611 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12612 break;
12613 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12614 break;
12615 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12616 break;
12617 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12618 break;
12619 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12620 break;
12621 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12622 break;
12623 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12624 break;
12625 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12626 break;
12627 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12628 break;
12629 case 8900: hashes_buf[0].salt->salt_iter = 1;
12630 break;
12631 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12632 break;
12633 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12634 break;
12635 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12636 break;
12637 case 9300: hashes_buf[0].salt->salt_iter = 1;
12638 break;
12639 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12640 break;
12641 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12642 break;
12643 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12644 break;
12645 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12646 break;
12647 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12648 break;
12649 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12650 break;
12651 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12652 break;
12653 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12654 break;
12655 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12656 break;
12657 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12658 break;
12659 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12660 break;
12661 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12662 break;
12663 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12664 break;
12665 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12666 break;
12667 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12668 break;
12669 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12670 break;
12671 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12672 break;
12673 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12674 break;
12675 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12676 break;
12677 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12678 break;
12679 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12680 break;
12681 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12682 break;
12683 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12684 break;
12685 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12686 break;
12687 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12688 break;
12689 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12690 break;
12691 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12692 break;
12693 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12694 break;
12695 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12696 break;
12697 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12698 break;
12699 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12700 break;
12701 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12702 break;
12703 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12704 break;
12705 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12706 break;
12707 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12708 break;
12709 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12710 break;
12711 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12712 break;
12713 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12714 break;
12715 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12716 break;
12717 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12718 break;
12719 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12720 break;
12721 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12722 break;
12723 }
12724
12725 hashes_cnt = 1;
12726 }
12727
12728 if (show == 1 || left == 1)
12729 {
12730 for (uint i = 0; i < pot_cnt; i++)
12731 {
12732 pot_t *pot_ptr = &pot[i];
12733
12734 hash_t *hashes_buf = &pot_ptr->hash;
12735
12736 local_free (hashes_buf->digest);
12737
12738 if (isSalted)
12739 {
12740 local_free (hashes_buf->salt);
12741 }
12742 }
12743
12744 local_free (pot);
12745
12746 if (data.quiet == 0) log_info_nn ("");
12747
12748 return (0);
12749 }
12750
12751 if ((keyspace == 0) && (stdout_flag == 0))
12752 {
12753 if (hashes_cnt == 0)
12754 {
12755 log_error ("ERROR: No hashes loaded");
12756
12757 return (-1);
12758 }
12759 }
12760
12761 /**
12762 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12763 */
12764
12765 if (data.outfile != NULL)
12766 {
12767 if (data.hashfile != NULL)
12768 {
12769 #ifdef _POSIX
12770 struct stat tmpstat_outfile;
12771 struct stat tmpstat_hashfile;
12772 #endif
12773
12774 #ifdef _WIN
12775 struct stat64 tmpstat_outfile;
12776 struct stat64 tmpstat_hashfile;
12777 #endif
12778
12779 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12780
12781 if (tmp_outfile_fp)
12782 {
12783 #ifdef _POSIX
12784 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12785 #endif
12786
12787 #ifdef _WIN
12788 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12789 #endif
12790
12791 fclose (tmp_outfile_fp);
12792 }
12793
12794 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12795
12796 if (tmp_hashfile_fp)
12797 {
12798 #ifdef _POSIX
12799 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12800 #endif
12801
12802 #ifdef _WIN
12803 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12804 #endif
12805
12806 fclose (tmp_hashfile_fp);
12807 }
12808
12809 if (tmp_outfile_fp && tmp_outfile_fp)
12810 {
12811 tmpstat_outfile.st_mode = 0;
12812 tmpstat_outfile.st_nlink = 0;
12813 tmpstat_outfile.st_uid = 0;
12814 tmpstat_outfile.st_gid = 0;
12815 tmpstat_outfile.st_rdev = 0;
12816 tmpstat_outfile.st_atime = 0;
12817
12818 tmpstat_hashfile.st_mode = 0;
12819 tmpstat_hashfile.st_nlink = 0;
12820 tmpstat_hashfile.st_uid = 0;
12821 tmpstat_hashfile.st_gid = 0;
12822 tmpstat_hashfile.st_rdev = 0;
12823 tmpstat_hashfile.st_atime = 0;
12824
12825 #ifdef _POSIX
12826 tmpstat_outfile.st_blksize = 0;
12827 tmpstat_outfile.st_blocks = 0;
12828
12829 tmpstat_hashfile.st_blksize = 0;
12830 tmpstat_hashfile.st_blocks = 0;
12831 #endif
12832
12833 #ifdef _POSIX
12834 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12835 {
12836 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12837
12838 return (-1);
12839 }
12840 #endif
12841
12842 #ifdef _WIN
12843 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12844 {
12845 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12846
12847 return (-1);
12848 }
12849 #endif
12850 }
12851 }
12852 }
12853
12854 /**
12855 * Remove duplicates
12856 */
12857
12858 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12859
12860 if (isSalted)
12861 {
12862 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12863 }
12864 else
12865 {
12866 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12867 }
12868
12869 uint hashes_cnt_orig = hashes_cnt;
12870
12871 hashes_cnt = 1;
12872
12873 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12874 {
12875 if (isSalted)
12876 {
12877 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12878 {
12879 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12880 }
12881 }
12882 else
12883 {
12884 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12885 }
12886
12887 if (hashes_pos > hashes_cnt)
12888 {
12889 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12890 }
12891
12892 hashes_cnt++;
12893 }
12894
12895 /**
12896 * Potfile removes
12897 */
12898
12899 uint potfile_remove_cracks = 0;
12900
12901 if (potfile_disable == 0)
12902 {
12903 hash_t hash_buf;
12904
12905 hash_buf.digest = mymalloc (dgst_size);
12906 hash_buf.salt = NULL;
12907 hash_buf.esalt = NULL;
12908 hash_buf.hash_info = NULL;
12909 hash_buf.cracked = 0;
12910
12911 if (isSalted)
12912 {
12913 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12914 }
12915
12916 if (esalt_size)
12917 {
12918 hash_buf.esalt = mymalloc (esalt_size);
12919 }
12920
12921 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12922
12923 // no solution for these special hash types (for instane because they use hashfile in output etc)
12924 if ((hash_mode != 5200) &&
12925 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12926 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12927 (hash_mode != 9000))
12928 {
12929 FILE *fp = fopen (potfile, "rb");
12930
12931 if (fp != NULL)
12932 {
12933 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12934
12935 // to be safe work with a copy (because of line_len loop, i etc)
12936 // moved up here because it's easier to handle continue case
12937 // it's just 64kb
12938
12939 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12940
12941 while (!feof (fp))
12942 {
12943 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12944
12945 if (ptr == NULL) break;
12946
12947 int line_len = strlen (line_buf);
12948
12949 if (line_len == 0) continue;
12950
12951 int iter = MAX_CUT_TRIES;
12952
12953 for (int i = line_len - 1; i && iter; i--, line_len--)
12954 {
12955 if (line_buf[i] != ':') continue;
12956
12957 if (isSalted)
12958 {
12959 memset (hash_buf.salt, 0, sizeof (salt_t));
12960 }
12961
12962 hash_t *found = NULL;
12963
12964 if (hash_mode == 6800)
12965 {
12966 if (i < 64) // 64 = 16 * uint in salt_buf[]
12967 {
12968 // manipulate salt_buf
12969 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12970
12971 hash_buf.salt->salt_len = i;
12972
12973 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12974 }
12975 }
12976 else if (hash_mode == 2500)
12977 {
12978 if (i < 64) // 64 = 16 * uint in salt_buf[]
12979 {
12980 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12981 // manipulate salt_buf
12982
12983 memcpy (line_buf_cpy, line_buf, i);
12984
12985 char *mac2_pos = strrchr (line_buf_cpy, ':');
12986
12987 if (mac2_pos == NULL) continue;
12988
12989 mac2_pos[0] = 0;
12990 mac2_pos++;
12991
12992 if (strlen (mac2_pos) != 12) continue;
12993
12994 char *mac1_pos = strrchr (line_buf_cpy, ':');
12995
12996 if (mac1_pos == NULL) continue;
12997
12998 mac1_pos[0] = 0;
12999 mac1_pos++;
13000
13001 if (strlen (mac1_pos) != 12) continue;
13002
13003 uint essid_length = mac1_pos - line_buf_cpy - 1;
13004
13005 // here we need the ESSID
13006 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
13007
13008 hash_buf.salt->salt_len = essid_length;
13009
13010 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
13011
13012 if (found)
13013 {
13014 wpa_t *wpa = (wpa_t *) found->esalt;
13015
13016 // compare hex string(s) vs binary MAC address(es)
13017
13018 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13019 {
13020 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
13021 {
13022 found = NULL;
13023
13024 break;
13025 }
13026 }
13027
13028 // early skip ;)
13029 if (!found) continue;
13030
13031 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13032 {
13033 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13034 {
13035 found = NULL;
13036
13037 break;
13038 }
13039 }
13040 }
13041 }
13042 }
13043 else
13044 {
13045 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13046
13047 if (parser_status == PARSER_OK)
13048 {
13049 if (isSalted)
13050 {
13051 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13052 }
13053 else
13054 {
13055 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13056 }
13057 }
13058 }
13059
13060 if (found == NULL) continue;
13061
13062 if (!found->cracked) potfile_remove_cracks++;
13063
13064 found->cracked = 1;
13065
13066 if (found) break;
13067
13068 iter--;
13069 }
13070 }
13071
13072 myfree (line_buf_cpy);
13073
13074 myfree (line_buf);
13075
13076 fclose (fp);
13077 }
13078 }
13079
13080 if (esalt_size)
13081 {
13082 local_free (hash_buf.esalt);
13083 }
13084
13085 if (isSalted)
13086 {
13087 local_free (hash_buf.salt);
13088 }
13089
13090 local_free (hash_buf.digest);
13091 }
13092
13093 /**
13094 * Now generate all the buffers required for later
13095 */
13096
13097 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13098
13099 salt_t *salts_buf_new = NULL;
13100 void *esalts_buf_new = NULL;
13101
13102 if (isSalted)
13103 {
13104 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13105
13106 if (esalt_size)
13107 {
13108 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13109 }
13110 }
13111 else
13112 {
13113 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13114 }
13115
13116 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13117
13118 uint digests_cnt = hashes_cnt;
13119 uint digests_done = 0;
13120
13121 size_t size_digests = digests_cnt * dgst_size;
13122 size_t size_shown = digests_cnt * sizeof (uint);
13123
13124 uint *digests_shown = (uint *) mymalloc (size_shown);
13125 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13126
13127 uint salts_cnt = 0;
13128 uint salts_done = 0;
13129
13130 hashinfo_t **hash_info = NULL;
13131
13132 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13133 {
13134 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13135
13136 if (username && (remove || show))
13137 {
13138 uint user_pos;
13139
13140 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13141 {
13142 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13143
13144 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13145 }
13146 }
13147 }
13148
13149 uint *salts_shown = (uint *) mymalloc (size_shown);
13150
13151 salt_t *salt_buf;
13152
13153 {
13154 // copied from inner loop
13155
13156 salt_buf = &salts_buf_new[salts_cnt];
13157
13158 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13159
13160 if (esalt_size)
13161 {
13162 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13163 }
13164
13165 salt_buf->digests_cnt = 0;
13166 salt_buf->digests_done = 0;
13167 salt_buf->digests_offset = 0;
13168
13169 salts_cnt++;
13170 }
13171
13172 if (hashes_buf[0].cracked == 1)
13173 {
13174 digests_shown[0] = 1;
13175
13176 digests_done++;
13177
13178 salt_buf->digests_done++;
13179 }
13180
13181 salt_buf->digests_cnt++;
13182
13183 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13184
13185 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13186 {
13187 hash_info[0] = hashes_buf[0].hash_info;
13188 }
13189
13190 // copy from inner loop
13191
13192 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13193 {
13194 if (isSalted)
13195 {
13196 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13197 {
13198 salt_buf = &salts_buf_new[salts_cnt];
13199
13200 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13201
13202 if (esalt_size)
13203 {
13204 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13205 }
13206
13207 salt_buf->digests_cnt = 0;
13208 salt_buf->digests_done = 0;
13209 salt_buf->digests_offset = hashes_pos;
13210
13211 salts_cnt++;
13212 }
13213 }
13214
13215 if (hashes_buf[hashes_pos].cracked == 1)
13216 {
13217 digests_shown[hashes_pos] = 1;
13218
13219 digests_done++;
13220
13221 salt_buf->digests_done++;
13222 }
13223
13224 salt_buf->digests_cnt++;
13225
13226 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13227
13228 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13229 {
13230 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13231 }
13232 }
13233
13234 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13235 {
13236 salt_t *salt_buf = &salts_buf_new[salt_pos];
13237
13238 if (salt_buf->digests_done == salt_buf->digests_cnt)
13239 {
13240 salts_shown[salt_pos] = 1;
13241
13242 salts_done++;
13243 }
13244
13245 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13246 }
13247
13248 local_free (digests_buf);
13249 local_free (salts_buf);
13250 local_free (esalts_buf);
13251
13252 digests_buf = digests_buf_new;
13253 salts_buf = salts_buf_new;
13254 esalts_buf = esalts_buf_new;
13255
13256 local_free (hashes_buf);
13257
13258 /**
13259 * special modification not set from parser
13260 */
13261
13262 switch (hash_mode)
13263 {
13264 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13265 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13266 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13267 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13268 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13269 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13270 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13271 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13272 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13273 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13274 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13275 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13276 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13277 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13278 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13279 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13280 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13281 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13282 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13283 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13284 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13285 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13286 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13287 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13288 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13289 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13290 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13291 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13292 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13293 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13294 }
13295
13296 if (truecrypt_keyfiles)
13297 {
13298 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13299
13300 char *keyfiles = strdup (truecrypt_keyfiles);
13301
13302 char *keyfile = strtok (keyfiles, ",");
13303
13304 do
13305 {
13306 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13307
13308 } while ((keyfile = strtok (NULL, ",")) != NULL);
13309
13310 free (keyfiles);
13311 }
13312
13313 if (veracrypt_keyfiles)
13314 {
13315 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13316
13317 char *keyfiles = strdup (veracrypt_keyfiles);
13318
13319 char *keyfile = strtok (keyfiles, ",");
13320
13321 do
13322 {
13323 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13324
13325 } while ((keyfile = strtok (NULL, ",")) != NULL);
13326
13327 free (keyfiles);
13328 }
13329
13330 data.digests_cnt = digests_cnt;
13331 data.digests_done = digests_done;
13332 data.digests_buf = digests_buf;
13333 data.digests_shown = digests_shown;
13334 data.digests_shown_tmp = digests_shown_tmp;
13335
13336 data.salts_cnt = salts_cnt;
13337 data.salts_done = salts_done;
13338 data.salts_buf = salts_buf;
13339 data.salts_shown = salts_shown;
13340
13341 data.esalts_buf = esalts_buf;
13342 data.hash_info = hash_info;
13343
13344 /**
13345 * Automatic Optimizers
13346 */
13347
13348 if (salts_cnt == 1)
13349 opti_type |= OPTI_TYPE_SINGLE_SALT;
13350
13351 if (digests_cnt == 1)
13352 opti_type |= OPTI_TYPE_SINGLE_HASH;
13353
13354 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13355 opti_type |= OPTI_TYPE_NOT_ITERATED;
13356
13357 if (attack_mode == ATTACK_MODE_BF)
13358 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13359
13360 data.opti_type = opti_type;
13361
13362 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13363 {
13364 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13365 {
13366 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13367 {
13368 if (opts_type & OPTS_TYPE_ST_ADD80)
13369 {
13370 opts_type &= ~OPTS_TYPE_ST_ADD80;
13371 opts_type |= OPTS_TYPE_PT_ADD80;
13372 }
13373
13374 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13375 {
13376 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13377 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13378 }
13379
13380 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13381 {
13382 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13383 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13384 }
13385 }
13386 }
13387 }
13388
13389 /**
13390 * Some algorithm, like descrypt, can benefit from JIT compilation
13391 */
13392
13393 int force_jit_compilation = -1;
13394
13395 if (hash_mode == 8900)
13396 {
13397 force_jit_compilation = 8900;
13398 }
13399 else if (hash_mode == 9300)
13400 {
13401 force_jit_compilation = 8900;
13402 }
13403 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13404 {
13405 force_jit_compilation = 1500;
13406 }
13407
13408 /**
13409 * generate bitmap tables
13410 */
13411
13412 const uint bitmap_shift1 = 5;
13413 const uint bitmap_shift2 = 13;
13414
13415 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13416
13417 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13418 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13419 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13420 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13421 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13422 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13423 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13424 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13425
13426 uint bitmap_bits;
13427 uint bitmap_nums;
13428 uint bitmap_mask;
13429 uint bitmap_size;
13430
13431 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13432 {
13433 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13434
13435 bitmap_nums = 1 << bitmap_bits;
13436
13437 bitmap_mask = bitmap_nums - 1;
13438
13439 bitmap_size = bitmap_nums * sizeof (uint);
13440
13441 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13442
13443 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;
13444 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;
13445
13446 break;
13447 }
13448
13449 bitmap_nums = 1 << bitmap_bits;
13450
13451 bitmap_mask = bitmap_nums - 1;
13452
13453 bitmap_size = bitmap_nums * sizeof (uint);
13454
13455 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);
13456 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);
13457
13458 /**
13459 * prepare quick rule
13460 */
13461
13462 data.rule_buf_l = rule_buf_l;
13463 data.rule_buf_r = rule_buf_r;
13464
13465 int rule_len_l = (int) strlen (rule_buf_l);
13466 int rule_len_r = (int) strlen (rule_buf_r);
13467
13468 data.rule_len_l = rule_len_l;
13469 data.rule_len_r = rule_len_r;
13470
13471 /**
13472 * load rules
13473 */
13474
13475 uint *all_kernel_rules_cnt = NULL;
13476
13477 kernel_rule_t **all_kernel_rules_buf = NULL;
13478
13479 if (rp_files_cnt)
13480 {
13481 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13482
13483 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13484 }
13485
13486 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13487
13488 int rule_len = 0;
13489
13490 for (uint i = 0; i < rp_files_cnt; i++)
13491 {
13492 uint kernel_rules_avail = 0;
13493
13494 uint kernel_rules_cnt = 0;
13495
13496 kernel_rule_t *kernel_rules_buf = NULL;
13497
13498 char *rp_file = rp_files[i];
13499
13500 char in[BLOCK_SIZE] = { 0 };
13501 char out[BLOCK_SIZE] = { 0 };
13502
13503 FILE *fp = NULL;
13504
13505 uint rule_line = 0;
13506
13507 if ((fp = fopen (rp_file, "rb")) == NULL)
13508 {
13509 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13510
13511 return (-1);
13512 }
13513
13514 while (!feof (fp))
13515 {
13516 memset (rule_buf, 0, HCBUFSIZ);
13517
13518 rule_len = fgetl (fp, rule_buf);
13519
13520 rule_line++;
13521
13522 if (rule_len == 0) continue;
13523
13524 if (rule_buf[0] == '#') continue;
13525
13526 if (kernel_rules_avail == kernel_rules_cnt)
13527 {
13528 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13529
13530 kernel_rules_avail += INCR_RULES;
13531 }
13532
13533 memset (in, 0, BLOCK_SIZE);
13534 memset (out, 0, BLOCK_SIZE);
13535
13536 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13537
13538 if (result == -1)
13539 {
13540 log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13541
13542 continue;
13543 }
13544
13545 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13546 {
13547 log_info ("WARNING: Cannot convert rule for use on OpenCL device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13548
13549 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13550
13551 continue;
13552 }
13553
13554 /* its so slow
13555 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13556 {
13557 log_info ("Duplicate rule for use on OpenCL device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13558
13559 continue;
13560 }
13561 */
13562
13563 kernel_rules_cnt++;
13564 }
13565
13566 fclose (fp);
13567
13568 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13569
13570 all_kernel_rules_buf[i] = kernel_rules_buf;
13571 }
13572
13573 /**
13574 * merge rules or automatic rule generator
13575 */
13576
13577 uint kernel_rules_cnt = 0;
13578
13579 kernel_rule_t *kernel_rules_buf = NULL;
13580
13581 if (attack_mode == ATTACK_MODE_STRAIGHT)
13582 {
13583 if (rp_files_cnt)
13584 {
13585 kernel_rules_cnt = 1;
13586
13587 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13588
13589 repeats[0] = kernel_rules_cnt;
13590
13591 for (uint i = 0; i < rp_files_cnt; i++)
13592 {
13593 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13594
13595 repeats[i + 1] = kernel_rules_cnt;
13596 }
13597
13598 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13599
13600 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13601
13602 for (uint i = 0; i < kernel_rules_cnt; i++)
13603 {
13604 uint out_pos = 0;
13605
13606 kernel_rule_t *out = &kernel_rules_buf[i];
13607
13608 for (uint j = 0; j < rp_files_cnt; j++)
13609 {
13610 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13611 uint in_pos;
13612
13613 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13614
13615 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13616 {
13617 if (out_pos == RULES_MAX - 1)
13618 {
13619 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13620
13621 break;
13622 }
13623
13624 out->cmds[out_pos] = in->cmds[in_pos];
13625 }
13626 }
13627 }
13628
13629 local_free (repeats);
13630 }
13631 else if (rp_gen)
13632 {
13633 uint kernel_rules_avail = 0;
13634
13635 while (kernel_rules_cnt < rp_gen)
13636 {
13637 if (kernel_rules_avail == kernel_rules_cnt)
13638 {
13639 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13640
13641 kernel_rules_avail += INCR_RULES;
13642 }
13643
13644 memset (rule_buf, 0, HCBUFSIZ);
13645
13646 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13647
13648 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13649
13650 kernel_rules_cnt++;
13651 }
13652 }
13653 }
13654
13655 myfree (rule_buf);
13656
13657 /**
13658 * generate NOP rules
13659 */
13660
13661 if ((rp_files_cnt == 0) && (rp_gen == 0))
13662 {
13663 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13664
13665 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13666
13667 kernel_rules_cnt++;
13668 }
13669
13670 data.kernel_rules_cnt = kernel_rules_cnt;
13671 data.kernel_rules_buf = kernel_rules_buf;
13672
13673 if (kernel_rules_cnt == 0)
13674 {
13675 log_error ("ERROR: No valid rules left");
13676
13677 return (-1);
13678 }
13679
13680 /**
13681 * OpenCL platforms: detect
13682 */
13683
13684 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13685 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13686
13687 cl_uint platforms_cnt = 0;
13688 cl_uint platform_devices_cnt = 0;
13689
13690 if (keyspace == 0)
13691 {
13692 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13693
13694 if (platforms_cnt == 0)
13695 {
13696 log_info ("");
13697 log_info ("ATTENTION! No OpenCL compatible platform found");
13698 log_info ("");
13699 log_info ("You're probably missing the OpenCL runtime installation");
13700 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13701 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13702 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13703 log_info ("");
13704
13705 return (-1);
13706 }
13707
13708 if (opencl_platforms_filter != (uint) -1)
13709 {
13710 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13711
13712 if (opencl_platforms_filter > platform_cnt_mask)
13713 {
13714 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13715
13716 return (-1);
13717 }
13718 }
13719 }
13720
13721 if (opencl_device_types == NULL)
13722 {
13723 /**
13724 * OpenCL device types:
13725 * 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.
13726 */
13727
13728 cl_device_type device_types_all = 0;
13729
13730 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13731 {
13732 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13733
13734 cl_platform_id platform = platforms[platform_id];
13735
13736 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13737
13738 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13739 {
13740 cl_device_id device = platform_devices[platform_devices_id];
13741
13742 cl_device_type device_type;
13743
13744 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13745
13746 device_types_all |= device_type;
13747 }
13748 }
13749
13750 // In such a case, automatically enable CPU device type support, since it's disabled by default.
13751
13752 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13753 {
13754 device_types_filter |= CL_DEVICE_TYPE_CPU;
13755 }
13756
13757 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13758 // If we have a CPU device, force it to be used
13759
13760 if (stdout_flag == 1)
13761 {
13762 if (device_types_all & CL_DEVICE_TYPE_CPU)
13763 {
13764 device_types_filter = CL_DEVICE_TYPE_CPU;
13765 }
13766 }
13767 }
13768
13769 /**
13770 * OpenCL devices: simply push all devices from all platforms into the same device array
13771 */
13772
13773 int need_adl = 0;
13774 int need_nvapi = 0;
13775 int need_nvml = 0;
13776 int need_xnvctrl = 0;
13777
13778 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13779
13780 data.devices_param = devices_param;
13781
13782 uint devices_cnt = 0;
13783
13784 uint devices_active = 0;
13785
13786 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13787 {
13788 cl_platform_id platform = platforms[platform_id];
13789
13790 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13791
13792 char platform_vendor[INFOSZ] = { 0 };
13793
13794 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13795
13796 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13797 // this causes trouble with vendor id based macros
13798 // we'll assign generic to those without special optimization available
13799
13800 cl_uint platform_vendor_id = 0;
13801
13802 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13803 {
13804 platform_vendor_id = VENDOR_ID_AMD;
13805 }
13806 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13807 {
13808 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13809 }
13810 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13811 {
13812 platform_vendor_id = VENDOR_ID_APPLE;
13813 }
13814 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13815 {
13816 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13817 }
13818 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13819 {
13820 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13821 }
13822 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13823 {
13824 platform_vendor_id = VENDOR_ID_MESA;
13825 }
13826 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13827 {
13828 platform_vendor_id = VENDOR_ID_NV;
13829 }
13830 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13831 {
13832 platform_vendor_id = VENDOR_ID_POCL;
13833 }
13834 else
13835 {
13836 platform_vendor_id = VENDOR_ID_GENERIC;
13837 }
13838
13839 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13840
13841 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13842 {
13843 if (machine_readable == 0)
13844 {
13845 if (platform_skipped == 0)
13846 {
13847 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13848
13849 char line[256] = { 0 };
13850
13851 for (int i = 0; i < len; i++) line[i] = '=';
13852
13853 log_info (line);
13854 }
13855 else
13856 {
13857 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13858 log_info ("");
13859 }
13860 }
13861 }
13862
13863 if (platform_skipped == 1) continue;
13864
13865 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13866 {
13867 size_t param_value_size = 0;
13868
13869 const uint device_id = devices_cnt;
13870
13871 hc_device_param_t *device_param = &data.devices_param[device_id];
13872
13873 device_param->platform_vendor_id = platform_vendor_id;
13874
13875 device_param->device = platform_devices[platform_devices_id];
13876
13877 device_param->device_id = device_id;
13878
13879 device_param->platform_devices_id = platform_devices_id;
13880
13881 // device_type
13882
13883 cl_device_type device_type;
13884
13885 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13886
13887 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13888
13889 device_param->device_type = device_type;
13890
13891 // device_name
13892
13893 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13894
13895 char *device_name = (char *) mymalloc (param_value_size);
13896
13897 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13898
13899 device_param->device_name = device_name;
13900
13901 // device_vendor
13902
13903 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13904
13905 char *device_vendor = (char *) mymalloc (param_value_size);
13906
13907 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13908
13909 device_param->device_vendor = device_vendor;
13910
13911 cl_uint device_vendor_id = 0;
13912
13913 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13914 {
13915 device_vendor_id = VENDOR_ID_AMD;
13916 }
13917 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13918 {
13919 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13920 }
13921 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13922 {
13923 device_vendor_id = VENDOR_ID_APPLE;
13924 }
13925 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13926 {
13927 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13928 }
13929 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13930 {
13931 device_vendor_id = VENDOR_ID_INTEL_SDK;
13932 }
13933 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13934 {
13935 device_vendor_id = VENDOR_ID_MESA;
13936 }
13937 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13938 {
13939 device_vendor_id = VENDOR_ID_NV;
13940 }
13941 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13942 {
13943 device_vendor_id = VENDOR_ID_POCL;
13944 }
13945 else
13946 {
13947 device_vendor_id = VENDOR_ID_GENERIC;
13948 }
13949
13950 device_param->device_vendor_id = device_vendor_id;
13951
13952 // tuning db
13953
13954 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13955
13956 // device_version
13957
13958 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13959
13960 char *device_version = (char *) mymalloc (param_value_size);
13961
13962 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13963
13964 device_param->device_version = device_version;
13965
13966 // device_opencl_version
13967
13968 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13969
13970 char *device_opencl_version = (char *) mymalloc (param_value_size);
13971
13972 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13973
13974 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13975
13976 myfree (device_opencl_version);
13977
13978 // vector_width
13979
13980 cl_uint vector_width;
13981
13982 if (opencl_vector_width_chgd == 0)
13983 {
13984 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13985 {
13986 if (opti_type & OPTI_TYPE_USES_BITS_64)
13987 {
13988 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13989 }
13990 else
13991 {
13992 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13993 }
13994 }
13995 else
13996 {
13997 vector_width = (cl_uint) tuningdb_entry->vector_width;
13998 }
13999 }
14000 else
14001 {
14002 vector_width = opencl_vector_width;
14003 }
14004
14005 if (vector_width > 16) vector_width = 16;
14006
14007 device_param->vector_width = vector_width;
14008
14009 // max_compute_units
14010
14011 cl_uint device_processors;
14012
14013 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
14014
14015 device_param->device_processors = device_processors;
14016
14017 // device_maxmem_alloc
14018 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
14019
14020 cl_ulong device_maxmem_alloc;
14021
14022 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
14023
14024 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
14025
14026 // device_global_mem
14027
14028 cl_ulong device_global_mem;
14029
14030 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14031
14032 device_param->device_global_mem = device_global_mem;
14033
14034 // max_work_group_size
14035
14036 size_t device_maxworkgroup_size;
14037
14038 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14039
14040 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14041
14042 // max_clock_frequency
14043
14044 cl_uint device_maxclock_frequency;
14045
14046 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14047
14048 device_param->device_maxclock_frequency = device_maxclock_frequency;
14049
14050 // device_endian_little
14051
14052 cl_bool device_endian_little;
14053
14054 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14055
14056 if (device_endian_little == CL_FALSE)
14057 {
14058 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14059
14060 device_param->skipped = 1;
14061 }
14062
14063 // device_available
14064
14065 cl_bool device_available;
14066
14067 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14068
14069 if (device_available == CL_FALSE)
14070 {
14071 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14072
14073 device_param->skipped = 1;
14074 }
14075
14076 // device_compiler_available
14077
14078 cl_bool device_compiler_available;
14079
14080 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14081
14082 if (device_compiler_available == CL_FALSE)
14083 {
14084 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14085
14086 device_param->skipped = 1;
14087 }
14088
14089 // device_execution_capabilities
14090
14091 cl_device_exec_capabilities device_execution_capabilities;
14092
14093 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14094
14095 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14096 {
14097 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14098
14099 device_param->skipped = 1;
14100 }
14101
14102 // device_extensions
14103
14104 size_t device_extensions_size;
14105
14106 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14107
14108 char *device_extensions = mymalloc (device_extensions_size + 1);
14109
14110 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14111
14112 if (strstr (device_extensions, "base_atomics") == 0)
14113 {
14114 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14115
14116 device_param->skipped = 1;
14117 }
14118
14119 if (strstr (device_extensions, "byte_addressable_store") == 0)
14120 {
14121 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14122
14123 device_param->skipped = 1;
14124 }
14125
14126 myfree (device_extensions);
14127
14128 // device_local_mem_size
14129
14130 cl_ulong device_local_mem_size;
14131
14132 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14133
14134 if (device_local_mem_size < 32768)
14135 {
14136 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14137
14138 device_param->skipped = 1;
14139 }
14140
14141 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14142 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14143 // This results in both utilizing it for 50%
14144 // However, Intel has much better SIMD control over their own hardware
14145 // It makes sense to give them full control over their own hardware
14146
14147 if (device_type & CL_DEVICE_TYPE_CPU)
14148 {
14149 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14150 {
14151 if (data.force == 0)
14152 {
14153 if (algorithm_pos == 0)
14154 {
14155 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14156 log_info (" You can use --force to override this but do not post error reports if you do so");
14157 }
14158
14159 device_param->skipped = 1;
14160 }
14161 }
14162 }
14163
14164 // skipped
14165
14166 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14167 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14168
14169 // driver_version
14170
14171 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14172
14173 char *driver_version = (char *) mymalloc (param_value_size);
14174
14175 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14176
14177 device_param->driver_version = driver_version;
14178
14179 // device_name_chksum
14180
14181 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14182
14183 #if __x86_64__
14184 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);
14185 #else
14186 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);
14187 #endif
14188
14189 uint device_name_digest[4] = { 0 };
14190
14191 md5_64 ((uint *) device_name_chksum, device_name_digest);
14192
14193 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14194
14195 device_param->device_name_chksum = device_name_chksum;
14196
14197 // vendor specific
14198
14199 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14200 {
14201 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14202 {
14203 need_adl = 1;
14204 }
14205
14206 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14207 {
14208 need_nvml = 1;
14209
14210 #ifdef LINUX
14211 need_xnvctrl = 1;
14212 #endif
14213
14214 #ifdef WIN
14215 need_nvapi = 1;
14216 #endif
14217 }
14218 }
14219
14220 if (device_type & CL_DEVICE_TYPE_GPU)
14221 {
14222 if (device_vendor_id == VENDOR_ID_NV)
14223 {
14224 cl_uint kernel_exec_timeout = 0;
14225
14226 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14227
14228 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14229
14230 device_param->kernel_exec_timeout = kernel_exec_timeout;
14231
14232 cl_uint sm_minor = 0;
14233 cl_uint sm_major = 0;
14234
14235 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14236 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14237
14238 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14239 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14240
14241 device_param->sm_minor = sm_minor;
14242 device_param->sm_major = sm_major;
14243
14244 // CPU burning loop damper
14245 // Value is given as number between 0-100
14246 // By default 100%
14247
14248 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14249
14250 if (nvidia_spin_damp_chgd == 0)
14251 {
14252 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14253 {
14254 /**
14255 * the workaround is not a friend of rule based attacks
14256 * the words from the wordlist combined with fast and slow rules cause
14257 * fluctuations which cause inaccurate wait time estimations
14258 * using a reduced damping percentage almost compensates this
14259 */
14260
14261 device_param->nvidia_spin_damp = 64;
14262 }
14263 }
14264
14265 device_param->nvidia_spin_damp /= 100;
14266 }
14267 }
14268
14269 // display results
14270
14271 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14272 {
14273 if (machine_readable == 0)
14274 {
14275 if (device_param->skipped == 0)
14276 {
14277 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14278 device_id + 1,
14279 device_name,
14280 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14281 (unsigned int) (device_global_mem / 1024 / 1024),
14282 (unsigned int) device_processors);
14283 }
14284 else
14285 {
14286 log_info ("- Device #%u: %s, skipped",
14287 device_id + 1,
14288 device_name);
14289 }
14290 }
14291 }
14292
14293 // common driver check
14294
14295 if (device_param->skipped == 0)
14296 {
14297 if (device_type & CL_DEVICE_TYPE_GPU)
14298 {
14299 if (platform_vendor_id == VENDOR_ID_AMD)
14300 {
14301 int catalyst_check = (force == 1) ? 0 : 1;
14302
14303 int catalyst_warn = 0;
14304
14305 int catalyst_broken = 0;
14306
14307 if (catalyst_check == 1)
14308 {
14309 catalyst_warn = 1;
14310
14311 // v14.9 and higher
14312 if (atoi (device_param->driver_version) >= 1573)
14313 {
14314 catalyst_warn = 0;
14315 }
14316
14317 catalyst_check = 0;
14318 }
14319
14320 if (catalyst_broken == 1)
14321 {
14322 log_info ("");
14323 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14324 log_info ("It passes over cracked hashes and will not report them as cracked");
14325 log_info ("You are STRONGLY encouraged not to use it");
14326 log_info ("You can use --force to override this but do not post error reports if you do so");
14327 log_info ("");
14328
14329 return (-1);
14330 }
14331
14332 if (catalyst_warn == 1)
14333 {
14334 log_info ("");
14335 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14336 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14337 log_info ("See hashcat's homepage for official supported catalyst drivers");
14338 #ifdef _WIN
14339 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14340 #endif
14341 log_info ("You can use --force to override this but do not post error reports if you do so");
14342 log_info ("");
14343
14344 return (-1);
14345 }
14346 }
14347 else if (platform_vendor_id == VENDOR_ID_NV)
14348 {
14349 if (device_param->kernel_exec_timeout != 0)
14350 {
14351 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);
14352 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14353 }
14354 }
14355 }
14356
14357 /* turns out pocl still creates segfaults (because of llvm)
14358 if (device_type & CL_DEVICE_TYPE_CPU)
14359 {
14360 if (platform_vendor_id == VENDOR_ID_AMD)
14361 {
14362 if (force == 0)
14363 {
14364 log_info ("");
14365 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14366 log_info ("You are STRONGLY encouraged not to use it");
14367 log_info ("You can use --force to override this but do not post error reports if you do so");
14368 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14369 log_info ("");
14370
14371 return (-1);
14372 }
14373 }
14374 }
14375 */
14376
14377 /**
14378 * kernel accel and loops tuning db adjustment
14379 */
14380
14381 device_param->kernel_accel_min = 1;
14382 device_param->kernel_accel_max = 1024;
14383
14384 device_param->kernel_loops_min = 1;
14385 device_param->kernel_loops_max = 1024;
14386
14387 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14388
14389 if (tuningdb_entry)
14390 {
14391 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14392 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14393
14394 if (_kernel_accel)
14395 {
14396 device_param->kernel_accel_min = _kernel_accel;
14397 device_param->kernel_accel_max = _kernel_accel;
14398 }
14399
14400 if (_kernel_loops)
14401 {
14402 if (workload_profile == 1)
14403 {
14404 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14405 }
14406 else if (workload_profile == 2)
14407 {
14408 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14409 }
14410
14411 device_param->kernel_loops_min = _kernel_loops;
14412 device_param->kernel_loops_max = _kernel_loops;
14413 }
14414 }
14415
14416 // commandline parameters overwrite tuningdb entries
14417
14418 if (kernel_accel)
14419 {
14420 device_param->kernel_accel_min = kernel_accel;
14421 device_param->kernel_accel_max = kernel_accel;
14422 }
14423
14424 if (kernel_loops)
14425 {
14426 device_param->kernel_loops_min = kernel_loops;
14427 device_param->kernel_loops_max = kernel_loops;
14428 }
14429
14430 /**
14431 * activate device
14432 */
14433
14434 devices_active++;
14435 }
14436
14437 // next please
14438
14439 devices_cnt++;
14440 }
14441
14442 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14443 {
14444 if (machine_readable == 0)
14445 {
14446 log_info ("");
14447 }
14448 }
14449 }
14450
14451 if (keyspace == 0 && devices_active == 0)
14452 {
14453 log_error ("ERROR: No devices found/left");
14454
14455 return (-1);
14456 }
14457
14458 // 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)
14459
14460 if (devices_filter != (uint) -1)
14461 {
14462 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14463
14464 if (devices_filter > devices_cnt_mask)
14465 {
14466 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14467
14468 return (-1);
14469 }
14470 }
14471
14472 data.devices_cnt = devices_cnt;
14473
14474 data.devices_active = devices_active;
14475
14476 /**
14477 * HM devices: init
14478 */
14479
14480 #ifdef HAVE_HWMON
14481 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14482 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14483 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14484 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } };
14485
14486 if (gpu_temp_disable == 0)
14487 {
14488 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14489 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14490 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14491 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14492
14493 data.hm_adl = NULL;
14494 data.hm_nvapi = NULL;
14495 data.hm_nvml = NULL;
14496 data.hm_xnvctrl = NULL;
14497
14498 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14499 {
14500 data.hm_nvml = nvml;
14501 }
14502
14503 if (data.hm_nvml)
14504 {
14505 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14506 {
14507 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14508
14509 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14510
14511 int tmp_out = 0;
14512
14513 for (int i = 0; i < tmp_in; i++)
14514 {
14515 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14516 }
14517
14518 for (int i = 0; i < tmp_out; i++)
14519 {
14520 unsigned int speed;
14521
14522 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14523
14524 // doesn't seem to create any advantages
14525 //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14526 //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14527 }
14528 }
14529 }
14530
14531 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14532 {
14533 data.hm_nvapi = nvapi;
14534 }
14535
14536 if (data.hm_nvapi)
14537 {
14538 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14539 {
14540 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14541
14542 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14543
14544 int tmp_out = 0;
14545
14546 for (int i = 0; i < tmp_in; i++)
14547 {
14548 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14549 }
14550 }
14551 }
14552
14553 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14554 {
14555 data.hm_xnvctrl = xnvctrl;
14556 }
14557
14558 if (data.hm_xnvctrl)
14559 {
14560 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14561 {
14562 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14563 {
14564 hc_device_param_t *device_param = &data.devices_param[device_id];
14565
14566 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14567
14568 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14569
14570 int speed = 0;
14571
14572 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14573 }
14574 }
14575 }
14576
14577 if ((need_adl == 1) && (adl_init (adl) == 0))
14578 {
14579 data.hm_adl = adl;
14580 }
14581
14582 if (data.hm_adl)
14583 {
14584 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14585 {
14586 // total number of adapters
14587
14588 int hm_adapters_num;
14589
14590 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14591
14592 // adapter info
14593
14594 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14595
14596 if (lpAdapterInfo == NULL) return (-1);
14597
14598 // get a list (of ids of) valid/usable adapters
14599
14600 int num_adl_adapters = 0;
14601
14602 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14603
14604 if (num_adl_adapters > 0)
14605 {
14606 hc_thread_mutex_lock (mux_adl);
14607
14608 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14609
14610 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14611
14612 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14613 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14614
14615 hc_thread_mutex_unlock (mux_adl);
14616 }
14617
14618 myfree (valid_adl_device_list);
14619 myfree (lpAdapterInfo);
14620 }
14621 }
14622
14623 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14624 {
14625 gpu_temp_disable = 1;
14626 }
14627 }
14628
14629 /**
14630 * OpenCL devices: allocate buffer for device specific information
14631 */
14632
14633 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14634
14635 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14636
14637 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14638
14639 /**
14640 * User-defined GPU temp handling
14641 */
14642
14643 if (gpu_temp_disable == 1)
14644 {
14645 gpu_temp_abort = 0;
14646 gpu_temp_retain = 0;
14647 }
14648
14649 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14650 {
14651 if (gpu_temp_abort < gpu_temp_retain)
14652 {
14653 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14654
14655 return (-1);
14656 }
14657 }
14658
14659 data.gpu_temp_disable = gpu_temp_disable;
14660 data.gpu_temp_abort = gpu_temp_abort;
14661 data.gpu_temp_retain = gpu_temp_retain;
14662 #endif
14663
14664 /**
14665 * enable custom signal handler(s)
14666 */
14667
14668 if (benchmark == 0)
14669 {
14670 hc_signal (sigHandler_default);
14671 }
14672 else
14673 {
14674 hc_signal (sigHandler_benchmark);
14675 }
14676
14677 /**
14678 * inform the user
14679 */
14680
14681 if (data.quiet == 0)
14682 {
14683 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14684
14685 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);
14686
14687 if (attack_mode == ATTACK_MODE_STRAIGHT)
14688 {
14689 log_info ("Rules: %u", kernel_rules_cnt);
14690 }
14691
14692 if (opti_type)
14693 {
14694 log_info ("Applicable Optimizers:");
14695
14696 for (uint i = 0; i < 32; i++)
14697 {
14698 const uint opti_bit = 1u << i;
14699
14700 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14701 }
14702 }
14703
14704 /**
14705 * Watchdog and Temperature balance
14706 */
14707
14708 #ifdef HAVE_HWMON
14709 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14710 {
14711 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14712 }
14713
14714 if (gpu_temp_abort == 0)
14715 {
14716 log_info ("Watchdog: Temperature abort trigger disabled");
14717 }
14718 else
14719 {
14720 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14721 }
14722
14723 if (gpu_temp_retain == 0)
14724 {
14725 log_info ("Watchdog: Temperature retain trigger disabled");
14726 }
14727 else
14728 {
14729 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14730 }
14731
14732 if (data.quiet == 0) log_info ("");
14733 #endif
14734 }
14735
14736 #ifdef HAVE_HWMON
14737
14738 /**
14739 * HM devices: copy
14740 */
14741
14742 if (gpu_temp_disable == 0)
14743 {
14744 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14745 {
14746 hc_device_param_t *device_param = &data.devices_param[device_id];
14747
14748 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14749
14750 if (device_param->skipped) continue;
14751
14752 const uint platform_devices_id = device_param->platform_devices_id;
14753
14754 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14755 {
14756 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14757 data.hm_device[device_id].nvapi = 0;
14758 data.hm_device[device_id].nvml = 0;
14759 data.hm_device[device_id].xnvctrl = 0;
14760 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14761 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14762 data.hm_device[device_id].fan_set_supported = 0;
14763 }
14764
14765 if (device_param->device_vendor_id == VENDOR_ID_NV)
14766 {
14767 data.hm_device[device_id].adl = 0;
14768 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14769 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14770 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14771 data.hm_device[device_id].od_version = 0;
14772 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14773 data.hm_device[device_id].fan_set_supported = 0;
14774 }
14775 }
14776 }
14777
14778 /**
14779 * powertune on user request
14780 */
14781
14782 if (powertune_enable == 1)
14783 {
14784 hc_thread_mutex_lock (mux_adl);
14785
14786 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14787 {
14788 hc_device_param_t *device_param = &data.devices_param[device_id];
14789
14790 if (device_param->skipped) continue;
14791
14792 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14793 {
14794 /**
14795 * Temporary fix:
14796 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14797 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14798 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14799 * Driver / ADL bug?
14800 */
14801
14802 if (data.hm_device[device_id].od_version == 6)
14803 {
14804 int ADL_rc;
14805
14806 // check powertune capabilities first, if not available then skip device
14807
14808 int powertune_supported = 0;
14809
14810 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14811 {
14812 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14813
14814 return (-1);
14815 }
14816
14817 // first backup current value, we will restore it later
14818
14819 if (powertune_supported != 0)
14820 {
14821 // powercontrol settings
14822
14823 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14824
14825 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14826 {
14827 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14828 }
14829
14830 if (ADL_rc != ADL_OK)
14831 {
14832 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14833
14834 return (-1);
14835 }
14836
14837 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14838 {
14839 log_error ("ERROR: Failed to set new ADL PowerControl values");
14840
14841 return (-1);
14842 }
14843
14844 // clocks
14845
14846 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14847
14848 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14849
14850 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)
14851 {
14852 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14853
14854 return (-1);
14855 }
14856
14857 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14858
14859 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14860
14861 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14862 {
14863 log_error ("ERROR: Failed to get ADL device capabilities");
14864
14865 return (-1);
14866 }
14867
14868 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14869 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14870
14871 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14872 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14873
14874 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14875 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14876
14877 // warning if profile has too low max values
14878
14879 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14880 {
14881 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14882 }
14883
14884 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14885 {
14886 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14887 }
14888
14889 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14890
14891 performance_state->iNumberOfPerformanceLevels = 2;
14892
14893 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14894 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14895 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14896 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14897
14898 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)
14899 {
14900 log_info ("ERROR: Failed to set ADL performance state");
14901
14902 return (-1);
14903 }
14904
14905 local_free (performance_state);
14906 }
14907
14908 // set powertune value only
14909
14910 if (powertune_supported != 0)
14911 {
14912 // powertune set
14913 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14914
14915 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14916 {
14917 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14918
14919 return (-1);
14920 }
14921
14922 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14923 {
14924 log_error ("ERROR: Failed to set new ADL PowerControl values");
14925
14926 return (-1);
14927 }
14928 }
14929 }
14930 }
14931
14932 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14933 {
14934 // first backup current value, we will restore it later
14935
14936 unsigned int limit;
14937
14938 int powertune_supported = 0;
14939
14940 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14941 {
14942 powertune_supported = 1;
14943 }
14944
14945 // if backup worked, activate the maximum allowed
14946
14947 if (powertune_supported != 0)
14948 {
14949 unsigned int minLimit;
14950 unsigned int maxLimit;
14951
14952 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14953 {
14954 if (maxLimit > 0)
14955 {
14956 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14957 {
14958 // now we can be sure we need to reset later
14959
14960 nvml_power_limit[device_id] = limit;
14961 }
14962 }
14963 }
14964 }
14965 }
14966 }
14967
14968 hc_thread_mutex_unlock (mux_adl);
14969 }
14970
14971 #endif // HAVE_HWMON
14972
14973 #ifdef DEBUG
14974 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14975 #endif
14976
14977 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14978
14979 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14980 {
14981 /**
14982 * host buffer
14983 */
14984
14985 hc_device_param_t *device_param = &data.devices_param[device_id];
14986
14987 if (device_param->skipped) continue;
14988
14989 /**
14990 * device properties
14991 */
14992
14993 const char *device_name_chksum = device_param->device_name_chksum;
14994 const u32 device_processors = device_param->device_processors;
14995
14996 /**
14997 * create context for each device
14998 */
14999
15000 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
15001
15002 /**
15003 * create command-queue
15004 */
15005
15006 // not supported with NV
15007 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15008
15009 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
15010
15011 /**
15012 * kernel threads: some algorithms need a fixed kernel-threads count
15013 * because of shared memory usage or bitslice
15014 * there needs to be some upper limit, otherwise there's too much overhead
15015 */
15016
15017 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15018
15019 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15020 {
15021 kernel_threads = KERNEL_THREADS_MAX_CPU;
15022 }
15023
15024 if (hash_mode == 1500) kernel_threads = 64; // DES
15025 if (hash_mode == 3000) kernel_threads = 64; // DES
15026 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15027 if (hash_mode == 7500) kernel_threads = 64; // RC4
15028 if (hash_mode == 8900) kernel_threads = 64; // Scrypt
15029 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15030 if (hash_mode == 9300) kernel_threads = 64; // Scrypt
15031 if (hash_mode == 9700) kernel_threads = 64; // RC4
15032 if (hash_mode == 9710) kernel_threads = 64; // RC4
15033 if (hash_mode == 9800) kernel_threads = 64; // RC4
15034 if (hash_mode == 9810) kernel_threads = 64; // RC4
15035 if (hash_mode == 10400) kernel_threads = 64; // RC4
15036 if (hash_mode == 10410) kernel_threads = 64; // RC4
15037 if (hash_mode == 10500) kernel_threads = 64; // RC4
15038 if (hash_mode == 13100) kernel_threads = 64; // RC4
15039
15040 device_param->kernel_threads = kernel_threads;
15041
15042 device_param->hardware_power = device_processors * kernel_threads;
15043
15044 /**
15045 * create input buffers on device : calculate size of fixed memory buffers
15046 */
15047
15048 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15049 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15050
15051 device_param->size_root_css = size_root_css;
15052 device_param->size_markov_css = size_markov_css;
15053
15054 size_t size_results = sizeof (uint);
15055
15056 device_param->size_results = size_results;
15057
15058 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15059 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15060
15061 size_t size_plains = digests_cnt * sizeof (plain_t);
15062 size_t size_salts = salts_cnt * sizeof (salt_t);
15063 size_t size_esalts = salts_cnt * esalt_size;
15064
15065 device_param->size_plains = size_plains;
15066 device_param->size_digests = size_digests;
15067 device_param->size_shown = size_shown;
15068 device_param->size_salts = size_salts;
15069
15070 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15071 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15072 size_t size_tm = 32 * sizeof (bs_word_t);
15073
15074 // scryptV stuff
15075
15076 size_t size_scrypt = 4;
15077
15078 if ((hash_mode == 8900) || (hash_mode == 9300))
15079 {
15080 // we need to check that all hashes have the same scrypt settings
15081
15082 const u32 scrypt_N = data.salts_buf[0].scrypt_N;
15083 const u32 scrypt_r = data.salts_buf[0].scrypt_r;
15084 const u32 scrypt_p = data.salts_buf[0].scrypt_p;
15085
15086 for (uint i = 1; i < salts_cnt; i++)
15087 {
15088 if ((data.salts_buf[i].scrypt_N != scrypt_N)
15089 || (data.salts_buf[i].scrypt_r != scrypt_r)
15090 || (data.salts_buf[i].scrypt_p != scrypt_p))
15091 {
15092 log_error ("ERROR: Mixed scrypt settings not supported");
15093
15094 return -1;
15095 }
15096 }
15097
15098 uint tmto_start = 0;
15099 uint tmto_stop = 10;
15100
15101 if (scrypt_tmto)
15102 {
15103 tmto_start = scrypt_tmto;
15104 }
15105 else
15106 {
15107 // in case the user did not specify the tmto manually
15108 // use some values known to run best (tested on 290x for AMD and GTX1080 for NV)
15109
15110 if (hash_mode == 8900)
15111 {
15112 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15113 {
15114 tmto_start = 3;
15115 }
15116 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15117 {
15118 tmto_start = 2;
15119 }
15120 }
15121 else if (hash_mode == 9300)
15122 {
15123 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15124 {
15125 tmto_start = 2;
15126 }
15127 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15128 {
15129 tmto_start = 4;
15130 }
15131 }
15132 }
15133
15134 data.scrypt_tmp_size = (128 * scrypt_r);
15135
15136 device_param->kernel_accel_min = 1;
15137 device_param->kernel_accel_max = 8;
15138
15139 uint tmto;
15140
15141 for (tmto = tmto_start; tmto < tmto_stop; tmto++)
15142 {
15143 size_scrypt = (128 * scrypt_r) * scrypt_N;
15144
15145 size_scrypt /= 1 << tmto;
15146
15147 size_scrypt *= device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
15148
15149 if ((size_scrypt / 4) > device_param->device_maxmem_alloc)
15150 {
15151 if (quiet == 0) log_info ("WARNING: Not enough single-block device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15152
15153 continue;
15154 }
15155
15156 if (size_scrypt > device_param->device_global_mem)
15157 {
15158 if (quiet == 0) log_info ("WARNING: Not enough total device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15159
15160 continue;
15161 }
15162
15163 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15164 {
15165 data.scrypt_tmto_final = tmto;
15166 }
15167
15168 break;
15169 }
15170
15171 if (tmto == tmto_stop)
15172 {
15173 log_error ("ERROR: Can't allocate enough device memory");
15174
15175 return -1;
15176 }
15177
15178 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.scrypt_tmto_final, size_scrypt);
15179 }
15180
15181 size_t size_scrypt4 = size_scrypt / 4;
15182
15183 /**
15184 * some algorithms need a fixed kernel-loops count
15185 */
15186
15187 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15188 {
15189 const u32 kernel_loops_fixed = 1024;
15190
15191 device_param->kernel_loops_min = kernel_loops_fixed;
15192 device_param->kernel_loops_max = kernel_loops_fixed;
15193 }
15194
15195 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15196 {
15197 const u32 kernel_loops_fixed = 1024;
15198
15199 device_param->kernel_loops_min = kernel_loops_fixed;
15200 device_param->kernel_loops_max = kernel_loops_fixed;
15201 }
15202
15203 if (hash_mode == 8900)
15204 {
15205 const u32 kernel_loops_fixed = 1;
15206
15207 device_param->kernel_loops_min = kernel_loops_fixed;
15208 device_param->kernel_loops_max = kernel_loops_fixed;
15209 }
15210
15211 if (hash_mode == 9300)
15212 {
15213 const u32 kernel_loops_fixed = 1;
15214
15215 device_param->kernel_loops_min = kernel_loops_fixed;
15216 device_param->kernel_loops_max = kernel_loops_fixed;
15217 }
15218
15219 if (hash_mode == 12500)
15220 {
15221 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15222
15223 device_param->kernel_loops_min = kernel_loops_fixed;
15224 device_param->kernel_loops_max = kernel_loops_fixed;
15225 }
15226
15227 /**
15228 * some algorithms have a maximum kernel-loops count
15229 */
15230
15231 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15232 {
15233 u32 innerloop_cnt = 0;
15234
15235 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15236 {
15237 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15238 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15239 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15240 }
15241 else
15242 {
15243 innerloop_cnt = data.salts_buf[0].salt_iter;
15244 }
15245
15246 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15247 (innerloop_cnt <= device_param->kernel_loops_max))
15248 {
15249 device_param->kernel_loops_max = innerloop_cnt;
15250 }
15251 }
15252
15253 u32 kernel_accel_min = device_param->kernel_accel_min;
15254 u32 kernel_accel_max = device_param->kernel_accel_max;
15255
15256 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15257
15258 size_t size_pws = 4;
15259 size_t size_tmps = 4;
15260 size_t size_hooks = 4;
15261
15262 while (kernel_accel_max >= kernel_accel_min)
15263 {
15264 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15265
15266 // size_pws
15267
15268 size_pws = kernel_power_max * sizeof (pw_t);
15269
15270 // size_tmps
15271
15272 switch (hash_mode)
15273 {
15274 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15275 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15276 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15277 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15278 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15279 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15280 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15281 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15282 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15283 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15284 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15285 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15286 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15287 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15288 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15289 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15290 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15291 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15292 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15293 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15294 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15295 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15296 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15297 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15298 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15299 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15300 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15301 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15302 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15303 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15304 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15305 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15306 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15307 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15308 case 8900: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15309 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15310 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15311 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15312 case 9300: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15313 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15314 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15315 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15316 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15317 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15318 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15319 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15320 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15321 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15322 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15323 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15324 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15325 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15326 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15327 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15328 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15329 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15330 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15331 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15332 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15333 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15334 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15335 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15336 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15337 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15338 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15339 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15340 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15341 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15342 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15343 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15344 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15345 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15346 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15347 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15348 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15349 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15350 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15351 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15352 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15353 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15354 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15355 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15356 };
15357
15358 // size_hooks
15359
15360 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15361 {
15362 switch (hash_mode)
15363 {
15364 }
15365 }
15366
15367 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15368 // if not, decrease amplifier and try again
15369
15370 int memory_limit_hit = 0;
15371
15372 if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15373 if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15374 if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15375
15376 const u64 size_total
15377 = bitmap_size
15378 + bitmap_size
15379 + bitmap_size
15380 + bitmap_size
15381 + bitmap_size
15382 + bitmap_size
15383 + bitmap_size
15384 + bitmap_size
15385 + size_bfs
15386 + size_combs
15387 + size_digests
15388 + size_esalts
15389 + size_hooks
15390 + size_markov_css
15391 + size_plains
15392 + size_pws
15393 + size_pws // not a bug
15394 + size_results
15395 + size_root_css
15396 + size_rules
15397 + size_rules_c
15398 + size_salts
15399 + size_scrypt4
15400 + size_scrypt4
15401 + size_scrypt4
15402 + size_scrypt4
15403 + size_shown
15404 + size_tm
15405 + size_tmps;
15406
15407 if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
15408
15409 if (memory_limit_hit == 1)
15410 {
15411 kernel_accel_max--;
15412
15413 continue;
15414 }
15415
15416 break;
15417 }
15418
15419 if (kernel_accel_max < kernel_accel_min)
15420 {
15421 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
15422
15423 return -1;
15424 }
15425
15426 device_param->kernel_accel_min = kernel_accel_min;
15427 device_param->kernel_accel_max = kernel_accel_max;
15428
15429 /*
15430 if (kernel_accel_max < kernel_accel)
15431 {
15432 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15433
15434 device_param->kernel_accel = kernel_accel_max;
15435 }
15436 */
15437
15438 device_param->size_bfs = size_bfs;
15439 device_param->size_combs = size_combs;
15440 device_param->size_rules = size_rules;
15441 device_param->size_rules_c = size_rules_c;
15442 device_param->size_pws = size_pws;
15443 device_param->size_tmps = size_tmps;
15444 device_param->size_hooks = size_hooks;
15445
15446 /**
15447 * default building options
15448 */
15449
15450 char cpath[1024] = { 0 };
15451
15452 char build_opts[1024] = { 0 };
15453
15454 #if _WIN
15455
15456 snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
15457
15458 char *cpath_real = mymalloc (MAX_PATH);
15459
15460 if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
15461 {
15462 log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
15463
15464 return -1;
15465 }
15466
15467 naive_replace (cpath_real, '\\', '/');
15468
15469 // not escaping here, windows has quotes
15470
15471 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
15472
15473 #else
15474
15475 snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
15476
15477 char *cpath_real = mymalloc (PATH_MAX);
15478
15479 if (realpath (cpath, cpath_real) == NULL)
15480 {
15481 log_error ("ERROR: %s: %s", cpath, strerror (errno));
15482
15483 return -1;
15484 }
15485
15486 naive_escape (cpath_real, PATH_MAX, ' ', '\\');
15487
15488 snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
15489
15490 #endif
15491
15492 // include check
15493 // this test needs to be done manually because of osx opencl runtime
15494 // if there's a problem with permission, its not reporting back and erroring out silently
15495
15496 #define files_cnt 15
15497
15498 const char *files_names[files_cnt] =
15499 {
15500 "inc_cipher_aes256.cl",
15501 "inc_cipher_serpent256.cl",
15502 "inc_cipher_twofish256.cl",
15503 "inc_common.cl",
15504 "inc_comp_multi_bs.cl",
15505 "inc_comp_multi.cl",
15506 "inc_comp_single_bs.cl",
15507 "inc_comp_single.cl",
15508 "inc_hash_constants.h",
15509 "inc_hash_functions.cl",
15510 "inc_rp.cl",
15511 "inc_rp.h",
15512 "inc_simd.cl",
15513 "inc_types.cl",
15514 "inc_vendor.cl",
15515 };
15516
15517 for (int i = 0; i < files_cnt; i++)
15518 {
15519 char path[1024] = { 0 };
15520
15521 snprintf (path, sizeof (path) - 1, "%s/%s", cpath_real, files_names[i]);
15522
15523 FILE *fd = fopen (path, "r");
15524
15525 if (fd == NULL)
15526 {
15527 log_error ("ERROR: %s: fopen(): %s", path, strerror (errno));
15528
15529 return -1;
15530 }
15531
15532 char buf[1];
15533
15534 size_t n = fread (buf, 1, 1, fd);
15535
15536 if (n != 1)
15537 {
15538 log_error ("ERROR: %s: fread(): %s", path, strerror (errno));
15539
15540 return -1;
15541 }
15542
15543 fclose (fd);
15544 }
15545
15546 myfree (cpath_real);
15547
15548 // we don't have sm_* on vendors not NV but it doesn't matter
15549
15550 char build_opts_new[1024] = { 0 };
15551
15552 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);
15553
15554 strncpy (build_opts, build_opts_new, sizeof (build_opts));
15555
15556 #ifdef DEBUG
15557 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15558 #endif
15559
15560 /**
15561 * main kernel
15562 */
15563
15564 {
15565 /**
15566 * kernel source filename
15567 */
15568
15569 char source_file[256] = { 0 };
15570
15571 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15572
15573 struct stat sst;
15574
15575 if (stat (source_file, &sst) == -1)
15576 {
15577 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15578
15579 return -1;
15580 }
15581
15582 /**
15583 * kernel cached filename
15584 */
15585
15586 char cached_file[256] = { 0 };
15587
15588 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15589
15590 int cached = 1;
15591
15592 struct stat cst;
15593
15594 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15595 {
15596 cached = 0;
15597 }
15598
15599 /**
15600 * kernel compile or load
15601 */
15602
15603 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15604
15605 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15606
15607 if (force_jit_compilation == -1)
15608 {
15609 if (cached == 0)
15610 {
15611 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));
15612
15613 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15614
15615 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15616
15617 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15618
15619 #ifdef DEBUG
15620 size_t build_log_size = 0;
15621
15622 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15623
15624 if (build_log_size > 1)
15625 {
15626 char *build_log = (char *) malloc (build_log_size + 1);
15627
15628 memset (build_log, 0, build_log_size + 1);
15629
15630 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15631
15632 puts (build_log);
15633
15634 free (build_log);
15635 }
15636 #endif
15637
15638 if (rc != 0)
15639 {
15640 device_param->skipped = true;
15641
15642 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15643
15644 continue;
15645 }
15646
15647 size_t binary_size;
15648
15649 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15650
15651 u8 *binary = (u8 *) mymalloc (binary_size);
15652
15653 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15654
15655 writeProgramBin (cached_file, binary, binary_size);
15656
15657 local_free (binary);
15658 }
15659 else
15660 {
15661 #ifdef DEBUG
15662 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15663 #endif
15664
15665 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15666
15667 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15668
15669 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15670 }
15671 }
15672 else
15673 {
15674 #ifdef DEBUG
15675 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15676 #endif
15677
15678 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15679
15680 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15681
15682 char build_opts_update[1024] = { 0 };
15683
15684 if (force_jit_compilation == 1500)
15685 {
15686 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%u", build_opts, data.salts_buf[0].salt_buf[0]);
15687 }
15688 else if (force_jit_compilation == 8900)
15689 {
15690 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);
15691 }
15692 else
15693 {
15694 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15695 }
15696
15697 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15698
15699 #ifdef DEBUG
15700 size_t build_log_size = 0;
15701
15702 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15703
15704 if (build_log_size > 1)
15705 {
15706 char *build_log = (char *) malloc (build_log_size + 1);
15707
15708 memset (build_log, 0, build_log_size + 1);
15709
15710 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15711
15712 puts (build_log);
15713
15714 free (build_log);
15715 }
15716 #endif
15717
15718 if (rc != 0)
15719 {
15720 device_param->skipped = true;
15721
15722 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15723 }
15724 }
15725
15726 local_free (kernel_lengths);
15727 local_free (kernel_sources[0]);
15728 local_free (kernel_sources);
15729 }
15730
15731 /**
15732 * word generator kernel
15733 */
15734
15735 if (attack_mode != ATTACK_MODE_STRAIGHT)
15736 {
15737 /**
15738 * kernel mp source filename
15739 */
15740
15741 char source_file[256] = { 0 };
15742
15743 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15744
15745 struct stat sst;
15746
15747 if (stat (source_file, &sst) == -1)
15748 {
15749 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15750
15751 return -1;
15752 }
15753
15754 /**
15755 * kernel mp cached filename
15756 */
15757
15758 char cached_file[256] = { 0 };
15759
15760 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15761
15762 int cached = 1;
15763
15764 struct stat cst;
15765
15766 if (stat (cached_file, &cst) == -1)
15767 {
15768 cached = 0;
15769 }
15770
15771 /**
15772 * kernel compile or load
15773 */
15774
15775 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15776
15777 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15778
15779 if (cached == 0)
15780 {
15781 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));
15782 if (quiet == 0) log_info ("");
15783
15784 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15785
15786 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15787
15788 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15789
15790 if (rc != 0)
15791 {
15792 device_param->skipped = true;
15793
15794 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15795
15796 continue;
15797 }
15798
15799 size_t binary_size;
15800
15801 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15802
15803 u8 *binary = (u8 *) mymalloc (binary_size);
15804
15805 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15806
15807 writeProgramBin (cached_file, binary, binary_size);
15808
15809 local_free (binary);
15810 }
15811 else
15812 {
15813 #ifdef DEBUG
15814 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15815 #endif
15816
15817 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15818
15819 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15820
15821 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15822 }
15823
15824 local_free (kernel_lengths);
15825 local_free (kernel_sources[0]);
15826 local_free (kernel_sources);
15827 }
15828
15829 /**
15830 * amplifier kernel
15831 */
15832
15833 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15834 {
15835
15836 }
15837 else
15838 {
15839 /**
15840 * kernel amp source filename
15841 */
15842
15843 char source_file[256] = { 0 };
15844
15845 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15846
15847 struct stat sst;
15848
15849 if (stat (source_file, &sst) == -1)
15850 {
15851 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15852
15853 return -1;
15854 }
15855
15856 /**
15857 * kernel amp cached filename
15858 */
15859
15860 char cached_file[256] = { 0 };
15861
15862 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15863
15864 int cached = 1;
15865
15866 struct stat cst;
15867
15868 if (stat (cached_file, &cst) == -1)
15869 {
15870 cached = 0;
15871 }
15872
15873 /**
15874 * kernel compile or load
15875 */
15876
15877 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15878
15879 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15880
15881 if (cached == 0)
15882 {
15883 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));
15884 if (quiet == 0) log_info ("");
15885
15886 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15887
15888 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15889
15890 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15891
15892 if (rc != 0)
15893 {
15894 device_param->skipped = true;
15895
15896 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15897
15898 continue;
15899 }
15900
15901 size_t binary_size;
15902
15903 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15904
15905 u8 *binary = (u8 *) mymalloc (binary_size);
15906
15907 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15908
15909 writeProgramBin (cached_file, binary, binary_size);
15910
15911 local_free (binary);
15912 }
15913 else
15914 {
15915 #ifdef DEBUG
15916 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15917 #endif
15918
15919 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15920
15921 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15922
15923 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15924 }
15925
15926 local_free (kernel_lengths);
15927 local_free (kernel_sources[0]);
15928 local_free (kernel_sources);
15929 }
15930
15931 // some algorithm collide too fast, make that impossible
15932
15933 if (benchmark == 1)
15934 {
15935 ((uint *) digests_buf)[0] = -1;
15936 ((uint *) digests_buf)[1] = -1;
15937 ((uint *) digests_buf)[2] = -1;
15938 ((uint *) digests_buf)[3] = -1;
15939 }
15940
15941 /**
15942 * global buffers
15943 */
15944
15945 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15946 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15947 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15948 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15949 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15950 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15951 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15952 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15953 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15954 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15955 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15956 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15957 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15958 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15959 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15960 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15961 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15962 device_param->d_scryptV0_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
15963 device_param->d_scryptV1_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
15964 device_param->d_scryptV2_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
15965 device_param->d_scryptV3_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
15966
15967 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);
15968 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);
15969 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);
15970 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);
15971 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);
15972 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);
15973 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);
15974 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);
15975 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15976 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15977 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15978
15979 /**
15980 * special buffers
15981 */
15982
15983 if (attack_kern == ATTACK_KERN_STRAIGHT)
15984 {
15985 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15986 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15987
15988 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15989 }
15990 else if (attack_kern == ATTACK_KERN_COMBI)
15991 {
15992 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15993 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15994 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15995 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15996 }
15997 else if (attack_kern == ATTACK_KERN_BF)
15998 {
15999 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
16000 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
16001 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
16002 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
16003 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
16004 }
16005
16006 if (size_esalts)
16007 {
16008 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
16009
16010 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
16011 }
16012
16013 /**
16014 * main host data
16015 */
16016
16017 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
16018
16019 device_param->pws_buf = pws_buf;
16020
16021 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
16022
16023 device_param->combs_buf = combs_buf;
16024
16025 void *hooks_buf = mymalloc (size_hooks);
16026
16027 device_param->hooks_buf = hooks_buf;
16028
16029 /**
16030 * kernel args
16031 */
16032
16033 device_param->kernel_params_buf32[24] = bitmap_mask;
16034 device_param->kernel_params_buf32[25] = bitmap_shift1;
16035 device_param->kernel_params_buf32[26] = bitmap_shift2;
16036 device_param->kernel_params_buf32[27] = 0; // salt_pos
16037 device_param->kernel_params_buf32[28] = 0; // loop_pos
16038 device_param->kernel_params_buf32[29] = 0; // loop_cnt
16039 device_param->kernel_params_buf32[30] = 0; // kernel_rules_cnt
16040 device_param->kernel_params_buf32[31] = 0; // digests_cnt
16041 device_param->kernel_params_buf32[32] = 0; // digests_offset
16042 device_param->kernel_params_buf32[33] = 0; // combs_mode
16043 device_param->kernel_params_buf32[34] = 0; // gid_max
16044
16045 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16046 ? &device_param->d_pws_buf
16047 : &device_param->d_pws_amp_buf;
16048 device_param->kernel_params[ 1] = &device_param->d_rules_c;
16049 device_param->kernel_params[ 2] = &device_param->d_combs_c;
16050 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
16051 device_param->kernel_params[ 4] = &device_param->d_tmps;
16052 device_param->kernel_params[ 5] = &device_param->d_hooks;
16053 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
16054 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
16055 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
16056 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
16057 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
16058 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
16059 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
16060 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
16061 device_param->kernel_params[14] = &device_param->d_plain_bufs;
16062 device_param->kernel_params[15] = &device_param->d_digests_buf;
16063 device_param->kernel_params[16] = &device_param->d_digests_shown;
16064 device_param->kernel_params[17] = &device_param->d_salt_bufs;
16065 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
16066 device_param->kernel_params[19] = &device_param->d_result;
16067 device_param->kernel_params[20] = &device_param->d_scryptV0_buf;
16068 device_param->kernel_params[21] = &device_param->d_scryptV1_buf;
16069 device_param->kernel_params[22] = &device_param->d_scryptV2_buf;
16070 device_param->kernel_params[23] = &device_param->d_scryptV3_buf;
16071 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
16072 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
16073 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
16074 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
16075 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
16076 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
16077 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
16078 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
16079 device_param->kernel_params[32] = &device_param->kernel_params_buf32[32];
16080 device_param->kernel_params[33] = &device_param->kernel_params_buf32[33];
16081 device_param->kernel_params[34] = &device_param->kernel_params_buf32[34];
16082
16083 device_param->kernel_params_mp_buf64[3] = 0;
16084 device_param->kernel_params_mp_buf32[4] = 0;
16085 device_param->kernel_params_mp_buf32[5] = 0;
16086 device_param->kernel_params_mp_buf32[6] = 0;
16087 device_param->kernel_params_mp_buf32[7] = 0;
16088 device_param->kernel_params_mp_buf32[8] = 0;
16089
16090 device_param->kernel_params_mp[0] = NULL;
16091 device_param->kernel_params_mp[1] = NULL;
16092 device_param->kernel_params_mp[2] = NULL;
16093 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16094 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16095 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16096 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16097 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16098 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16099
16100 device_param->kernel_params_mp_l_buf64[3] = 0;
16101 device_param->kernel_params_mp_l_buf32[4] = 0;
16102 device_param->kernel_params_mp_l_buf32[5] = 0;
16103 device_param->kernel_params_mp_l_buf32[6] = 0;
16104 device_param->kernel_params_mp_l_buf32[7] = 0;
16105 device_param->kernel_params_mp_l_buf32[8] = 0;
16106 device_param->kernel_params_mp_l_buf32[9] = 0;
16107
16108 device_param->kernel_params_mp_l[0] = NULL;
16109 device_param->kernel_params_mp_l[1] = NULL;
16110 device_param->kernel_params_mp_l[2] = NULL;
16111 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
16112 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
16113 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16114 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16115 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16116 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16117 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16118
16119 device_param->kernel_params_mp_r_buf64[3] = 0;
16120 device_param->kernel_params_mp_r_buf32[4] = 0;
16121 device_param->kernel_params_mp_r_buf32[5] = 0;
16122 device_param->kernel_params_mp_r_buf32[6] = 0;
16123 device_param->kernel_params_mp_r_buf32[7] = 0;
16124 device_param->kernel_params_mp_r_buf32[8] = 0;
16125
16126 device_param->kernel_params_mp_r[0] = NULL;
16127 device_param->kernel_params_mp_r[1] = NULL;
16128 device_param->kernel_params_mp_r[2] = NULL;
16129 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16130 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16131 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16132 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16133 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16134 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16135
16136 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16137 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16138
16139 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16140 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16141 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16142 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16143 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16144 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16145 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16146
16147 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16148 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16149
16150 device_param->kernel_params_memset_buf32[1] = 0; // value
16151 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16152
16153 device_param->kernel_params_memset[0] = NULL;
16154 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16155 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16156
16157 /**
16158 * kernel name
16159 */
16160
16161 size_t kernel_wgs_tmp;
16162
16163 char kernel_name[64] = { 0 };
16164
16165 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16166 {
16167 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16168 {
16169 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16170
16171 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16172
16173 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16174
16175 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16176
16177 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16178
16179 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16180 }
16181 else
16182 {
16183 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16184
16185 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16186
16187 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16188
16189 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16190
16191 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16192
16193 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16194 }
16195
16196 if (data.attack_mode == ATTACK_MODE_BF)
16197 {
16198 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16199 {
16200 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16201
16202 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16203
16204 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);
16205 }
16206 }
16207 }
16208 else
16209 {
16210 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16211
16212 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16213
16214 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16215
16216 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16217
16218 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16219
16220 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16221
16222 if (opts_type & OPTS_TYPE_HOOK12)
16223 {
16224 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16225
16226 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16227
16228 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);
16229 }
16230
16231 if (opts_type & OPTS_TYPE_HOOK23)
16232 {
16233 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16234
16235 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16236
16237 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);
16238 }
16239 }
16240
16241 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);
16242 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);
16243 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);
16244
16245 for (uint i = 0; i <= 23; i++)
16246 {
16247 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16248 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16249 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16250
16251 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16252 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16253 }
16254
16255 for (uint i = 24; i <= 34; i++)
16256 {
16257 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16258 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16259 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16260
16261 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16262 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16263 }
16264
16265 // GPU memset
16266
16267 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16268
16269 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);
16270
16271 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16272 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16273 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16274
16275 // MP start
16276
16277 if (attack_mode == ATTACK_MODE_BF)
16278 {
16279 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16280 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16281
16282 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);
16283 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);
16284
16285 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16286 {
16287 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16288 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16289 }
16290 }
16291 else if (attack_mode == ATTACK_MODE_HYBRID1)
16292 {
16293 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16294
16295 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);
16296 }
16297 else if (attack_mode == ATTACK_MODE_HYBRID2)
16298 {
16299 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16300
16301 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);
16302 }
16303
16304 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16305 {
16306 // nothing to do
16307 }
16308 else
16309 {
16310 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16311
16312 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);
16313 }
16314
16315 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16316 {
16317 // nothing to do
16318 }
16319 else
16320 {
16321 for (uint i = 0; i < 5; i++)
16322 {
16323 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16324 }
16325
16326 for (uint i = 5; i < 7; i++)
16327 {
16328 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16329 }
16330 }
16331
16332 // maybe this has been updated by clGetKernelWorkGroupInfo()
16333 // value can only be decreased, so we don't need to reallocate buffers
16334
16335 device_param->kernel_threads = kernel_threads;
16336
16337 // zero some data buffers
16338
16339 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16340 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16341 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16342 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16343 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16344 run_kernel_bzero (device_param, device_param->d_result, size_results);
16345
16346 /**
16347 * special buffers
16348 */
16349
16350 if (attack_kern == ATTACK_KERN_STRAIGHT)
16351 {
16352 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16353 }
16354 else if (attack_kern == ATTACK_KERN_COMBI)
16355 {
16356 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16357 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16358 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16359 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16360 }
16361 else if (attack_kern == ATTACK_KERN_BF)
16362 {
16363 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16364 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16365 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16366 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16367 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16368 }
16369
16370 #if defined(HAVE_HWMON)
16371
16372 /**
16373 * Store initial fanspeed if gpu_temp_retain is enabled
16374 */
16375
16376 if (gpu_temp_disable == 0)
16377 {
16378 if (gpu_temp_retain != 0)
16379 {
16380 hc_thread_mutex_lock (mux_adl);
16381
16382 if (data.hm_device[device_id].fan_get_supported == 1)
16383 {
16384 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16385 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16386
16387 // we also set it to tell the OS we take control over the fan and it's automatic controller
16388 // if it was set to automatic. we do not control user-defined fanspeeds.
16389
16390 if (fanpolicy == 1)
16391 {
16392 data.hm_device[device_id].fan_set_supported = 1;
16393
16394 int rc = -1;
16395
16396 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16397 {
16398 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16399 }
16400 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16401 {
16402 #ifdef LINUX
16403 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16404 #endif
16405
16406 #ifdef WIN
16407 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16408 #endif
16409 }
16410
16411 if (rc == 0)
16412 {
16413 data.hm_device[device_id].fan_set_supported = 1;
16414 }
16415 else
16416 {
16417 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16418
16419 data.hm_device[device_id].fan_set_supported = 0;
16420 }
16421 }
16422 else
16423 {
16424 data.hm_device[device_id].fan_set_supported = 0;
16425 }
16426 }
16427
16428 hc_thread_mutex_unlock (mux_adl);
16429 }
16430 }
16431
16432 #endif // HAVE_HWMON
16433 }
16434
16435 if (data.quiet == 0) log_info_nn ("");
16436
16437 /**
16438 * In benchmark-mode, inform user which algorithm is checked
16439 */
16440
16441 if (benchmark == 1)
16442 {
16443 if (machine_readable == 0)
16444 {
16445 quiet = 0;
16446
16447 data.quiet = quiet;
16448
16449 char *hash_type = strhashtype (data.hash_mode); // not a bug
16450
16451 log_info ("Hashtype: %s", hash_type);
16452 log_info ("");
16453 }
16454 }
16455
16456 /**
16457 * keep track of the progress
16458 */
16459
16460 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16461 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16462 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16463
16464 /**
16465 * open filehandles
16466 */
16467
16468 #if _WIN
16469 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16470 {
16471 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16472
16473 return (-1);
16474 }
16475
16476 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16477 {
16478 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16479
16480 return (-1);
16481 }
16482
16483 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16484 {
16485 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16486
16487 return (-1);
16488 }
16489 #endif
16490
16491 /**
16492 * dictionary pad
16493 */
16494
16495 segment_size *= (1024 * 1024);
16496
16497 data.segment_size = segment_size;
16498
16499 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16500
16501 wl_data->buf = (char *) mymalloc (segment_size);
16502 wl_data->avail = segment_size;
16503 wl_data->incr = segment_size;
16504 wl_data->cnt = 0;
16505 wl_data->pos = 0;
16506
16507 cs_t *css_buf = NULL;
16508 uint css_cnt = 0;
16509 uint dictcnt = 0;
16510 uint maskcnt = 1;
16511 char **masks = NULL;
16512 char **dictfiles = NULL;
16513
16514 uint mask_from_file = 0;
16515
16516 if (attack_mode == ATTACK_MODE_STRAIGHT)
16517 {
16518 if (wordlist_mode == WL_MODE_FILE)
16519 {
16520 int wls_left = myargc - (optind + 1);
16521
16522 for (int i = 0; i < wls_left; i++)
16523 {
16524 char *l0_filename = myargv[optind + 1 + i];
16525
16526 struct stat l0_stat;
16527
16528 if (stat (l0_filename, &l0_stat) == -1)
16529 {
16530 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16531
16532 return (-1);
16533 }
16534
16535 uint is_dir = S_ISDIR (l0_stat.st_mode);
16536
16537 if (is_dir == 0)
16538 {
16539 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16540
16541 dictcnt++;
16542
16543 dictfiles[dictcnt - 1] = l0_filename;
16544 }
16545 else
16546 {
16547 // do not allow --keyspace w/ a directory
16548
16549 if (keyspace == 1)
16550 {
16551 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16552
16553 return (-1);
16554 }
16555
16556 char **dictionary_files = NULL;
16557
16558 dictionary_files = scan_directory (l0_filename);
16559
16560 if (dictionary_files != NULL)
16561 {
16562 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16563
16564 for (int d = 0; dictionary_files[d] != NULL; d++)
16565 {
16566 char *l1_filename = dictionary_files[d];
16567
16568 struct stat l1_stat;
16569
16570 if (stat (l1_filename, &l1_stat) == -1)
16571 {
16572 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16573
16574 return (-1);
16575 }
16576
16577 if (S_ISREG (l1_stat.st_mode))
16578 {
16579 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16580
16581 dictcnt++;
16582
16583 dictfiles[dictcnt - 1] = strdup (l1_filename);
16584 }
16585 }
16586 }
16587
16588 local_free (dictionary_files);
16589 }
16590 }
16591
16592 if (dictcnt < 1)
16593 {
16594 log_error ("ERROR: No usable dictionary file found.");
16595
16596 return (-1);
16597 }
16598 }
16599 else if (wordlist_mode == WL_MODE_STDIN)
16600 {
16601 dictcnt = 1;
16602 }
16603 }
16604 else if (attack_mode == ATTACK_MODE_COMBI)
16605 {
16606 // display
16607
16608 char *dictfile1 = myargv[optind + 1 + 0];
16609 char *dictfile2 = myargv[optind + 1 + 1];
16610
16611 // find the bigger dictionary and use as base
16612
16613 FILE *fp1 = NULL;
16614 FILE *fp2 = NULL;
16615
16616 struct stat tmp_stat;
16617
16618 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16619 {
16620 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16621
16622 return (-1);
16623 }
16624
16625 if (stat (dictfile1, &tmp_stat) == -1)
16626 {
16627 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16628
16629 fclose (fp1);
16630
16631 return (-1);
16632 }
16633
16634 if (S_ISDIR (tmp_stat.st_mode))
16635 {
16636 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16637
16638 fclose (fp1);
16639
16640 return (-1);
16641 }
16642
16643 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16644 {
16645 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16646
16647 fclose (fp1);
16648
16649 return (-1);
16650 }
16651
16652 if (stat (dictfile2, &tmp_stat) == -1)
16653 {
16654 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16655
16656 fclose (fp1);
16657 fclose (fp2);
16658
16659 return (-1);
16660 }
16661
16662 if (S_ISDIR (tmp_stat.st_mode))
16663 {
16664 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16665
16666 fclose (fp1);
16667 fclose (fp2);
16668
16669 return (-1);
16670 }
16671
16672 data.combs_cnt = 1;
16673
16674 data.quiet = 1;
16675
16676 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16677
16678 data.quiet = quiet;
16679
16680 if (words1_cnt == 0)
16681 {
16682 log_error ("ERROR: %s: empty file", dictfile1);
16683
16684 fclose (fp1);
16685 fclose (fp2);
16686
16687 return (-1);
16688 }
16689
16690 data.combs_cnt = 1;
16691
16692 data.quiet = 1;
16693
16694 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16695
16696 data.quiet = quiet;
16697
16698 if (words2_cnt == 0)
16699 {
16700 log_error ("ERROR: %s: empty file", dictfile2);
16701
16702 fclose (fp1);
16703 fclose (fp2);
16704
16705 return (-1);
16706 }
16707
16708 fclose (fp1);
16709 fclose (fp2);
16710
16711 data.dictfile = dictfile1;
16712 data.dictfile2 = dictfile2;
16713
16714 if (words1_cnt >= words2_cnt)
16715 {
16716 data.combs_cnt = words2_cnt;
16717 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16718
16719 dictfiles = &data.dictfile;
16720
16721 dictcnt = 1;
16722 }
16723 else
16724 {
16725 data.combs_cnt = words1_cnt;
16726 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16727
16728 dictfiles = &data.dictfile2;
16729
16730 dictcnt = 1;
16731
16732 // we also have to switch wordlist related rules!
16733
16734 char *tmpc = data.rule_buf_l;
16735
16736 data.rule_buf_l = data.rule_buf_r;
16737 data.rule_buf_r = tmpc;
16738
16739 int tmpi = data.rule_len_l;
16740
16741 data.rule_len_l = data.rule_len_r;
16742 data.rule_len_r = tmpi;
16743 }
16744 }
16745 else if (attack_mode == ATTACK_MODE_BF)
16746 {
16747 char *mask = NULL;
16748
16749 maskcnt = 0;
16750
16751 if (benchmark == 0)
16752 {
16753 mask = myargv[optind + 1];
16754
16755 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16756
16757 if ((optind + 2) <= myargc)
16758 {
16759 struct stat file_stat;
16760
16761 if (stat (mask, &file_stat) == -1)
16762 {
16763 maskcnt = 1;
16764
16765 masks[maskcnt - 1] = mystrdup (mask);
16766 }
16767 else
16768 {
16769 int wls_left = myargc - (optind + 1);
16770
16771 uint masks_avail = INCR_MASKS;
16772
16773 for (int i = 0; i < wls_left; i++)
16774 {
16775 if (i != 0)
16776 {
16777 mask = myargv[optind + 1 + i];
16778
16779 if (stat (mask, &file_stat) == -1)
16780 {
16781 log_error ("ERROR: %s: %s", mask, strerror (errno));
16782
16783 return (-1);
16784 }
16785 }
16786
16787 uint is_file = S_ISREG (file_stat.st_mode);
16788
16789 if (is_file == 1)
16790 {
16791 FILE *mask_fp;
16792
16793 if ((mask_fp = fopen (mask, "r")) == NULL)
16794 {
16795 log_error ("ERROR: %s: %s", mask, strerror (errno));
16796
16797 return (-1);
16798 }
16799
16800 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16801
16802 while (!feof (mask_fp))
16803 {
16804 memset (line_buf, 0, HCBUFSIZ);
16805
16806 int line_len = fgetl (mask_fp, line_buf);
16807
16808 if (line_len == 0) continue;
16809
16810 if (line_buf[0] == '#') continue;
16811
16812 if (masks_avail == maskcnt)
16813 {
16814 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16815
16816 masks_avail += INCR_MASKS;
16817 }
16818
16819 masks[maskcnt] = mystrdup (line_buf);
16820
16821 maskcnt++;
16822 }
16823
16824 myfree (line_buf);
16825
16826 fclose (mask_fp);
16827 }
16828 else
16829 {
16830 log_error ("ERROR: %s: unsupported file-type", mask);
16831
16832 return (-1);
16833 }
16834 }
16835
16836 mask_from_file = 1;
16837 }
16838 }
16839 else
16840 {
16841 custom_charset_1 = (char *) "?l?d?u";
16842 custom_charset_2 = (char *) "?l?d";
16843 custom_charset_3 = (char *) "?l?d*!$@_";
16844
16845 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16846 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16847 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16848
16849 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16850
16851 wordlist_mode = WL_MODE_MASK;
16852
16853 data.wordlist_mode = wordlist_mode;
16854
16855 increment = 1;
16856
16857 maskcnt = 1;
16858 }
16859 }
16860 else
16861 {
16862 /**
16863 * generate full masks and charsets
16864 */
16865
16866 masks = (char **) mymalloc (sizeof (char *));
16867
16868 switch (hash_mode)
16869 {
16870 case 1731: pw_min = 5;
16871 pw_max = 5;
16872 mask = mystrdup ("?b?b?b?b?b");
16873 break;
16874 case 12500: pw_min = 5;
16875 pw_max = 5;
16876 mask = mystrdup ("?b?b?b?b?b");
16877 break;
16878 default: pw_min = 7;
16879 pw_max = 7;
16880 mask = mystrdup ("?b?b?b?b?b?b?b");
16881 break;
16882 }
16883
16884 maskcnt = 1;
16885
16886 masks[maskcnt - 1] = mystrdup (mask);
16887
16888 wordlist_mode = WL_MODE_MASK;
16889
16890 data.wordlist_mode = wordlist_mode;
16891
16892 increment = 1;
16893 }
16894
16895 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16896
16897 if (increment)
16898 {
16899 if (increment_min > pw_min) pw_min = increment_min;
16900
16901 if (increment_max < pw_max) pw_max = increment_max;
16902 }
16903 }
16904 else if (attack_mode == ATTACK_MODE_HYBRID1)
16905 {
16906 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16907
16908 // display
16909
16910 char *mask = myargv[myargc - 1];
16911
16912 maskcnt = 0;
16913
16914 masks = (char **) mymalloc (1 * sizeof (char *));
16915
16916 // mod
16917
16918 struct stat file_stat;
16919
16920 if (stat (mask, &file_stat) == -1)
16921 {
16922 maskcnt = 1;
16923
16924 masks[maskcnt - 1] = mystrdup (mask);
16925 }
16926 else
16927 {
16928 uint is_file = S_ISREG (file_stat.st_mode);
16929
16930 if (is_file == 1)
16931 {
16932 FILE *mask_fp;
16933
16934 if ((mask_fp = fopen (mask, "r")) == NULL)
16935 {
16936 log_error ("ERROR: %s: %s", mask, strerror (errno));
16937
16938 return (-1);
16939 }
16940
16941 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16942
16943 uint masks_avail = 1;
16944
16945 while (!feof (mask_fp))
16946 {
16947 memset (line_buf, 0, HCBUFSIZ);
16948
16949 int line_len = fgetl (mask_fp, line_buf);
16950
16951 if (line_len == 0) continue;
16952
16953 if (line_buf[0] == '#') continue;
16954
16955 if (masks_avail == maskcnt)
16956 {
16957 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16958
16959 masks_avail += INCR_MASKS;
16960 }
16961
16962 masks[maskcnt] = mystrdup (line_buf);
16963
16964 maskcnt++;
16965 }
16966
16967 myfree (line_buf);
16968
16969 fclose (mask_fp);
16970
16971 mask_from_file = 1;
16972 }
16973 else
16974 {
16975 maskcnt = 1;
16976
16977 masks[maskcnt - 1] = mystrdup (mask);
16978 }
16979 }
16980
16981 // base
16982
16983 int wls_left = myargc - (optind + 2);
16984
16985 for (int i = 0; i < wls_left; i++)
16986 {
16987 char *filename = myargv[optind + 1 + i];
16988
16989 struct stat file_stat;
16990
16991 if (stat (filename, &file_stat) == -1)
16992 {
16993 log_error ("ERROR: %s: %s", filename, strerror (errno));
16994
16995 return (-1);
16996 }
16997
16998 uint is_dir = S_ISDIR (file_stat.st_mode);
16999
17000 if (is_dir == 0)
17001 {
17002 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17003
17004 dictcnt++;
17005
17006 dictfiles[dictcnt - 1] = filename;
17007 }
17008 else
17009 {
17010 // do not allow --keyspace w/ a directory
17011
17012 if (keyspace == 1)
17013 {
17014 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17015
17016 return (-1);
17017 }
17018
17019 char **dictionary_files = NULL;
17020
17021 dictionary_files = scan_directory (filename);
17022
17023 if (dictionary_files != NULL)
17024 {
17025 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17026
17027 for (int d = 0; dictionary_files[d] != NULL; d++)
17028 {
17029 char *l1_filename = dictionary_files[d];
17030
17031 struct stat l1_stat;
17032
17033 if (stat (l1_filename, &l1_stat) == -1)
17034 {
17035 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17036
17037 return (-1);
17038 }
17039
17040 if (S_ISREG (l1_stat.st_mode))
17041 {
17042 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17043
17044 dictcnt++;
17045
17046 dictfiles[dictcnt - 1] = strdup (l1_filename);
17047 }
17048 }
17049 }
17050
17051 local_free (dictionary_files);
17052 }
17053 }
17054
17055 if (dictcnt < 1)
17056 {
17057 log_error ("ERROR: No usable dictionary file found.");
17058
17059 return (-1);
17060 }
17061
17062 if (increment)
17063 {
17064 maskcnt = 0;
17065
17066 uint mask_min = increment_min; // we can't reject smaller masks here
17067 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17068
17069 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17070 {
17071 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17072
17073 if (cur_mask == NULL) break;
17074
17075 masks[maskcnt] = cur_mask;
17076
17077 maskcnt++;
17078
17079 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17080 }
17081 }
17082 }
17083 else if (attack_mode == ATTACK_MODE_HYBRID2)
17084 {
17085 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17086
17087 // display
17088
17089 char *mask = myargv[optind + 1 + 0];
17090
17091 maskcnt = 0;
17092
17093 masks = (char **) mymalloc (1 * sizeof (char *));
17094
17095 // mod
17096
17097 struct stat file_stat;
17098
17099 if (stat (mask, &file_stat) == -1)
17100 {
17101 maskcnt = 1;
17102
17103 masks[maskcnt - 1] = mystrdup (mask);
17104 }
17105 else
17106 {
17107 uint is_file = S_ISREG (file_stat.st_mode);
17108
17109 if (is_file == 1)
17110 {
17111 FILE *mask_fp;
17112
17113 if ((mask_fp = fopen (mask, "r")) == NULL)
17114 {
17115 log_error ("ERROR: %s: %s", mask, strerror (errno));
17116
17117 return (-1);
17118 }
17119
17120 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17121
17122 uint masks_avail = 1;
17123
17124 while (!feof (mask_fp))
17125 {
17126 memset (line_buf, 0, HCBUFSIZ);
17127
17128 int line_len = fgetl (mask_fp, line_buf);
17129
17130 if (line_len == 0) continue;
17131
17132 if (line_buf[0] == '#') continue;
17133
17134 if (masks_avail == maskcnt)
17135 {
17136 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17137
17138 masks_avail += INCR_MASKS;
17139 }
17140
17141 masks[maskcnt] = mystrdup (line_buf);
17142
17143 maskcnt++;
17144 }
17145
17146 myfree (line_buf);
17147
17148 fclose (mask_fp);
17149
17150 mask_from_file = 1;
17151 }
17152 else
17153 {
17154 maskcnt = 1;
17155
17156 masks[maskcnt - 1] = mystrdup (mask);
17157 }
17158 }
17159
17160 // base
17161
17162 int wls_left = myargc - (optind + 2);
17163
17164 for (int i = 0; i < wls_left; i++)
17165 {
17166 char *filename = myargv[optind + 2 + i];
17167
17168 struct stat file_stat;
17169
17170 if (stat (filename, &file_stat) == -1)
17171 {
17172 log_error ("ERROR: %s: %s", filename, strerror (errno));
17173
17174 return (-1);
17175 }
17176
17177 uint is_dir = S_ISDIR (file_stat.st_mode);
17178
17179 if (is_dir == 0)
17180 {
17181 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17182
17183 dictcnt++;
17184
17185 dictfiles[dictcnt - 1] = filename;
17186 }
17187 else
17188 {
17189 // do not allow --keyspace w/ a directory
17190
17191 if (keyspace == 1)
17192 {
17193 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17194
17195 return (-1);
17196 }
17197
17198 char **dictionary_files = NULL;
17199
17200 dictionary_files = scan_directory (filename);
17201
17202 if (dictionary_files != NULL)
17203 {
17204 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17205
17206 for (int d = 0; dictionary_files[d] != NULL; d++)
17207 {
17208 char *l1_filename = dictionary_files[d];
17209
17210 struct stat l1_stat;
17211
17212 if (stat (l1_filename, &l1_stat) == -1)
17213 {
17214 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17215
17216 return (-1);
17217 }
17218
17219 if (S_ISREG (l1_stat.st_mode))
17220 {
17221 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17222
17223 dictcnt++;
17224
17225 dictfiles[dictcnt - 1] = strdup (l1_filename);
17226 }
17227 }
17228 }
17229
17230 local_free (dictionary_files);
17231 }
17232 }
17233
17234 if (dictcnt < 1)
17235 {
17236 log_error ("ERROR: No usable dictionary file found.");
17237
17238 return (-1);
17239 }
17240
17241 if (increment)
17242 {
17243 maskcnt = 0;
17244
17245 uint mask_min = increment_min; // we can't reject smaller masks here
17246 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17247
17248 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17249 {
17250 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17251
17252 if (cur_mask == NULL) break;
17253
17254 masks[maskcnt] = cur_mask;
17255
17256 maskcnt++;
17257
17258 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17259 }
17260 }
17261 }
17262
17263 data.pw_min = pw_min;
17264 data.pw_max = pw_max;
17265
17266 /**
17267 * weak hash check
17268 */
17269
17270 if (weak_hash_threshold >= salts_cnt)
17271 {
17272 hc_device_param_t *device_param = NULL;
17273
17274 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17275 {
17276 device_param = &data.devices_param[device_id];
17277
17278 if (device_param->skipped) continue;
17279
17280 break;
17281 }
17282
17283 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17284
17285 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17286 {
17287 weak_hash_check (device_param, salt_pos);
17288 }
17289
17290 // Display hack, guarantee that there is at least one \r before real start
17291
17292 //if (data.quiet == 0) log_info ("");
17293 }
17294
17295 /**
17296 * status and monitor threads
17297 */
17298
17299 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17300 {
17301 data.devices_status = STATUS_STARTING;
17302 }
17303
17304 uint inner_threads_cnt = 0;
17305
17306 hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17307
17308 data.shutdown_inner = 0;
17309
17310 /**
17311 * Outfile remove
17312 */
17313
17314 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
17315 {
17316 hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL);
17317
17318 inner_threads_cnt++;
17319
17320 if (outfile_check_timer != 0)
17321 {
17322 if (data.outfile_check_directory != NULL)
17323 {
17324 if ((hash_mode != 5200) &&
17325 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17326 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17327 (hash_mode != 9000))
17328 {
17329 hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL);
17330
17331 inner_threads_cnt++;
17332 }
17333 else
17334 {
17335 outfile_check_timer = 0;
17336 }
17337 }
17338 else
17339 {
17340 outfile_check_timer = 0;
17341 }
17342 }
17343 }
17344
17345 /**
17346 * Inform the user if we got some hashes remove because of the pot file remove feature
17347 */
17348
17349 if (data.quiet == 0)
17350 {
17351 if (potfile_remove_cracks > 0)
17352 {
17353 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17354 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17355 }
17356 }
17357
17358 data.outfile_check_timer = outfile_check_timer;
17359
17360 /**
17361 * main loop
17362 */
17363
17364 char **induction_dictionaries = NULL;
17365
17366 int induction_dictionaries_cnt = 0;
17367
17368 hcstat_table_t *root_table_buf = NULL;
17369 hcstat_table_t *markov_table_buf = NULL;
17370
17371 uint initial_restore_done = 0;
17372
17373 data.maskcnt = maskcnt;
17374
17375 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17376 {
17377 if (data.devices_status == STATUS_CRACKED) continue;
17378 if (data.devices_status == STATUS_ABORTED) continue;
17379 if (data.devices_status == STATUS_QUIT) continue;
17380
17381 if (maskpos > rd->maskpos)
17382 {
17383 rd->dictpos = 0;
17384 }
17385
17386 rd->maskpos = maskpos;
17387 data.maskpos = maskpos;
17388
17389 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17390 {
17391 char *mask = masks[maskpos];
17392
17393 if (mask_from_file == 1)
17394 {
17395 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17396
17397 char *str_ptr;
17398 uint str_pos;
17399
17400 uint mask_offset = 0;
17401
17402 uint separator_cnt;
17403
17404 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17405 {
17406 str_ptr = strstr (mask + mask_offset, ",");
17407
17408 if (str_ptr == NULL) break;
17409
17410 str_pos = str_ptr - mask;
17411
17412 // escaped separator, i.e. "\,"
17413
17414 if (str_pos > 0)
17415 {
17416 if (mask[str_pos - 1] == '\\')
17417 {
17418 separator_cnt --;
17419
17420 mask_offset = str_pos + 1;
17421
17422 continue;
17423 }
17424 }
17425
17426 // reset the offset
17427
17428 mask_offset = 0;
17429
17430 mask[str_pos] = '\0';
17431
17432 switch (separator_cnt)
17433 {
17434 case 0:
17435 mp_reset_usr (mp_usr, 0);
17436
17437 custom_charset_1 = mask;
17438 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17439 break;
17440
17441 case 1:
17442 mp_reset_usr (mp_usr, 1);
17443
17444 custom_charset_2 = mask;
17445 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17446 break;
17447
17448 case 2:
17449 mp_reset_usr (mp_usr, 2);
17450
17451 custom_charset_3 = mask;
17452 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17453 break;
17454
17455 case 3:
17456 mp_reset_usr (mp_usr, 3);
17457
17458 custom_charset_4 = mask;
17459 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17460 break;
17461 }
17462
17463 mask = mask + str_pos + 1;
17464 }
17465 }
17466
17467 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17468 {
17469 if (maskpos > 0)
17470 {
17471 local_free (css_buf);
17472 local_free (data.root_css_buf);
17473 local_free (data.markov_css_buf);
17474
17475 local_free (masks[maskpos - 1]);
17476 }
17477
17478 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17479
17480 data.mask = mask;
17481 data.css_cnt = css_cnt;
17482 data.css_buf = css_buf;
17483
17484 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17485
17486 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17487
17488 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17489 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17490
17491 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17492
17493 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17494
17495 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17496 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17497
17498 data.root_css_buf = root_css_buf;
17499 data.markov_css_buf = markov_css_buf;
17500
17501 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17502
17503 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17504
17505 local_free (root_table_buf);
17506 local_free (markov_table_buf);
17507
17508 // args
17509
17510 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17511 {
17512 hc_device_param_t *device_param = &data.devices_param[device_id];
17513
17514 if (device_param->skipped) continue;
17515
17516 device_param->kernel_params_mp[0] = &device_param->d_combs;
17517 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17518 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17519
17520 device_param->kernel_params_mp_buf64[3] = 0;
17521 device_param->kernel_params_mp_buf32[4] = css_cnt;
17522 device_param->kernel_params_mp_buf32[5] = 0;
17523 device_param->kernel_params_mp_buf32[6] = 0;
17524 device_param->kernel_params_mp_buf32[7] = 0;
17525
17526 if (attack_mode == ATTACK_MODE_HYBRID1)
17527 {
17528 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17529 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17530 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17531 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17532 }
17533 else if (attack_mode == ATTACK_MODE_HYBRID2)
17534 {
17535 device_param->kernel_params_mp_buf32[5] = 0;
17536 device_param->kernel_params_mp_buf32[6] = 0;
17537 device_param->kernel_params_mp_buf32[7] = 0;
17538 }
17539
17540 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]);
17541 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]);
17542 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]);
17543
17544 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);
17545 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);
17546 }
17547 }
17548 else if (attack_mode == ATTACK_MODE_BF)
17549 {
17550 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17551
17552 if (increment)
17553 {
17554 for (uint i = 0; i < dictcnt; i++)
17555 {
17556 local_free (dictfiles[i]);
17557 }
17558
17559 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17560 {
17561 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17562
17563 if (l1_filename == NULL) break;
17564
17565 dictcnt++;
17566
17567 dictfiles[dictcnt - 1] = l1_filename;
17568 }
17569 }
17570 else
17571 {
17572 dictcnt++;
17573
17574 dictfiles[dictcnt - 1] = mask;
17575 }
17576
17577 if (dictcnt == 0)
17578 {
17579 log_error ("ERROR: Mask is too small");
17580
17581 return (-1);
17582 }
17583 }
17584 }
17585
17586 free (induction_dictionaries);
17587
17588 // induction_dictionaries_cnt = 0; // implied
17589
17590 if (attack_mode != ATTACK_MODE_BF)
17591 {
17592 if (keyspace == 0)
17593 {
17594 induction_dictionaries = scan_directory (induction_directory);
17595
17596 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17597 }
17598 }
17599
17600 if (induction_dictionaries_cnt)
17601 {
17602 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17603 }
17604
17605 /**
17606 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17607 */
17608 if (keyspace == 1)
17609 {
17610 if ((maskcnt > 1) || (dictcnt > 1))
17611 {
17612 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17613
17614 return (-1);
17615 }
17616 }
17617
17618 for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
17619 {
17620 if (data.devices_status == STATUS_CRACKED) continue;
17621 if (data.devices_status == STATUS_ABORTED) continue;
17622 if (data.devices_status == STATUS_QUIT) continue;
17623
17624 rd->dictpos = dictpos;
17625
17626 char *subid = logfile_generate_subid ();
17627
17628 data.subid = subid;
17629
17630 logfile_sub_msg ("START");
17631
17632 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17633 {
17634 data.devices_status = STATUS_INIT;
17635 }
17636
17637 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17638 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17639 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17640
17641 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17642
17643 data.cpt_pos = 0;
17644
17645 data.cpt_start = time (NULL);
17646
17647 data.cpt_total = 0;
17648
17649 if (data.restore == 0)
17650 {
17651 rd->words_cur = skip;
17652
17653 skip = 0;
17654
17655 data.skip = 0;
17656 }
17657
17658 data.ms_paused = 0;
17659
17660 data.kernel_power_final = 0;
17661
17662 data.words_cur = rd->words_cur;
17663
17664 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17665 {
17666 hc_device_param_t *device_param = &data.devices_param[device_id];
17667
17668 if (device_param->skipped) continue;
17669
17670 device_param->speed_pos = 0;
17671
17672 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17673 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17674
17675 device_param->exec_pos = 0;
17676
17677 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17678
17679 device_param->outerloop_pos = 0;
17680 device_param->outerloop_left = 0;
17681 device_param->innerloop_pos = 0;
17682 device_param->innerloop_left = 0;
17683
17684 // some more resets:
17685
17686 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17687
17688 device_param->pws_cnt = 0;
17689
17690 device_param->words_off = 0;
17691 device_param->words_done = 0;
17692 }
17693
17694 // figure out some workload
17695
17696 if (attack_mode == ATTACK_MODE_STRAIGHT)
17697 {
17698 if (data.wordlist_mode == WL_MODE_FILE)
17699 {
17700 char *dictfile = NULL;
17701
17702 if (induction_dictionaries_cnt)
17703 {
17704 dictfile = induction_dictionaries[0];
17705 }
17706 else
17707 {
17708 dictfile = dictfiles[dictpos];
17709 }
17710
17711 data.dictfile = dictfile;
17712
17713 logfile_sub_string (dictfile);
17714
17715 for (uint i = 0; i < rp_files_cnt; i++)
17716 {
17717 logfile_sub_var_string ("rulefile", rp_files[i]);
17718 }
17719
17720 FILE *fd2 = fopen (dictfile, "rb");
17721
17722 if (fd2 == NULL)
17723 {
17724 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17725
17726 return (-1);
17727 }
17728
17729 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17730
17731 fclose (fd2);
17732
17733 if (data.words_cnt == 0)
17734 {
17735 logfile_sub_msg ("STOP");
17736
17737 continue;
17738 }
17739 }
17740 }
17741 else if (attack_mode == ATTACK_MODE_COMBI)
17742 {
17743 char *dictfile = data.dictfile;
17744 char *dictfile2 = data.dictfile2;
17745
17746 logfile_sub_string (dictfile);
17747 logfile_sub_string (dictfile2);
17748
17749 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17750 {
17751 FILE *fd2 = fopen (dictfile, "rb");
17752
17753 if (fd2 == NULL)
17754 {
17755 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17756
17757 return (-1);
17758 }
17759
17760 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17761
17762 fclose (fd2);
17763 }
17764 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17765 {
17766 FILE *fd2 = fopen (dictfile2, "rb");
17767
17768 if (fd2 == NULL)
17769 {
17770 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17771
17772 return (-1);
17773 }
17774
17775 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17776
17777 fclose (fd2);
17778 }
17779
17780 if (data.words_cnt == 0)
17781 {
17782 logfile_sub_msg ("STOP");
17783
17784 continue;
17785 }
17786 }
17787 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17788 {
17789 char *dictfile = NULL;
17790
17791 if (induction_dictionaries_cnt)
17792 {
17793 dictfile = induction_dictionaries[0];
17794 }
17795 else
17796 {
17797 dictfile = dictfiles[dictpos];
17798 }
17799
17800 data.dictfile = dictfile;
17801
17802 char *mask = data.mask;
17803
17804 logfile_sub_string (dictfile);
17805 logfile_sub_string (mask);
17806
17807 FILE *fd2 = fopen (dictfile, "rb");
17808
17809 if (fd2 == NULL)
17810 {
17811 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17812
17813 return (-1);
17814 }
17815
17816 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17817
17818 fclose (fd2);
17819
17820 if (data.words_cnt == 0)
17821 {
17822 logfile_sub_msg ("STOP");
17823
17824 continue;
17825 }
17826 }
17827 else if (attack_mode == ATTACK_MODE_BF)
17828 {
17829 local_free (css_buf);
17830 local_free (data.root_css_buf);
17831 local_free (data.markov_css_buf);
17832
17833 char *mask = dictfiles[dictpos];
17834
17835 logfile_sub_string (mask);
17836
17837 // base
17838
17839 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17840
17841 if (opts_type & OPTS_TYPE_PT_UNICODE)
17842 {
17843 uint css_cnt_unicode = css_cnt * 2;
17844
17845 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17846
17847 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17848 {
17849 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17850
17851 css_buf_unicode[j + 1].cs_buf[0] = 0;
17852 css_buf_unicode[j + 1].cs_len = 1;
17853 }
17854
17855 free (css_buf);
17856
17857 css_buf = css_buf_unicode;
17858 css_cnt = css_cnt_unicode;
17859 }
17860
17861 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17862
17863 uint mask_min = pw_min;
17864 uint mask_max = pw_max;
17865
17866 if (opts_type & OPTS_TYPE_PT_UNICODE)
17867 {
17868 mask_min *= 2;
17869 mask_max *= 2;
17870 }
17871
17872 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17873 {
17874 if (css_cnt < mask_min)
17875 {
17876 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17877 }
17878
17879 if (css_cnt > mask_max)
17880 {
17881 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17882 }
17883
17884 // skip to next mask
17885
17886 logfile_sub_msg ("STOP");
17887
17888 continue;
17889 }
17890
17891 uint save_css_cnt = css_cnt;
17892
17893 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17894 {
17895 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17896 {
17897 uint salt_len = (uint) data.salts_buf[0].salt_len;
17898 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17899
17900 uint css_cnt_salt = css_cnt + salt_len;
17901
17902 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17903
17904 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17905
17906 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17907 {
17908 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17909 css_buf_salt[j].cs_len = 1;
17910 }
17911
17912 free (css_buf);
17913
17914 css_buf = css_buf_salt;
17915 css_cnt = css_cnt_salt;
17916 }
17917 }
17918
17919 data.mask = mask;
17920 data.css_cnt = css_cnt;
17921 data.css_buf = css_buf;
17922
17923 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17924
17925 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17926
17927 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17928
17929 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17930 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17931
17932 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17933
17934 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17935
17936 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17937 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17938
17939 data.root_css_buf = root_css_buf;
17940 data.markov_css_buf = markov_css_buf;
17941
17942 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17943
17944 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17945
17946 local_free (root_table_buf);
17947 local_free (markov_table_buf);
17948
17949 // copy + args
17950
17951 uint css_cnt_l = css_cnt;
17952 uint css_cnt_r;
17953
17954 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17955 {
17956 if (save_css_cnt < 6)
17957 {
17958 css_cnt_r = 1;
17959 }
17960 else if (save_css_cnt == 6)
17961 {
17962 css_cnt_r = 2;
17963 }
17964 else
17965 {
17966 if (opts_type & OPTS_TYPE_PT_UNICODE)
17967 {
17968 if (save_css_cnt == 8 || save_css_cnt == 10)
17969 {
17970 css_cnt_r = 2;
17971 }
17972 else
17973 {
17974 css_cnt_r = 4;
17975 }
17976 }
17977 else
17978 {
17979 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17980 {
17981 css_cnt_r = 3;
17982 }
17983 else
17984 {
17985 css_cnt_r = 4;
17986 }
17987 }
17988 }
17989 }
17990 else
17991 {
17992 css_cnt_r = 1;
17993
17994 /* unfinished code?
17995 int sum = css_buf[css_cnt_r - 1].cs_len;
17996
17997 for (uint i = 1; i < 4 && i < css_cnt; i++)
17998 {
17999 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
18000
18001 css_cnt_r++;
18002
18003 sum *= css_buf[css_cnt_r - 1].cs_len;
18004 }
18005 */
18006 }
18007
18008 css_cnt_l -= css_cnt_r;
18009
18010 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
18011
18012 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18013 {
18014 hc_device_param_t *device_param = &data.devices_param[device_id];
18015
18016 if (device_param->skipped) continue;
18017
18018 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
18019 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
18020 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
18021
18022 device_param->kernel_params_mp_l_buf64[3] = 0;
18023 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
18024 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
18025 device_param->kernel_params_mp_l_buf32[6] = 0;
18026 device_param->kernel_params_mp_l_buf32[7] = 0;
18027 device_param->kernel_params_mp_l_buf32[8] = 0;
18028
18029 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
18030 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
18031 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
18032 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
18033
18034 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
18035 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
18036 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
18037
18038 device_param->kernel_params_mp_r_buf64[3] = 0;
18039 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
18040 device_param->kernel_params_mp_r_buf32[5] = 0;
18041 device_param->kernel_params_mp_r_buf32[6] = 0;
18042 device_param->kernel_params_mp_r_buf32[7] = 0;
18043
18044 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]);
18045 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]);
18046 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]);
18047
18048 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]);
18049 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]);
18050 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]);
18051
18052 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);
18053 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);
18054 }
18055 }
18056
18057 u64 words_base = data.words_cnt;
18058
18059 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18060 {
18061 if (data.kernel_rules_cnt)
18062 {
18063 words_base /= data.kernel_rules_cnt;
18064 }
18065 }
18066 else if (data.attack_kern == ATTACK_KERN_COMBI)
18067 {
18068 if (data.combs_cnt)
18069 {
18070 words_base /= data.combs_cnt;
18071 }
18072 }
18073 else if (data.attack_kern == ATTACK_KERN_BF)
18074 {
18075 if (data.bfs_cnt)
18076 {
18077 words_base /= data.bfs_cnt;
18078 }
18079 }
18080
18081 data.words_base = words_base;
18082
18083 if (keyspace == 1)
18084 {
18085 log_info ("%llu", (unsigned long long int) words_base);
18086
18087 return (0);
18088 }
18089
18090 if (data.words_cur > data.words_base)
18091 {
18092 log_error ("ERROR: Restore value greater keyspace");
18093
18094 return (-1);
18095 }
18096
18097 if (data.words_cur)
18098 {
18099 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18100 {
18101 for (uint i = 0; i < data.salts_cnt; i++)
18102 {
18103 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18104 }
18105 }
18106 else if (data.attack_kern == ATTACK_KERN_COMBI)
18107 {
18108 for (uint i = 0; i < data.salts_cnt; i++)
18109 {
18110 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18111 }
18112 }
18113 else if (data.attack_kern == ATTACK_KERN_BF)
18114 {
18115 for (uint i = 0; i < data.salts_cnt; i++)
18116 {
18117 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18118 }
18119 }
18120 }
18121
18122 /*
18123 * Update loopback file
18124 */
18125
18126 if (loopback == 1)
18127 {
18128 time_t now;
18129
18130 time (&now);
18131
18132 uint random_num = get_random_num (0, 9999);
18133
18134 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18135
18136 data.loopback_file = loopback_file;
18137 }
18138
18139 /*
18140 * Update dictionary statistic
18141 */
18142
18143 if (keyspace == 0)
18144 {
18145 dictstat_fp = fopen (dictstat, "wb");
18146
18147 if (dictstat_fp)
18148 {
18149 lock_file (dictstat_fp);
18150
18151 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18152
18153 fclose (dictstat_fp);
18154 }
18155 }
18156
18157 /**
18158 * create autotune threads
18159 */
18160
18161 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18162
18163 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18164 {
18165 data.devices_status = STATUS_AUTOTUNE;
18166 }
18167
18168 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18169 {
18170 hc_device_param_t *device_param = &devices_param[device_id];
18171
18172 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18173 }
18174
18175 hc_thread_wait (data.devices_cnt, c_threads);
18176
18177 /*
18178 * Inform user about possible slow speeds
18179 */
18180
18181 uint hardware_power_all = 0;
18182
18183 uint kernel_power_all = 0;
18184
18185 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18186 {
18187 hc_device_param_t *device_param = &devices_param[device_id];
18188
18189 hardware_power_all += device_param->hardware_power;
18190
18191 kernel_power_all += device_param->kernel_power;
18192 }
18193
18194 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
18195
18196 data.kernel_power_all = kernel_power_all;
18197
18198 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18199 {
18200 if (data.words_base < kernel_power_all)
18201 {
18202 if (quiet == 0)
18203 {
18204 clear_prompt ();
18205
18206 log_info ("ATTENTION!");
18207 log_info (" The wordlist or mask you are using is too small.");
18208 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18209 log_info (" The cracking speed will drop.");
18210 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18211 log_info ("");
18212 }
18213 }
18214 }
18215
18216 /**
18217 * create cracker threads
18218 */
18219
18220 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18221 {
18222 data.devices_status = STATUS_RUNNING;
18223 }
18224
18225 if (initial_restore_done == 0)
18226 {
18227 if (data.restore_disable == 0) cycle_restore ();
18228
18229 initial_restore_done = 1;
18230 }
18231
18232 hc_timer_set (&data.timer_running);
18233
18234 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18235 {
18236 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18237 {
18238 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18239 if (quiet == 0) fflush (stdout);
18240 }
18241 }
18242 else if (wordlist_mode == WL_MODE_STDIN)
18243 {
18244 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18245 if (data.quiet == 0) log_info ("");
18246 }
18247
18248 time_t runtime_start;
18249
18250 time (&runtime_start);
18251
18252 data.runtime_start = runtime_start;
18253
18254 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18255 {
18256 hc_device_param_t *device_param = &devices_param[device_id];
18257
18258 if (wordlist_mode == WL_MODE_STDIN)
18259 {
18260 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18261 }
18262 else
18263 {
18264 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18265 }
18266 }
18267
18268 hc_thread_wait (data.devices_cnt, c_threads);
18269
18270 local_free (c_threads);
18271
18272 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18273 {
18274 data.devices_status = STATUS_EXHAUSTED;
18275 }
18276
18277 logfile_sub_var_uint ("status-after-work", data.devices_status);
18278
18279 data.restore = 0;
18280
18281 if (induction_dictionaries_cnt)
18282 {
18283 unlink (induction_dictionaries[0]);
18284 }
18285
18286 free (induction_dictionaries);
18287
18288 if (attack_mode != ATTACK_MODE_BF)
18289 {
18290 induction_dictionaries = scan_directory (induction_directory);
18291
18292 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18293 }
18294
18295 if (benchmark == 1)
18296 {
18297 status_benchmark ();
18298
18299 if (machine_readable == 0)
18300 {
18301 log_info ("");
18302 }
18303 }
18304 else
18305 {
18306 if (quiet == 0)
18307 {
18308 clear_prompt ();
18309
18310 log_info ("");
18311
18312 status_display ();
18313
18314 log_info ("");
18315 }
18316 else
18317 {
18318 if (status == 1)
18319 {
18320 status_display ();
18321 }
18322 }
18323 }
18324
18325 if (induction_dictionaries_cnt)
18326 {
18327 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18328 }
18329
18330 time_t runtime_stop;
18331
18332 time (&runtime_stop);
18333
18334 data.runtime_stop = runtime_stop;
18335
18336 logfile_sub_uint (runtime_start);
18337 logfile_sub_uint (runtime_stop);
18338
18339 logfile_sub_msg ("STOP");
18340
18341 global_free (subid);
18342
18343 // from this point we handle bypass as running
18344
18345 if (data.devices_status == STATUS_BYPASS)
18346 {
18347 data.devices_status = STATUS_RUNNING;
18348 }
18349
18350 // and overwrite benchmark aborts as well
18351
18352 if (data.benchmark == 1)
18353 {
18354 if (data.devices_status == STATUS_ABORTED)
18355 {
18356 data.devices_status = STATUS_RUNNING;
18357 }
18358 }
18359
18360 // finalize task
18361
18362 if (data.devices_status == STATUS_CRACKED) break;
18363 if (data.devices_status == STATUS_ABORTED) break;
18364 if (data.devices_status == STATUS_QUIT) break;
18365 }
18366
18367 if (data.devices_status == STATUS_CRACKED) break;
18368 if (data.devices_status == STATUS_ABORTED) break;
18369 if (data.devices_status == STATUS_QUIT) break;
18370 }
18371
18372 // 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
18373 if (attack_mode == ATTACK_MODE_STRAIGHT)
18374 {
18375 if (data.wordlist_mode == WL_MODE_FILE)
18376 {
18377 if (data.dictfile == NULL)
18378 {
18379 if (dictfiles != NULL)
18380 {
18381 data.dictfile = dictfiles[0];
18382
18383 hc_timer_set (&data.timer_running);
18384 }
18385 }
18386 }
18387 }
18388 // NOTE: combi is okay because it is already set beforehand
18389 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18390 {
18391 if (data.dictfile == NULL)
18392 {
18393 if (dictfiles != NULL)
18394 {
18395 hc_timer_set (&data.timer_running);
18396
18397 data.dictfile = dictfiles[0];
18398 }
18399 }
18400 }
18401 else if (attack_mode == ATTACK_MODE_BF)
18402 {
18403 if (data.mask == NULL)
18404 {
18405 hc_timer_set (&data.timer_running);
18406
18407 data.mask = masks[0];
18408 }
18409 }
18410
18411 // if cracked / aborted remove last induction dictionary
18412
18413 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18414 {
18415 struct stat induct_stat;
18416
18417 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18418 {
18419 unlink (induction_dictionaries[file_pos]);
18420 }
18421 }
18422
18423 // wait for inner threads
18424
18425 data.shutdown_inner = 1;
18426
18427 for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++)
18428 {
18429 hc_thread_wait (1, &inner_threads[thread_idx]);
18430 }
18431
18432 local_free (inner_threads);
18433
18434 // we dont need restore file anymore
18435 if (data.restore_disable == 0)
18436 {
18437 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18438 {
18439 unlink (eff_restore_file);
18440 unlink (new_restore_file);
18441 }
18442 else
18443 {
18444 cycle_restore ();
18445 }
18446 }
18447
18448 // finally save left hashes
18449
18450 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18451 {
18452 save_hash ();
18453 }
18454
18455 /**
18456 * Clean up
18457 */
18458
18459 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18460 {
18461 hc_device_param_t *device_param = &data.devices_param[device_id];
18462
18463 if (device_param->skipped) continue;
18464
18465 local_free (device_param->combs_buf);
18466 local_free (device_param->hooks_buf);
18467 local_free (device_param->device_name);
18468 local_free (device_param->device_name_chksum);
18469 local_free (device_param->device_version);
18470 local_free (device_param->driver_version);
18471
18472 if (device_param->pws_buf) myfree (device_param->pws_buf);
18473 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18474 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18475 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18476 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18477 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18478 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18479 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18480 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18481 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18482 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18483 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18484 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18485 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18486 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18487 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18488 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18489 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18490 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18491 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18492 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18493 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18494 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18495 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18496 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18497 if (device_param->d_scryptV0_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV0_buf);
18498 if (device_param->d_scryptV1_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV1_buf);
18499 if (device_param->d_scryptV2_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV2_buf);
18500 if (device_param->d_scryptV3_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV3_buf);
18501 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18502 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18503 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18504
18505 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18506 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18507 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18508 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18509 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18510 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18511 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18512 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18513 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18514 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18515 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18516
18517 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18518 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18519 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18520
18521 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18522 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18523 }
18524
18525 // reset default fan speed
18526
18527 #ifdef HAVE_HWMON
18528 if (gpu_temp_disable == 0)
18529 {
18530 if (gpu_temp_retain != 0)
18531 {
18532 hc_thread_mutex_lock (mux_adl);
18533
18534 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18535 {
18536 hc_device_param_t *device_param = &data.devices_param[device_id];
18537
18538 if (device_param->skipped) continue;
18539
18540 if (data.hm_device[device_id].fan_set_supported == 1)
18541 {
18542 int rc = -1;
18543
18544 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18545 {
18546 rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0);
18547 }
18548 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18549 {
18550 #ifdef LINUX
18551 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18552 #endif
18553
18554 #ifdef WIN
18555 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 0);
18556 #endif
18557 }
18558
18559 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18560 }
18561 }
18562
18563 hc_thread_mutex_unlock (mux_adl);
18564 }
18565 }
18566
18567 // reset power tuning
18568
18569 if (powertune_enable == 1)
18570 {
18571 hc_thread_mutex_lock (mux_adl);
18572
18573 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18574 {
18575 hc_device_param_t *device_param = &data.devices_param[device_id];
18576
18577 if (device_param->skipped) continue;
18578
18579 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18580 {
18581 if (data.hm_device[device_id].od_version == 6)
18582 {
18583 // check powertune capabilities first, if not available then skip device
18584
18585 int powertune_supported = 0;
18586
18587 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18588 {
18589 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18590
18591 return (-1);
18592 }
18593
18594 if (powertune_supported != 0)
18595 {
18596 // powercontrol settings
18597
18598 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18599 {
18600 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18601
18602 return (-1);
18603 }
18604
18605 // clocks
18606
18607 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18608
18609 performance_state->iNumberOfPerformanceLevels = 2;
18610
18611 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18612 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18613 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18614 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18615
18616 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18617 {
18618 log_info ("ERROR: Failed to restore ADL performance state");
18619
18620 return (-1);
18621 }
18622
18623 local_free (performance_state);
18624 }
18625 }
18626 }
18627
18628 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18629 {
18630 unsigned int limit = nvml_power_limit[device_id];
18631
18632 if (limit > 0)
18633 {
18634 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18635 }
18636 }
18637 }
18638
18639 hc_thread_mutex_unlock (mux_adl);
18640 }
18641
18642 if (gpu_temp_disable == 0)
18643 {
18644 if (data.hm_nvml)
18645 {
18646 hm_NVML_nvmlShutdown (data.hm_nvml);
18647
18648 nvml_close (data.hm_nvml);
18649
18650 data.hm_nvml = NULL;
18651 }
18652
18653 if (data.hm_nvapi)
18654 {
18655 hm_NvAPI_Unload (data.hm_nvapi);
18656
18657 nvapi_close (data.hm_nvapi);
18658
18659 data.hm_nvapi = NULL;
18660 }
18661
18662 if (data.hm_xnvctrl)
18663 {
18664 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18665
18666 xnvctrl_close (data.hm_xnvctrl);
18667
18668 data.hm_xnvctrl = NULL;
18669 }
18670
18671 if (data.hm_adl)
18672 {
18673 hm_ADL_Main_Control_Destroy (data.hm_adl);
18674
18675 adl_close (data.hm_adl);
18676
18677 data.hm_adl = NULL;
18678 }
18679 }
18680 #endif // HAVE_HWMON
18681
18682 // free memory
18683
18684 local_free (masks);
18685
18686 local_free (dictstat_base);
18687
18688 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18689 {
18690 pot_t *pot_ptr = &pot[pot_pos];
18691
18692 hash_t *hash = &pot_ptr->hash;
18693
18694 local_free (hash->digest);
18695
18696 if (isSalted)
18697 {
18698 local_free (hash->salt);
18699 }
18700 }
18701
18702 local_free (pot);
18703
18704 local_free (all_kernel_rules_cnt);
18705 local_free (all_kernel_rules_buf);
18706
18707 local_free (wl_data->buf);
18708 local_free (wl_data);
18709
18710 local_free (bitmap_s1_a);
18711 local_free (bitmap_s1_b);
18712 local_free (bitmap_s1_c);
18713 local_free (bitmap_s1_d);
18714 local_free (bitmap_s2_a);
18715 local_free (bitmap_s2_b);
18716 local_free (bitmap_s2_c);
18717 local_free (bitmap_s2_d);
18718
18719 #ifdef HAVE_HWMON
18720 local_free (od_clock_mem_status);
18721 local_free (od_power_control_status);
18722 local_free (nvml_power_limit);
18723 #endif
18724
18725 global_free (devices_param);
18726
18727 global_free (kernel_rules_buf);
18728
18729 global_free (root_css_buf);
18730 global_free (markov_css_buf);
18731
18732 global_free (digests_buf);
18733 global_free (digests_shown);
18734 global_free (digests_shown_tmp);
18735
18736 global_free (salts_buf);
18737 global_free (salts_shown);
18738
18739 global_free (esalts_buf);
18740
18741 global_free (words_progress_done);
18742 global_free (words_progress_rejected);
18743 global_free (words_progress_restored);
18744
18745 if (pot_fp) fclose (pot_fp);
18746
18747 if (data.devices_status == STATUS_QUIT) break;
18748 }
18749
18750 // wait for outer threads
18751
18752 data.shutdown_outer = 1;
18753
18754 for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++)
18755 {
18756 hc_thread_wait (1, &outer_threads[thread_idx]);
18757 }
18758
18759 local_free (outer_threads);
18760
18761 // destroy others mutex
18762
18763 hc_thread_mutex_delete (mux_dispatcher);
18764 hc_thread_mutex_delete (mux_counter);
18765 hc_thread_mutex_delete (mux_display);
18766 hc_thread_mutex_delete (mux_adl);
18767
18768 // free memory
18769
18770 local_free (eff_restore_file);
18771 local_free (new_restore_file);
18772
18773 local_free (rd);
18774
18775 // tuning db
18776
18777 tuning_db_destroy (tuning_db);
18778
18779 // loopback
18780
18781 local_free (loopback_file);
18782
18783 if (loopback == 1) unlink (loopback_file);
18784
18785 // induction directory
18786
18787 if (induction_dir == NULL)
18788 {
18789 if (attack_mode != ATTACK_MODE_BF)
18790 {
18791 if (rmdir (induction_directory) == -1)
18792 {
18793 if (errno == ENOENT)
18794 {
18795 // good, we can ignore
18796 }
18797 else if (errno == ENOTEMPTY)
18798 {
18799 // good, we can ignore
18800 }
18801 else
18802 {
18803 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18804
18805 return (-1);
18806 }
18807 }
18808
18809 local_free (induction_directory);
18810 }
18811 }
18812
18813 // outfile-check directory
18814
18815 if (outfile_check_dir == NULL)
18816 {
18817 if (rmdir (outfile_check_directory) == -1)
18818 {
18819 if (errno == ENOENT)
18820 {
18821 // good, we can ignore
18822 }
18823 else if (errno == ENOTEMPTY)
18824 {
18825 // good, we can ignore
18826 }
18827 else
18828 {
18829 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18830
18831 return (-1);
18832 }
18833 }
18834
18835 local_free (outfile_check_directory);
18836 }
18837
18838 time_t proc_stop;
18839
18840 time (&proc_stop);
18841
18842 logfile_top_uint (proc_start);
18843 logfile_top_uint (proc_stop);
18844
18845 logfile_top_msg ("STOP");
18846
18847 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18848 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18849
18850 if (data.ocl) ocl_close (data.ocl);
18851
18852 if (data.devices_status == STATUS_ABORTED) return 2;
18853 if (data.devices_status == STATUS_QUIT) return 2;
18854 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18855 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18856 if (data.devices_status == STATUS_CRACKED) return 0;
18857
18858 return -1;
18859 }
Hashcat additions to support pwdhash