projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Replace DARWIN macro with __APPLE__
[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 __APPLE__
10 #include <stdio.h>
11 #endif
12
13 #ifdef __FreeBSD__
14 #include <stdio.h>
15 #endif
16
17 #include <common.h>
18 #include <shared.h>
19 #include <rp_kernel_on_cpu.h>
20 #include <getopt.h>
21
22 const char *PROGNAME = "hashcat";
23 const uint VERSION_BIN = 300;
24 const uint RESTORE_MIN = 300;
25
26 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
27
28 #define INCR_RULES 10000
29 #define INCR_SALTS 100000
30 #define INCR_MASKS 1000
31 #define INCR_POT 1000
32
33 #define USAGE 0
34 #define VERSION 0
35 #define QUIET 0
36 #define MARKOV_THRESHOLD 0
37 #define MARKOV_DISABLE 0
38 #define MARKOV_CLASSIC 0
39 #define BENCHMARK 0
40 #define STDOUT_FLAG 0
41 #define RESTORE 0
42 #define RESTORE_TIMER 60
43 #define RESTORE_DISABLE 0
44 #define STATUS 0
45 #define STATUS_TIMER 10
46 #define MACHINE_READABLE 0
47 #define LOOPBACK 0
48 #define WEAK_HASH_THRESHOLD 100
49 #define SHOW 0
50 #define LEFT 0
51 #define USERNAME 0
52 #define REMOVE 0
53 #define REMOVE_TIMER 60
54 #define SKIP 0
55 #define LIMIT 0
56 #define KEYSPACE 0
57 #define POTFILE_DISABLE 0
58 #define DEBUG_MODE 0
59 #define RP_GEN 0
60 #define RP_GEN_FUNC_MIN 1
61 #define RP_GEN_FUNC_MAX 4
62 #define RP_GEN_SEED 0
63 #define RULE_BUF_L ":"
64 #define RULE_BUF_R ":"
65 #define FORCE 0
66 #define RUNTIME 0
67 #define HEX_CHARSET 0
68 #define HEX_SALT 0
69 #define HEX_WORDLIST 0
70 #define OUTFILE_FORMAT 3
71 #define OUTFILE_AUTOHEX 1
72 #define OUTFILE_CHECK_TIMER 5
73 #define ATTACK_MODE 0
74 #define HASH_MODE 0
75 #define SEGMENT_SIZE 32
76 #define INCREMENT 0
77 #define INCREMENT_MIN 1
78 #define INCREMENT_MAX PW_MAX
79 #define SEPARATOR ':'
80 #define BITMAP_MIN 16
81 #define BITMAP_MAX 24
82 #define NVIDIA_SPIN_DAMP 100
83 #define GPU_TEMP_DISABLE 0
84 #define GPU_TEMP_ABORT 90
85 #define GPU_TEMP_RETAIN 75
86 #define WORKLOAD_PROFILE 2
87 #define KERNEL_ACCEL 0
88 #define KERNEL_LOOPS 0
89 #define KERNEL_RULES 1024
90 #define KERNEL_COMBS 1024
91 #define KERNEL_BFS 1024
92 #define KERNEL_THREADS_MAX 256
93 #define KERNEL_THREADS_MAX_CPU 1
94 #define POWERTUNE_ENABLE 0
95 #define LOGFILE_DISABLE 0
96 #define SCRYPT_TMTO 0
97 #define OPENCL_VECTOR_WIDTH 0
98
99 #define WL_MODE_STDIN 1
100 #define WL_MODE_FILE 2
101 #define WL_MODE_MASK 3
102
103 #define HL_MODE_FILE 4
104 #define HL_MODE_ARG 5
105
106 #define HLFMTS_CNT 11
107 #define HLFMT_HASHCAT 0
108 #define HLFMT_PWDUMP 1
109 #define HLFMT_PASSWD 2
110 #define HLFMT_SHADOW 3
111 #define HLFMT_DCC 4
112 #define HLFMT_DCC2 5
113 #define HLFMT_NETNTLM1 7
114 #define HLFMT_NETNTLM2 8
115 #define HLFMT_NSLDAP 9
116 #define HLFMT_NSLDAPS 10
117
118 #define HLFMT_TEXT_HASHCAT "native hashcat"
119 #define HLFMT_TEXT_PWDUMP "pwdump"
120 #define HLFMT_TEXT_PASSWD "passwd"
121 #define HLFMT_TEXT_SHADOW "shadow"
122 #define HLFMT_TEXT_DCC "DCC"
123 #define HLFMT_TEXT_DCC2 "DCC 2"
124 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
125 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
126 #define HLFMT_TEXT_NSLDAP "nsldap"
127 #define HLFMT_TEXT_NSLDAPS "nsldaps"
128
129 #define ATTACK_MODE_STRAIGHT 0
130 #define ATTACK_MODE_COMBI 1
131 #define ATTACK_MODE_TOGGLE 2
132 #define ATTACK_MODE_BF 3
133 #define ATTACK_MODE_PERM 4
134 #define ATTACK_MODE_TABLE 5
135 #define ATTACK_MODE_HYBRID1 6
136 #define ATTACK_MODE_HYBRID2 7
137 #define ATTACK_MODE_NONE 100
138
139 #define ATTACK_KERN_STRAIGHT 0
140 #define ATTACK_KERN_COMBI 1
141 #define ATTACK_KERN_BF 3
142 #define ATTACK_KERN_NONE 100
143
144 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
145 #define ATTACK_EXEC_INSIDE_KERNEL 11
146
147 #define COMBINATOR_MODE_BASE_LEFT 10001
148 #define COMBINATOR_MODE_BASE_RIGHT 10002
149
150 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
151 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
152
153 #define MAX_CUT_TRIES 4
154
155 #define MAX_DICTSTAT 10000
156
157 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
158
159 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
160
161 #define global_free(attr) \
162 { \
163 myfree ((void *) data.attr); \
164 \
165 data.attr = NULL; \
166 }
167
168 #define local_free(attr) \
169 { \
170 myfree ((void *) attr); \
171 \
172 attr = NULL; \
173 }
174
175 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
176 #define HC_API_CALL __stdcall
177 #else
178 #define HC_API_CALL
179 #endif
180
181 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
182 {
183 900,
184 0,
185 5100,
186 100,
187 1400,
188 10800,
189 1700,
190 5000,
191 10100,
192 6000,
193 6100,
194 6900,
195 11700,
196 11800,
197 400,
198 8900,
199 11900,
200 12000,
201 10900,
202 12100,
203 23,
204 2500,
205 5300,
206 5400,
207 5500,
208 5600,
209 7300,
210 7500,
211 13100,
212 8300,
213 11100,
214 11200,
215 11400,
216 121,
217 2611,
218 2711,
219 2811,
220 8400,
221 11,
222 2612,
223 7900,
224 21,
225 11000,
226 124,
227 10000,
228 3711,
229 7600,
230 12,
231 131,
232 132,
233 1731,
234 200,
235 300,
236 3100,
237 112,
238 12300,
239 8000,
240 141,
241 1441,
242 1600,
243 12600,
244 1421,
245 101,
246 111,
247 1711,
248 3000,
249 1000,
250 1100,
251 2100,
252 12800,
253 1500,
254 12400,
255 500,
256 3200,
257 7400,
258 1800,
259 122,
260 1722,
261 7100,
262 6300,
263 6700,
264 6400,
265 6500,
266 2400,
267 2410,
268 5700,
269 9200,
270 9300,
271 22,
272 501,
273 5800,
274 8100,
275 8500,
276 7200,
277 9900,
278 7700,
279 7800,
280 10300,
281 8600,
282 8700,
283 9100,
284 133,
285 13500,
286 11600,
287 13600,
288 12500,
289 13000,
290 13200,
291 13300,
292 6211,
293 6221,
294 6231,
295 6241,
296 13711,
297 13721,
298 13731,
299 13741,
300 13751,
301 13761,
302 8800,
303 12900,
304 12200,
305 9700,
306 9710,
307 9800,
308 9810,
309 9400,
310 9500,
311 9600,
312 10400,
313 10410,
314 10500,
315 10600,
316 10700,
317 9000,
318 5200,
319 6800,
320 6600,
321 8200,
322 11300,
323 12700,
324 13400,
325 125
326 };
327
328 /**
329 * types
330 */
331
332 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
333
334 /**
335 * globals
336 */
337
338 static unsigned int full01 = 0x01010101;
339 static unsigned int full80 = 0x80808080;
340
341 int SUPPRESS_OUTPUT = 0;
342
343 hc_thread_mutex_t mux_adl;
344 hc_thread_mutex_t mux_counter;
345 hc_thread_mutex_t mux_dispatcher;
346 hc_thread_mutex_t mux_display;
347
348 hc_global_data_t data;
349
350 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
351
352 const char *USAGE_MINI[] =
353 {
354 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
355 "",
356 "Try --help for more help.",
357 NULL
358 };
359
360 const char *USAGE_BIG[] =
361 {
362 "%s, advanced password recovery",
363 "",
364 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
365 "",
366 "- [ Options ] -",
367 "",
368 " Options Short / Long | Type | Description | Example",
369 "===============================+======+======================================================+=======================",
370 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
371 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
372 " -V, --version | | Print version |",
373 " -h, --help | | Print help |",
374 " --quiet | | Suppress output |",
375 " --hex-charset | | Assume charset is given in hex |",
376 " --hex-salt | | Assume salt is given in hex |",
377 " --hex-wordlist | | Assume words in wordlist is given in hex |",
378 " --force | | Ignore warnings |",
379 " --status | | Enable automatic update of the status-screen |",
380 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
381 " --machine-readable | | Display the status view in a machine readable format |",
382 " --loopback | | Add new plains to induct directory |",
383 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
384 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
385 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
386 " --markov-classic | | Enables classic markov-chains, no per-position |",
387 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
388 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
389 " --session | Str | Define specific session name | --session=mysession",
390 " --restore | | Restore session from --session |",
391 " --restore-disable | | Do not write restore file |",
392 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
393 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
394 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
395 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
396 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
397 " --stdout | | Do not crack a hash, instead print candidates only |",
398 " --show | | Compare hashlist with potfile; Show cracked hashes |",
399 " --left | | Compare hashlist with potfile; Show uncracked hashes |",
400 " --username | | Enable ignoring of usernames in hashfile |",
401 " --remove | | Enable remove of hash once it is cracked |",
402 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
403 " --potfile-disable | | Do not write potfile |",
404 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
405 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
406 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
407 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
408 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
409 " --logfile-disable | | Disable the logfile |",
410 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
411 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
412 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
413 " -b, --benchmark | | Run benchmark |",
414 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
415 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
416 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
417 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
418 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
419 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
420 " -D, --opencl-device-types | Str | OpenCL device-types to use, separate with comma | -D 1",
421 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
422 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
423 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
424 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
425 " --nvidia-spin-damp | Num | Workaround NVidias CPU burning loop bug, in percent | --nvidia-spin-damp=50",
426 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
427 #ifdef HAVE_HWMON
428 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
429 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
430 " --powertune-enable | | Enable power tuning, restores settings when finished |",
431 #endif
432 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
433 " -s, --skip | Num | Skip X words from the start | -s 1000000",
434 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
435 " --keyspace | | Show keyspace base:mod values and quit |",
436 " -j, --rule-left | Rule | Single rule applied to each word from left wordlist | -j 'c'",
437 " -k, --rule-right | Rule | Single rule applied to each word from right wordlist | -k '^-'",
438 " -r, --rules-file | File | Multiple rules applied to each word from wordlists | -r rules/best64.rule",
439 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
440 " --generate-rules-func-min | Num | Force min X funcs per rule |",
441 " --generate-rules-func-max | Num | Force max X funcs per rule |",
442 " --generate-rules-seed | Num | Force RNG seed set to X |",
443 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
444 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
445 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
446 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
447 " -i, --increment | | Enable mask increment mode |",
448 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
449 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
450 "",
451 "- [ Hash modes ] -",
452 "",
453 " # | Name | Category",
454 " ======+==================================================+======================================",
455 " 900 | MD4 | Raw Hash",
456 " 0 | MD5 | Raw Hash",
457 " 5100 | Half MD5 | Raw Hash",
458 " 100 | SHA1 | Raw Hash",
459 " 10800 | SHA-384 | Raw Hash",
460 " 1400 | SHA-256 | Raw Hash",
461 " 1700 | SHA-512 | Raw Hash",
462 " 5000 | SHA-3(Keccak) | Raw Hash",
463 " 10100 | SipHash | Raw Hash",
464 " 6000 | RipeMD160 | Raw Hash",
465 " 6100 | Whirlpool | Raw Hash",
466 " 6900 | GOST R 34.11-94 | Raw Hash",
467 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
468 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
469 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
471 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
472 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
473 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
474 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
475 " 2600 | md5(md5($pass)) | Raw Hash, Salted and / or Iterated",
476 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
477 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
478 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
479 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
480 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
481 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
482 " 4500 | sha1(sha1($pass)) | Raw Hash, Salted and / or Iterated",
483 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
484 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
485 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
486 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
487 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
488 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
489 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
490 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
491 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
492 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
493 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
494 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
495 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
496 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
497 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
498 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
499 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
500 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
501 " 400 | phpass | Generic KDF",
502 " 8900 | scrypt | Generic KDF",
503 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
504 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
505 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
506 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
507 " 23 | Skype | Network protocols",
508 " 2500 | WPA/WPA2 | Network protocols",
509 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
510 " 5300 | IKE-PSK MD5 | Network protocols",
511 " 5400 | IKE-PSK SHA1 | Network protocols",
512 " 5500 | NetNTLMv1 | Network protocols",
513 " 5500 | NetNTLMv1 + ESS | Network protocols",
514 " 5600 | NetNTLMv2 | Network protocols",
515 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
516 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
517 " 8300 | DNSSEC (NSEC3) | Network protocols",
518 " 10200 | Cram MD5 | Network protocols",
519 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
520 " 11200 | MySQL CRAM (SHA1) | Network protocols",
521 " 11400 | SIP digest authentication (MD5) | Network protocols",
522 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
523 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
524 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
525 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
526 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
527 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
528 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
529 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
530 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
531 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
532 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
533 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
534 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
535 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
536 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
537 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
538 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
539 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
540 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
541 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
542 " 12 | PostgreSQL | Database Server",
543 " 131 | MSSQL(2000) | Database Server",
544 " 132 | MSSQL(2005) | Database Server",
545 " 1731 | MSSQL(2012) | Database Server",
546 " 1731 | MSSQL(2014) | Database Server",
547 " 200 | MySQL323 | Database Server",
548 " 300 | MySQL4.1/MySQL5 | Database Server",
549 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
550 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
551 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
552 " 8000 | Sybase ASE | Database Server",
553 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
554 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
555 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
556 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
557 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
558 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
559 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
560 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
561 " 11500 | CRC32 | Checksums",
562 " 3000 | LM | Operating-Systems",
563 " 1000 | NTLM | Operating-Systems",
564 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
565 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
566 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
567 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
568 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
569 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
570 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
571 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
572 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
573 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
574 " 1722 | OSX v10.7 | Operating-Systems",
575 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
576 " 6300 | AIX {smd5} | Operating-Systems",
577 " 6700 | AIX {ssha1} | Operating-Systems",
578 " 6400 | AIX {ssha256} | Operating-Systems",
579 " 6500 | AIX {ssha512} | Operating-Systems",
580 " 2400 | Cisco-PIX | Operating-Systems",
581 " 2410 | Cisco-ASA | Operating-Systems",
582 " 500 | Cisco-IOS $1$ | Operating-Systems",
583 " 5700 | Cisco-IOS $4$ | Operating-Systems",
584 " 9200 | Cisco-IOS $8$ | Operating-Systems",
585 " 9300 | Cisco-IOS $9$ | Operating-Systems",
586 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
587 " 501 | Juniper IVE | Operating-Systems",
588 " 5800 | Android PIN | Operating-Systems",
589 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
590 " 8100 | Citrix Netscaler | Operating-Systems",
591 " 8500 | RACF | Operating-Systems",
592 " 7200 | GRUB 2 | Operating-Systems",
593 " 9900 | Radmin2 | Operating-Systems",
594 " 125 | ArubaOS | Operating-Systems",
595 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
596 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
597 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
598 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
599 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
600 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
601 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
602 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
603 " 11600 | 7-Zip | Archives",
604 " 12500 | RAR3-hp | Archives",
605 " 13000 | RAR5 | Archives",
606 " 13200 | AxCrypt | Archives",
607 " 13300 | AxCrypt in memory SHA1 | Archives",
608 " 13600 | WinZip | Archives",
609 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
610 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
611 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
612 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
613 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
614 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
615 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
616 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
617 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
618 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
619 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
620 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
621 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
622 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
623 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
624 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
625 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
626 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
627 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
628 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
629 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
630 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
631 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
632 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
633 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
634 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
635 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
636 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
637 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
638 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
639 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
640 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
641 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
642 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
643 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
644 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
645 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
646 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
647 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
648 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
649 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
650 " 9400 | MS Office 2007 | Documents",
651 " 9500 | MS Office 2010 | Documents",
652 " 9600 | MS Office 2013 | Documents",
653 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
654 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
655 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
656 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
657 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
658 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
659 " 9000 | Password Safe v2 | Password Managers",
660 " 5200 | Password Safe v3 | Password Managers",
661 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
662 " 6600 | 1Password, agilekeychain | Password Managers",
663 " 8200 | 1Password, cloudkeychain | Password Managers",
664 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
665 " 12700 | Blockchain, My Wallet | Password Managers",
666 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
667 "",
668 "- [ Outfile Formats ] -",
669 "",
670 " # | Format",
671 " ===+========",
672 " 1 | hash[:salt]",
673 " 2 | plain",
674 " 3 | hash[:salt]:plain",
675 " 4 | hex_plain",
676 " 5 | hash[:salt]:hex_plain",
677 " 6 | plain:hex_plain",
678 " 7 | hash[:salt]:plain:hex_plain",
679 " 8 | crackpos",
680 " 9 | hash[:salt]:crack_pos",
681 " 10 | plain:crack_pos",
682 " 11 | hash[:salt]:plain:crack_pos",
683 " 12 | hex_plain:crack_pos",
684 " 13 | hash[:salt]:hex_plain:crack_pos",
685 " 14 | plain:hex_plain:crack_pos",
686 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
687 "",
688 "- [ Rule Debugging Modes ] -",
689 "",
690 " # | Format",
691 " ===+========",
692 " 1 | Finding-Rule",
693 " 2 | Original-Word",
694 " 3 | Original-Word:Finding-Rule",
695 " 4 | Original-Word:Finding-Rule:Processed-Word",
696 "",
697 "- [ Attack Modes ] -",
698 "",
699 " # | Mode",
700 " ===+======",
701 " 0 | Straight",
702 " 1 | Combination",
703 " 3 | Brute-force",
704 " 6 | Hybrid Wordlist + Mask",
705 " 7 | Hybrid Mask + Wordlist",
706 "",
707 "- [ Built-in Charsets ] -",
708 "",
709 " ? | Charset",
710 " ===+=========",
711 " l | abcdefghijklmnopqrstuvwxyz",
712 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
713 " d | 0123456789",
714 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
715 " a | ?l?u?d?s",
716 " b | 0x00 - 0xff",
717 "",
718 "- [ OpenCL Device Types ] -",
719 "",
720 " # | Device Type",
721 " ===+=============",
722 " 1 | CPU",
723 " 2 | GPU",
724 " 3 | FPGA, DSP, Co-Processor",
725 "",
726 "- [ Workload Profiles ] -",
727 "",
728 " # | Performance | Runtime | Power Consumption | Desktop Impact",
729 " ===+=============+=========+===================+=================",
730 " 1 | Low | 2 ms | Low | Minimal",
731 " 2 | Default | 12 ms | Economic | Noticeable",
732 " 3 | High | 96 ms | High | Unresponsive",
733 " 4 | Nightmare | 480 ms | Insane | Headless",
734 "",
735 "- [ Basic Examples ] -",
736 "",
737 " Attack- | Hash- |",
738 " Mode | Type | Example command",
739 " ==================+=======+==================================================================",
740 " Wordlist | $P$ | %s -a 0 -m 400 example400.hash example.dict",
741 " Wordlist + Rules | MD5 | %s -a 0 -m 0 example0.hash example.dict -r rules/best64.rule",
742 " Brute-Force | MD5 | %s -a 3 -m 0 example0.hash ?a?a?a?a?a?a",
743 " Combinator | MD5 | %s -a 1 -m 0 example0.hash example.dict example.dict",
744 "",
745 "If you still have no idea what just happened try following pages:",
746 "",
747 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
748 "* https://hashcat.net/wiki/#frequently_asked_questions",
749 NULL
750 };
751
752 /**
753 * hashcat specific functions
754 */
755
756 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
757 {
758 int exec_pos = (int) device_param->exec_pos - last_num_entries;
759
760 if (exec_pos < 0) exec_pos += EXEC_CACHE;
761
762 double exec_ms_sum = 0;
763
764 int exec_ms_cnt = 0;
765
766 for (int i = 0; i < last_num_entries; i++)
767 {
768 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
769
770 if (exec_ms)
771 {
772 exec_ms_sum += exec_ms;
773
774 exec_ms_cnt++;
775 }
776 }
777
778 if (exec_ms_cnt == 0) return 0;
779
780 return exec_ms_sum / exec_ms_cnt;
781 }
782
783 void status_display_machine_readable ()
784 {
785 FILE *out = stdout;
786
787 fprintf (out, "STATUS\t%u\t", data.devices_status);
788
789 /**
790 * speed new
791 */
792
793 fprintf (out, "SPEED\t");
794
795 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
796 {
797 hc_device_param_t *device_param = &data.devices_param[device_id];
798
799 if (device_param->skipped) continue;
800
801 u64 speed_cnt = 0;
802 double speed_ms = 0;
803
804 for (int i = 0; i < SPEED_CACHE; i++)
805 {
806 speed_cnt += device_param->speed_cnt[i];
807 speed_ms += device_param->speed_ms[i];
808 }
809
810 speed_cnt /= SPEED_CACHE;
811 speed_ms /= SPEED_CACHE;
812
813 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
814 }
815
816 /**
817 * exec time
818 */
819
820 fprintf (out, "EXEC_RUNTIME\t");
821
822 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
823 {
824 hc_device_param_t *device_param = &data.devices_param[device_id];
825
826 if (device_param->skipped) continue;
827
828 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
829
830 fprintf (out, "%f\t", exec_ms_avg);
831 }
832
833 /**
834 * words_cur
835 */
836
837 u64 words_cur = get_lowest_words_done ();
838
839 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
840
841 /**
842 * counter
843 */
844
845 u64 progress_total = data.words_cnt * data.salts_cnt;
846
847 u64 all_done = 0;
848 u64 all_rejected = 0;
849 u64 all_restored = 0;
850
851 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
852 {
853 all_done += data.words_progress_done[salt_pos];
854 all_rejected += data.words_progress_rejected[salt_pos];
855 all_restored += data.words_progress_restored[salt_pos];
856 }
857
858 u64 progress_cur = all_restored + all_done + all_rejected;
859 u64 progress_end = progress_total;
860
861 u64 progress_skip = 0;
862
863 if (data.skip)
864 {
865 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
866
867 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
868 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
869 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
870 }
871
872 if (data.limit)
873 {
874 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
875
876 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
877 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
878 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
879 }
880
881 u64 progress_cur_relative_skip = progress_cur - progress_skip;
882 u64 progress_end_relative_skip = progress_end - progress_skip;
883
884 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
885
886 /**
887 * cracks
888 */
889
890 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
891 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
892
893 /**
894 * temperature
895 */
896
897 #ifdef HAVE_HWMON
898 if (data.gpu_temp_disable == 0)
899 {
900 fprintf (out, "TEMP\t");
901
902 hc_thread_mutex_lock (mux_adl);
903
904 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
905 {
906 hc_device_param_t *device_param = &data.devices_param[device_id];
907
908 if (device_param->skipped) continue;
909
910 int temp = hm_get_temperature_with_device_id (device_id);
911
912 fprintf (out, "%d\t", temp);
913 }
914
915 hc_thread_mutex_unlock (mux_adl);
916 }
917 #endif // HAVE_HWMON
918
919 /**
920 * flush
921 */
922
923 fputs (EOL, out);
924 fflush (out);
925 }
926
927 void status_display ()
928 {
929 if (data.devices_status == STATUS_INIT) return;
930 if (data.devices_status == STATUS_STARTING) return;
931
932 // in this case some required buffers are free'd, ascii_digest() would run into segfault
933 if (data.shutdown_inner == 1) return;
934
935 if (data.machine_readable == 1)
936 {
937 status_display_machine_readable ();
938
939 return;
940 }
941
942 char tmp_buf[1000] = { 0 };
943
944 uint tmp_len = 0;
945
946 log_info ("Session.Name...: %s", data.session);
947
948 char *status_type = strstatus (data.devices_status);
949
950 uint hash_mode = data.hash_mode;
951
952 char *hash_type = strhashtype (hash_mode); // not a bug
953
954 log_info ("Status.........: %s", status_type);
955
956 /**
957 * show rules
958 */
959
960 if (data.rp_files_cnt)
961 {
962 uint i;
963
964 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
965 {
966 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
967 }
968
969 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
970
971 log_info ("Rules.Type.....: %s", tmp_buf);
972
973 tmp_len = 0;
974 }
975
976 if (data.rp_gen)
977 {
978 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
979
980 if (data.rp_gen_seed)
981 {
982 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
983 }
984 }
985
986 /**
987 * show input
988 */
989
990 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
991 {
992 if (data.wordlist_mode == WL_MODE_FILE)
993 {
994 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
995 }
996 else if (data.wordlist_mode == WL_MODE_STDIN)
997 {
998 log_info ("Input.Mode.....: Pipe");
999 }
1000 }
1001 else if (data.attack_mode == ATTACK_MODE_COMBI)
1002 {
1003 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1004 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1005 }
1006 else if (data.attack_mode == ATTACK_MODE_BF)
1007 {
1008 char *mask = data.mask;
1009
1010 if (mask != NULL)
1011 {
1012 uint mask_len = data.css_cnt;
1013
1014 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1015
1016 if (mask_len > 0)
1017 {
1018 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1019 {
1020 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1021 {
1022 mask_len -= data.salts_buf[0].salt_len;
1023 }
1024 }
1025
1026 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1027
1028 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1029 }
1030
1031 if (data.maskcnt > 1)
1032 {
1033 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1034
1035 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1036 }
1037
1038 log_info ("Input.Mode.....: %s", tmp_buf);
1039 }
1040
1041 tmp_len = 0;
1042 }
1043 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1044 {
1045 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1046 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1047 }
1048 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1049 {
1050 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1051 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1052 }
1053
1054 if (data.digests_cnt == 1)
1055 {
1056 if (data.hash_mode == 2500)
1057 {
1058 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1059
1060 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1061 (char *) data.salts_buf[0].salt_buf,
1062 wpa->orig_mac1[0],
1063 wpa->orig_mac1[1],
1064 wpa->orig_mac1[2],
1065 wpa->orig_mac1[3],
1066 wpa->orig_mac1[4],
1067 wpa->orig_mac1[5],
1068 wpa->orig_mac2[0],
1069 wpa->orig_mac2[1],
1070 wpa->orig_mac2[2],
1071 wpa->orig_mac2[3],
1072 wpa->orig_mac2[4],
1073 wpa->orig_mac2[5]);
1074 }
1075 else if (data.hash_mode == 5200)
1076 {
1077 log_info ("Hash.Target....: File (%s)", data.hashfile);
1078 }
1079 else if (data.hash_mode == 9000)
1080 {
1081 log_info ("Hash.Target....: File (%s)", data.hashfile);
1082 }
1083 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1084 {
1085 log_info ("Hash.Target....: File (%s)", data.hashfile);
1086 }
1087 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1088 {
1089 log_info ("Hash.Target....: File (%s)", data.hashfile);
1090 }
1091 else
1092 {
1093 char out_buf[HCBUFSIZ] = { 0 };
1094
1095 ascii_digest (out_buf, 0, 0);
1096
1097 // limit length
1098 if (strlen (out_buf) > 40)
1099 {
1100 out_buf[41] = '.';
1101 out_buf[42] = '.';
1102 out_buf[43] = '.';
1103 out_buf[44] = 0;
1104 }
1105
1106 log_info ("Hash.Target....: %s", out_buf);
1107 }
1108 }
1109 else
1110 {
1111 if (data.hash_mode == 3000)
1112 {
1113 char out_buf1[32] = { 0 };
1114 char out_buf2[32] = { 0 };
1115
1116 ascii_digest (out_buf1, 0, 0);
1117 ascii_digest (out_buf2, 0, 1);
1118
1119 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1120 }
1121 else
1122 {
1123 log_info ("Hash.Target....: File (%s)", data.hashfile);
1124 }
1125 }
1126
1127 log_info ("Hash.Type......: %s", hash_type);
1128
1129 /**
1130 * speed new
1131 */
1132
1133 u64 speed_cnt[DEVICES_MAX] = { 0 };
1134 double speed_ms[DEVICES_MAX] = { 0 };
1135
1136 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1137 {
1138 hc_device_param_t *device_param = &data.devices_param[device_id];
1139
1140 if (device_param->skipped) continue;
1141
1142 speed_cnt[device_id] = 0;
1143 speed_ms[device_id] = 0;
1144
1145 for (int i = 0; i < SPEED_CACHE; i++)
1146 {
1147 speed_cnt[device_id] += device_param->speed_cnt[i];
1148 speed_ms[device_id] += device_param->speed_ms[i];
1149 }
1150
1151 speed_cnt[device_id] /= SPEED_CACHE;
1152 speed_ms[device_id] /= SPEED_CACHE;
1153 }
1154
1155 double hashes_all_ms = 0;
1156
1157 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1158
1159 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1160 {
1161 hc_device_param_t *device_param = &data.devices_param[device_id];
1162
1163 if (device_param->skipped) continue;
1164
1165 hashes_dev_ms[device_id] = 0;
1166
1167 if (speed_ms[device_id])
1168 {
1169 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1170
1171 hashes_all_ms += hashes_dev_ms[device_id];
1172 }
1173 }
1174
1175 /**
1176 * exec time
1177 */
1178
1179 double exec_all_ms[DEVICES_MAX] = { 0 };
1180
1181 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1182 {
1183 hc_device_param_t *device_param = &data.devices_param[device_id];
1184
1185 if (device_param->skipped) continue;
1186
1187 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1188
1189 exec_all_ms[device_id] = exec_ms_avg;
1190 }
1191
1192 /**
1193 * timers
1194 */
1195
1196 double ms_running = 0;
1197
1198 hc_timer_get (data.timer_running, ms_running);
1199
1200 double ms_paused = data.ms_paused;
1201
1202 if (data.devices_status == STATUS_PAUSED)
1203 {
1204 double ms_paused_tmp = 0;
1205
1206 hc_timer_get (data.timer_paused, ms_paused_tmp);
1207
1208 ms_paused += ms_paused_tmp;
1209 }
1210
1211 #ifdef WIN
1212
1213 __time64_t sec_run = ms_running / 1000;
1214
1215 #else
1216
1217 time_t sec_run = ms_running / 1000;
1218
1219 #endif
1220
1221 if (sec_run)
1222 {
1223 char display_run[32] = { 0 };
1224
1225 struct tm tm_run;
1226
1227 struct tm *tmp = NULL;
1228
1229 #ifdef WIN
1230
1231 tmp = _gmtime64 (&sec_run);
1232
1233 #else
1234
1235 tmp = gmtime (&sec_run);
1236
1237 #endif
1238
1239 if (tmp != NULL)
1240 {
1241 memset (&tm_run, 0, sizeof (tm_run));
1242
1243 memcpy (&tm_run, tmp, sizeof (tm_run));
1244
1245 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1246
1247 char *start = ctime (&data.proc_start);
1248
1249 size_t start_len = strlen (start);
1250
1251 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1252 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1253
1254 log_info ("Time.Started...: %s (%s)", start, display_run);
1255 }
1256 }
1257 else
1258 {
1259 log_info ("Time.Started...: 0 secs");
1260 }
1261
1262 /**
1263 * counters
1264 */
1265
1266 u64 progress_total = data.words_cnt * data.salts_cnt;
1267
1268 u64 all_done = 0;
1269 u64 all_rejected = 0;
1270 u64 all_restored = 0;
1271
1272 u64 progress_noneed = 0;
1273
1274 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1275 {
1276 all_done += data.words_progress_done[salt_pos];
1277 all_rejected += data.words_progress_rejected[salt_pos];
1278 all_restored += data.words_progress_restored[salt_pos];
1279
1280 // Important for ETA only
1281
1282 if (data.salts_shown[salt_pos] == 1)
1283 {
1284 const u64 all = data.words_progress_done[salt_pos]
1285 + data.words_progress_rejected[salt_pos]
1286 + data.words_progress_restored[salt_pos];
1287
1288 const u64 left = data.words_cnt - all;
1289
1290 progress_noneed += left;
1291 }
1292 }
1293
1294 u64 progress_cur = all_restored + all_done + all_rejected;
1295 u64 progress_end = progress_total;
1296
1297 u64 progress_skip = 0;
1298
1299 if (data.skip)
1300 {
1301 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1302
1303 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1304 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1305 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1306 }
1307
1308 if (data.limit)
1309 {
1310 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1311
1312 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1313 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1314 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1315 }
1316
1317 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1318 u64 progress_end_relative_skip = progress_end - progress_skip;
1319
1320 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1321 {
1322 if (data.devices_status != STATUS_CRACKED)
1323 {
1324 #ifdef WIN
1325 __time64_t sec_etc = 0;
1326 #else
1327 time_t sec_etc = 0;
1328 #endif
1329
1330 if (hashes_all_ms)
1331 {
1332 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1333
1334 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1335
1336 sec_etc = ms_left / 1000;
1337 }
1338
1339 if (sec_etc == 0)
1340 {
1341 //log_info ("Time.Estimated.: 0 secs");
1342 }
1343 else if ((u64) sec_etc > ETC_MAX)
1344 {
1345 log_info ("Time.Estimated.: > 10 Years");
1346 }
1347 else
1348 {
1349 char display_etc[32] = { 0 };
1350 char display_runtime[32] = { 0 };
1351
1352 struct tm tm_etc;
1353 struct tm tm_runtime;
1354
1355 struct tm *tmp = NULL;
1356
1357 #ifdef WIN
1358 tmp = _gmtime64 (&sec_etc);
1359 #else
1360 tmp = gmtime (&sec_etc);
1361 #endif
1362
1363 if (tmp != NULL)
1364 {
1365 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1366
1367 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1368
1369 time_t now;
1370
1371 time (&now);
1372
1373 now += sec_etc;
1374
1375 char *etc = ctime (&now);
1376
1377 size_t etc_len = strlen (etc);
1378
1379 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1380 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1381
1382 if (data.runtime)
1383 {
1384 time_t runtime_cur;
1385
1386 time (&runtime_cur);
1387
1388 #ifdef WIN
1389
1390 __time64_t runtime_left = data.proc_start + data.runtime - runtime_cur;
1391
1392 tmp = _gmtime64 (&runtime_left);
1393
1394 #else
1395
1396 time_t runtime_left = data.proc_start + data.runtime - runtime_cur;
1397
1398 tmp = gmtime (&runtime_left);
1399
1400 #endif
1401
1402 if ((tmp != NULL) && (runtime_left > 0) && (runtime_left < sec_etc))
1403 {
1404 memcpy (&tm_runtime, tmp, sizeof (tm_runtime));
1405
1406 format_timer_display (&tm_runtime, display_runtime, sizeof (display_runtime));
1407
1408 log_info ("Time.Estimated.: %s (%s), but limited (%s)", etc, display_etc, display_runtime);
1409 }
1410 else
1411 {
1412 log_info ("Time.Estimated.: %s (%s), but limit exceeded", etc, display_etc);
1413 }
1414 }
1415 else
1416 {
1417 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1418 }
1419 }
1420 }
1421 }
1422 }
1423
1424 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1425 {
1426 hc_device_param_t *device_param = &data.devices_param[device_id];
1427
1428 if (device_param->skipped) continue;
1429
1430 char display_dev_cur[16] = { 0 };
1431
1432 strncpy (display_dev_cur, "0.00", 4);
1433
1434 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1435
1436 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1437 }
1438
1439 char display_all_cur[16] = { 0 };
1440
1441 strncpy (display_all_cur, "0.00", 4);
1442
1443 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1444
1445 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1446
1447 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1448 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1449
1450 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);
1451
1452 // crack-per-time
1453
1454 if (data.digests_cnt > 100)
1455 {
1456 time_t now = time (NULL);
1457
1458 int cpt_cur_min = 0;
1459 int cpt_cur_hour = 0;
1460 int cpt_cur_day = 0;
1461
1462 for (int i = 0; i < CPT_BUF; i++)
1463 {
1464 const uint cracked = data.cpt_buf[i].cracked;
1465 const time_t timestamp = data.cpt_buf[i].timestamp;
1466
1467 if ((timestamp + 60) > now)
1468 {
1469 cpt_cur_min += cracked;
1470 }
1471
1472 if ((timestamp + 3600) > now)
1473 {
1474 cpt_cur_hour += cracked;
1475 }
1476
1477 if ((timestamp + 86400) > now)
1478 {
1479 cpt_cur_day += cracked;
1480 }
1481 }
1482
1483 double ms_real = ms_running - ms_paused;
1484
1485 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1486 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1487 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1488
1489 if ((data.cpt_start + 86400) < now)
1490 {
1491 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1492 cpt_cur_min,
1493 cpt_cur_hour,
1494 cpt_cur_day,
1495 cpt_avg_min,
1496 cpt_avg_hour,
1497 cpt_avg_day);
1498 }
1499 else if ((data.cpt_start + 3600) < now)
1500 {
1501 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1502 cpt_cur_min,
1503 cpt_cur_hour,
1504 cpt_avg_min,
1505 cpt_avg_hour,
1506 cpt_avg_day);
1507 }
1508 else if ((data.cpt_start + 60) < now)
1509 {
1510 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1511 cpt_cur_min,
1512 cpt_avg_min,
1513 cpt_avg_hour,
1514 cpt_avg_day);
1515 }
1516 else
1517 {
1518 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1519 cpt_avg_min,
1520 cpt_avg_hour,
1521 cpt_avg_day);
1522 }
1523 }
1524
1525 // Restore point
1526
1527 u64 restore_point = get_lowest_words_done ();
1528
1529 u64 restore_total = data.words_base;
1530
1531 float percent_restore = 0;
1532
1533 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1534
1535 if (progress_end_relative_skip)
1536 {
1537 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1538 {
1539 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1540 float percent_rejected = 0.0;
1541
1542 if (progress_cur)
1543 {
1544 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1545 }
1546
1547 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);
1548 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1549
1550 if (data.restore_disable == 0)
1551 {
1552 if (percent_finished != 1)
1553 {
1554 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1555 }
1556 }
1557 }
1558 }
1559 else
1560 {
1561 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1562 {
1563 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1564 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1565
1566 if (data.restore_disable == 0)
1567 {
1568 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1569 }
1570 }
1571 else
1572 {
1573 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1574 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1575
1576 // --restore not allowed if stdin is used -- really? why?
1577
1578 //if (data.restore_disable == 0)
1579 //{
1580 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1581 //}
1582 }
1583 }
1584
1585 #ifdef HAVE_HWMON
1586
1587 if (data.devices_status == STATUS_EXHAUSTED) return;
1588 if (data.devices_status == STATUS_CRACKED) return;
1589 if (data.devices_status == STATUS_ABORTED) return;
1590 if (data.devices_status == STATUS_QUIT) return;
1591
1592 if (data.gpu_temp_disable == 0)
1593 {
1594 hc_thread_mutex_lock (mux_adl);
1595
1596 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1597 {
1598 hc_device_param_t *device_param = &data.devices_param[device_id];
1599
1600 if (device_param->skipped) continue;
1601
1602 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1603 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1604 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1605 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1606 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1607 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1608 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1609
1610 char output_buf[256] = { 0 };
1611
1612 int output_len = 0;
1613
1614 if (num_temperature >= 0)
1615 {
1616 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1617
1618 output_len = strlen (output_buf);
1619 }
1620
1621 if (num_fanspeed >= 0)
1622 {
1623 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1624
1625 output_len = strlen (output_buf);
1626 }
1627
1628 if (num_utilization >= 0)
1629 {
1630 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1631
1632 output_len = strlen (output_buf);
1633 }
1634
1635 if (num_corespeed >= 0)
1636 {
1637 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1638
1639 output_len = strlen (output_buf);
1640 }
1641
1642 if (num_memoryspeed >= 0)
1643 {
1644 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1645
1646 output_len = strlen (output_buf);
1647 }
1648
1649 if (num_buslanes >= 0)
1650 {
1651 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1652
1653 output_len = strlen (output_buf);
1654 }
1655
1656 if (num_throttle == 1)
1657 {
1658 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1659
1660 output_len = strlen (output_buf);
1661 }
1662
1663 if (output_len == 0)
1664 {
1665 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1666
1667 output_len = strlen (output_buf);
1668 }
1669
1670 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1671 }
1672
1673 hc_thread_mutex_unlock (mux_adl);
1674 }
1675
1676 #endif // HAVE_HWMON
1677 }
1678
1679 static void status_benchmark_automate ()
1680 {
1681 u64 speed_cnt[DEVICES_MAX] = { 0 };
1682 double speed_ms[DEVICES_MAX] = { 0 };
1683
1684 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1685 {
1686 hc_device_param_t *device_param = &data.devices_param[device_id];
1687
1688 if (device_param->skipped) continue;
1689
1690 speed_cnt[device_id] = device_param->speed_cnt[0];
1691 speed_ms[device_id] = device_param->speed_ms[0];
1692 }
1693
1694 double hashes_dev_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 hashes_dev_ms[device_id] = 0;
1703
1704 if (speed_ms[device_id])
1705 {
1706 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1707 }
1708 }
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 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1717 }
1718 }
1719
1720 static void status_benchmark ()
1721 {
1722 if (data.devices_status == STATUS_INIT) return;
1723 if (data.devices_status == STATUS_STARTING) return;
1724
1725 if (data.shutdown_inner == 1) return;
1726
1727 if (data.machine_readable == 1)
1728 {
1729 status_benchmark_automate ();
1730
1731 return;
1732 }
1733
1734 u64 speed_cnt[DEVICES_MAX] = { 0 };
1735 double speed_ms[DEVICES_MAX] = { 0 };
1736
1737 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1738 {
1739 hc_device_param_t *device_param = &data.devices_param[device_id];
1740
1741 if (device_param->skipped) continue;
1742
1743 speed_cnt[device_id] = device_param->speed_cnt[0];
1744 speed_ms[device_id] = device_param->speed_ms[0];
1745 }
1746
1747 double hashes_all_ms = 0;
1748
1749 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1750
1751 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1752 {
1753 hc_device_param_t *device_param = &data.devices_param[device_id];
1754
1755 if (device_param->skipped) continue;
1756
1757 hashes_dev_ms[device_id] = 0;
1758
1759 if (speed_ms[device_id])
1760 {
1761 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1762
1763 hashes_all_ms += hashes_dev_ms[device_id];
1764 }
1765 }
1766
1767 /**
1768 * exec time
1769 */
1770
1771 double exec_all_ms[DEVICES_MAX] = { 0 };
1772
1773 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1774 {
1775 hc_device_param_t *device_param = &data.devices_param[device_id];
1776
1777 if (device_param->skipped) continue;
1778
1779 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1780
1781 exec_all_ms[device_id] = exec_ms_avg;
1782 }
1783
1784 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1785 {
1786 hc_device_param_t *device_param = &data.devices_param[device_id];
1787
1788 if (device_param->skipped) continue;
1789
1790 char display_dev_cur[16] = { 0 };
1791
1792 strncpy (display_dev_cur, "0.00", 4);
1793
1794 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1795
1796 if (data.devices_active >= 10)
1797 {
1798 log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1799 }
1800 else
1801 {
1802 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1803 }
1804 }
1805
1806 char display_all_cur[16] = { 0 };
1807
1808 strncpy (display_all_cur, "0.00", 4);
1809
1810 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1811
1812 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1813 }
1814
1815 /**
1816 * hashcat -only- functions
1817 */
1818
1819 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1820 {
1821 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1822 {
1823 if (attack_kern == ATTACK_KERN_STRAIGHT)
1824 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1825 else if (attack_kern == ATTACK_KERN_COMBI)
1826 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1827 else if (attack_kern == ATTACK_KERN_BF)
1828 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1829 }
1830 else
1831 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1832 }
1833
1834 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)
1835 {
1836 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1837 {
1838 if (attack_kern == ATTACK_KERN_STRAIGHT)
1839 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1840 else if (attack_kern == ATTACK_KERN_COMBI)
1841 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1842 else if (attack_kern == ATTACK_KERN_BF)
1843 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1844 }
1845 else
1846 {
1847 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1848 }
1849 }
1850
1851 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1852 {
1853 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1854 {
1855 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1856 }
1857 else
1858 {
1859 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1860 }
1861 }
1862
1863 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)
1864 {
1865 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1866 {
1867 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1868 }
1869 else
1870 {
1871 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1872 }
1873 }
1874
1875 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1876 {
1877 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1878 }
1879
1880 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1881 {
1882 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1883 }
1884
1885 static char *filename_from_filepath (char *filepath)
1886 {
1887 char *ptr = NULL;
1888
1889 if ((ptr = strrchr (filepath, '/')) != NULL)
1890 {
1891 ptr++;
1892 }
1893 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1894 {
1895 ptr++;
1896 }
1897 else
1898 {
1899 ptr = filepath;
1900 }
1901
1902 return ptr;
1903 }
1904
1905 static uint convert_from_hex (char *line_buf, const uint line_len)
1906 {
1907 if (line_len & 1) return (line_len); // not in hex
1908
1909 if (data.hex_wordlist == 1)
1910 {
1911 uint i;
1912 uint j;
1913
1914 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1915 {
1916 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1917 }
1918
1919 memset (line_buf + i, 0, line_len - i);
1920
1921 return (i);
1922 }
1923 else if (line_len >= 6) // $HEX[] = 6
1924 {
1925 if (line_buf[0] != '$') return (line_len);
1926 if (line_buf[1] != 'H') return (line_len);
1927 if (line_buf[2] != 'E') return (line_len);
1928 if (line_buf[3] != 'X') return (line_len);
1929 if (line_buf[4] != '[') return (line_len);
1930 if (line_buf[line_len - 1] != ']') return (line_len);
1931
1932 uint i;
1933 uint j;
1934
1935 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1936 {
1937 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1938 }
1939
1940 memset (line_buf + i, 0, line_len - i);
1941
1942 return (i);
1943 }
1944
1945 return (line_len);
1946 }
1947
1948 static void clear_prompt ()
1949 {
1950 fputc ('\r', stdout);
1951
1952 for (size_t i = 0; i < strlen (PROMPT); i++)
1953 {
1954 fputc (' ', stdout);
1955 }
1956
1957 fputc ('\r', stdout);
1958
1959 fflush (stdout);
1960 }
1961
1962 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1963 {
1964 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);
1965 }
1966
1967 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1968 {
1969 char *outfile = data.outfile;
1970 uint quiet = data.quiet;
1971 FILE *pot_fp = data.pot_fp;
1972 uint loopback = data.loopback;
1973 uint debug_mode = data.debug_mode;
1974 char *debug_file = data.debug_file;
1975
1976 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1977 int debug_rule_len = 0; // -1 error
1978 uint debug_plain_len = 0;
1979
1980 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1981
1982 // hash
1983
1984 char out_buf[HCBUFSIZ] = { 0 };
1985
1986 const u32 salt_pos = plain->salt_pos;
1987 const u32 digest_pos = plain->digest_pos; // relative
1988 const u32 gidvid = plain->gidvid;
1989 const u32 il_pos = plain->il_pos;
1990
1991 ascii_digest (out_buf, salt_pos, digest_pos);
1992
1993 // plain
1994
1995 u64 crackpos = device_param->words_off;
1996
1997 uint plain_buf[16] = { 0 };
1998
1999 u8 *plain_ptr = (u8 *) plain_buf;
2000
2001 unsigned int plain_len = 0;
2002
2003 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2004 {
2005 pw_t pw;
2006
2007 gidd_to_pw_t (device_param, gidvid, &pw);
2008
2009 for (int i = 0; i < 16; i++)
2010 {
2011 plain_buf[i] = pw.i[i];
2012 }
2013
2014 plain_len = pw.pw_len;
2015
2016 const uint off = device_param->innerloop_pos + il_pos;
2017
2018 if (debug_mode > 0)
2019 {
2020 debug_rule_len = 0;
2021
2022 // save rule
2023 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
2024 {
2025 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
2026
2027 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
2028 }
2029
2030 // save plain
2031 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
2032 {
2033 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
2034
2035 memcpy (debug_plain_ptr, plain_ptr, plain_len);
2036
2037 debug_plain_len = plain_len;
2038 }
2039 }
2040
2041 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2042
2043 crackpos += gidvid;
2044 crackpos *= data.kernel_rules_cnt;
2045 crackpos += device_param->innerloop_pos + il_pos;
2046
2047 if (plain_len > data.pw_max) plain_len = data.pw_max;
2048 }
2049 else if (data.attack_mode == ATTACK_MODE_COMBI)
2050 {
2051 pw_t pw;
2052
2053 gidd_to_pw_t (device_param, gidvid, &pw);
2054
2055 for (int i = 0; i < 16; i++)
2056 {
2057 plain_buf[i] = pw.i[i];
2058 }
2059
2060 plain_len = pw.pw_len;
2061
2062 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2063 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2064
2065 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2066 {
2067 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2068 }
2069 else
2070 {
2071 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2072
2073 memcpy (plain_ptr, comb_buf, comb_len);
2074 }
2075
2076 plain_len += comb_len;
2077
2078 crackpos += gidvid;
2079 crackpos *= data.combs_cnt;
2080 crackpos += device_param->innerloop_pos + il_pos;
2081
2082 if (data.pw_max != PW_DICTMAX1)
2083 {
2084 if (plain_len > data.pw_max) plain_len = data.pw_max;
2085 }
2086 }
2087 else if (data.attack_mode == ATTACK_MODE_BF)
2088 {
2089 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2090 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2091
2092 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2093 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2094
2095 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2096 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2097
2098 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2099 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2100
2101 plain_len = data.css_cnt;
2102
2103 crackpos += gidvid;
2104 crackpos *= data.bfs_cnt;
2105 crackpos += device_param->innerloop_pos + il_pos;
2106 }
2107 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2108 {
2109 pw_t pw;
2110
2111 gidd_to_pw_t (device_param, gidvid, &pw);
2112
2113 for (int i = 0; i < 16; i++)
2114 {
2115 plain_buf[i] = pw.i[i];
2116 }
2117
2118 plain_len = pw.pw_len;
2119
2120 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2121
2122 uint start = 0;
2123 uint stop = device_param->kernel_params_mp_buf32[4];
2124
2125 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2126
2127 plain_len += start + stop;
2128
2129 crackpos += gidvid;
2130 crackpos *= data.combs_cnt;
2131 crackpos += device_param->innerloop_pos + il_pos;
2132
2133 if (data.pw_max != PW_DICTMAX1)
2134 {
2135 if (plain_len > data.pw_max) plain_len = data.pw_max;
2136 }
2137 }
2138 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2139 {
2140 pw_t pw;
2141
2142 gidd_to_pw_t (device_param, gidvid, &pw);
2143
2144 for (int i = 0; i < 16; i++)
2145 {
2146 plain_buf[i] = pw.i[i];
2147 }
2148
2149 plain_len = pw.pw_len;
2150
2151 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2152
2153 uint start = 0;
2154 uint stop = device_param->kernel_params_mp_buf32[4];
2155
2156 memmove (plain_ptr + stop, plain_ptr, plain_len);
2157
2158 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2159
2160 plain_len += start + stop;
2161
2162 crackpos += gidvid;
2163 crackpos *= data.combs_cnt;
2164 crackpos += device_param->innerloop_pos + il_pos;
2165
2166 if (data.pw_max != PW_DICTMAX1)
2167 {
2168 if (plain_len > data.pw_max) plain_len = data.pw_max;
2169 }
2170 }
2171
2172 if (data.attack_mode == ATTACK_MODE_BF)
2173 {
2174 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2175 {
2176 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2177 {
2178 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2179 {
2180 plain_len = plain_len - data.salts_buf[0].salt_len;
2181 }
2182 }
2183
2184 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2185 {
2186 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2187 {
2188 plain_ptr[j] = plain_ptr[i];
2189 }
2190
2191 plain_len = plain_len / 2;
2192 }
2193 }
2194 }
2195
2196 // if enabled, update also the potfile
2197
2198 if (pot_fp)
2199 {
2200 lock_file (pot_fp);
2201
2202 fprintf (pot_fp, "%s:", out_buf);
2203
2204 format_plain (pot_fp, plain_ptr, plain_len, 1);
2205
2206 fputc ('\n', pot_fp);
2207
2208 fflush (pot_fp);
2209
2210 unlock_file (pot_fp);
2211 }
2212
2213 // outfile
2214
2215 FILE *out_fp = NULL;
2216
2217 if (outfile != NULL)
2218 {
2219 if ((out_fp = fopen (outfile, "ab")) == NULL)
2220 {
2221 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2222
2223 out_fp = stdout;
2224 }
2225
2226 lock_file (out_fp);
2227 }
2228 else
2229 {
2230 out_fp = stdout;
2231
2232 if (quiet == 0) clear_prompt ();
2233 }
2234
2235 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2236
2237 if (outfile != NULL)
2238 {
2239 if (out_fp != stdout)
2240 {
2241 fclose (out_fp);
2242 }
2243 }
2244 else
2245 {
2246 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2247 {
2248 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2249 {
2250 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2251 if (quiet == 0) fflush (stdout);
2252 }
2253 }
2254 }
2255
2256 // loopback
2257
2258 if (loopback)
2259 {
2260 char *loopback_file = data.loopback_file;
2261
2262 FILE *fb_fp = NULL;
2263
2264 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2265 {
2266 lock_file (fb_fp);
2267
2268 format_plain (fb_fp, plain_ptr, plain_len, 1);
2269
2270 fputc ('\n', fb_fp);
2271
2272 fclose (fb_fp);
2273 }
2274 }
2275
2276 // (rule) debug mode
2277
2278 // the next check implies that:
2279 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2280 // - debug_mode > 0
2281
2282 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2283 {
2284 if (debug_rule_len < 0) debug_rule_len = 0;
2285
2286 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2287
2288 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2289
2290 if ((quiet == 0) && (debug_file == NULL))
2291 {
2292 fprintf (stdout, "%s", PROMPT);
2293
2294 fflush (stdout);
2295 }
2296 }
2297 }
2298
2299 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2300 {
2301 salt_t *salt_buf = &data.salts_buf[salt_pos];
2302
2303 u32 num_cracked;
2304
2305 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2306
2307 if (num_cracked)
2308 {
2309 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2310
2311 log_info_nn ("");
2312
2313 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2314
2315 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);
2316
2317 uint cpt_cracked = 0;
2318
2319 hc_thread_mutex_lock (mux_display);
2320
2321 for (uint i = 0; i < num_cracked; i++)
2322 {
2323 const uint hash_pos = cracked[i].hash_pos;
2324
2325 if (data.digests_shown[hash_pos] == 1) continue;
2326
2327 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2328 {
2329 data.digests_shown[hash_pos] = 1;
2330
2331 data.digests_done++;
2332
2333 cpt_cracked++;
2334
2335 salt_buf->digests_done++;
2336
2337 if (salt_buf->digests_done == salt_buf->digests_cnt)
2338 {
2339 data.salts_shown[salt_pos] = 1;
2340
2341 data.salts_done++;
2342 }
2343 }
2344
2345 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2346
2347 check_hash (device_param, &cracked[i]);
2348 }
2349
2350 hc_thread_mutex_unlock (mux_display);
2351
2352 myfree (cracked);
2353
2354 if (cpt_cracked > 0)
2355 {
2356 hc_thread_mutex_lock (mux_display);
2357
2358 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2359 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2360
2361 data.cpt_pos++;
2362
2363 data.cpt_total += cpt_cracked;
2364
2365 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2366
2367 hc_thread_mutex_unlock (mux_display);
2368 }
2369
2370 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2371 {
2372 // we need to reset cracked state on the device
2373 // otherwise host thinks again and again the hash was cracked
2374 // and returns invalid password each time
2375
2376 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2377
2378 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);
2379 }
2380
2381 num_cracked = 0;
2382
2383 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2384 }
2385 }
2386
2387 // stolen from princeprocessor ;)
2388
2389 typedef struct
2390 {
2391 FILE *fp;
2392
2393 char buf[BUFSIZ];
2394 int len;
2395
2396 } out_t;
2397
2398 static void out_flush (out_t *out)
2399 {
2400 fwrite (out->buf, 1, out->len, out->fp);
2401
2402 out->len = 0;
2403 }
2404
2405 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2406 {
2407 char *ptr = out->buf + out->len;
2408
2409 memcpy (ptr, pw_buf, pw_len);
2410
2411 ptr[pw_len] = '\n';
2412
2413 out->len += pw_len + 1;
2414
2415 if (out->len >= BUFSIZ - 100)
2416 {
2417 out_flush (out);
2418 }
2419 }
2420
2421 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2422 {
2423 out_t out;
2424
2425 out.fp = stdout;
2426 out.len = 0;
2427
2428 uint plain_buf[16] = { 0 };
2429
2430 u8 *plain_ptr = (u8 *) plain_buf;
2431
2432 uint plain_len = 0;
2433
2434 const uint il_cnt = device_param->kernel_params_buf32[30]; // ugly, i know
2435
2436 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2437 {
2438 pw_t pw;
2439
2440 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2441 {
2442 gidd_to_pw_t (device_param, gidvid, &pw);
2443
2444 const uint pos = device_param->innerloop_pos;
2445
2446 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2447 {
2448 for (int i = 0; i < 8; i++)
2449 {
2450 plain_buf[i] = pw.i[i];
2451 }
2452
2453 plain_len = pw.pw_len;
2454
2455 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2456
2457 if (plain_len > data.pw_max) plain_len = data.pw_max;
2458
2459 out_push (&out, plain_ptr, plain_len);
2460 }
2461 }
2462 }
2463 else if (data.attack_mode == ATTACK_MODE_COMBI)
2464 {
2465 pw_t pw;
2466
2467 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2468 {
2469 gidd_to_pw_t (device_param, gidvid, &pw);
2470
2471 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2472 {
2473 for (int i = 0; i < 8; i++)
2474 {
2475 plain_buf[i] = pw.i[i];
2476 }
2477
2478 plain_len = pw.pw_len;
2479
2480 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2481 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2482
2483 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2484 {
2485 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2486 }
2487 else
2488 {
2489 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2490
2491 memcpy (plain_ptr, comb_buf, comb_len);
2492 }
2493
2494 plain_len += comb_len;
2495
2496 if (data.pw_max != PW_DICTMAX1)
2497 {
2498 if (plain_len > data.pw_max) plain_len = data.pw_max;
2499 }
2500
2501 out_push (&out, plain_ptr, plain_len);
2502 }
2503 }
2504 }
2505 else if (data.attack_mode == ATTACK_MODE_BF)
2506 {
2507 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2508 {
2509 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2510 {
2511 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2512 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2513
2514 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2515 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2516
2517 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2518 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2519
2520 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2521 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2522
2523 plain_len = data.css_cnt;
2524
2525 out_push (&out, plain_ptr, plain_len);
2526 }
2527 }
2528 }
2529 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2530 {
2531 pw_t pw;
2532
2533 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2534 {
2535 gidd_to_pw_t (device_param, gidvid, &pw);
2536
2537 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2538 {
2539 for (int i = 0; i < 8; i++)
2540 {
2541 plain_buf[i] = pw.i[i];
2542 }
2543
2544 plain_len = pw.pw_len;
2545
2546 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2547
2548 uint start = 0;
2549 uint stop = device_param->kernel_params_mp_buf32[4];
2550
2551 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2552
2553 plain_len += start + stop;
2554
2555 out_push (&out, plain_ptr, plain_len);
2556 }
2557 }
2558 }
2559 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2560 {
2561 pw_t pw;
2562
2563 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2564 {
2565 gidd_to_pw_t (device_param, gidvid, &pw);
2566
2567 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2568 {
2569 for (int i = 0; i < 8; i++)
2570 {
2571 plain_buf[i] = pw.i[i];
2572 }
2573
2574 plain_len = pw.pw_len;
2575
2576 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2577
2578 uint start = 0;
2579 uint stop = device_param->kernel_params_mp_buf32[4];
2580
2581 memmove (plain_ptr + stop, plain_ptr, plain_len);
2582
2583 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2584
2585 plain_len += start + stop;
2586
2587 out_push (&out, plain_ptr, plain_len);
2588 }
2589 }
2590 }
2591
2592 out_flush (&out);
2593 }
2594
2595 static void save_hash ()
2596 {
2597 char *hashfile = data.hashfile;
2598
2599 char new_hashfile[256] = { 0 };
2600 char old_hashfile[256] = { 0 };
2601
2602 snprintf (new_hashfile, 255, "%s.new", hashfile);
2603 snprintf (old_hashfile, 255, "%s.old", hashfile);
2604
2605 unlink (new_hashfile);
2606
2607 char separator = data.separator;
2608
2609 FILE *fp = fopen (new_hashfile, "wb");
2610
2611 if (fp == NULL)
2612 {
2613 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2614
2615 exit (-1);
2616 }
2617
2618 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2619 {
2620 if (data.salts_shown[salt_pos] == 1) continue;
2621
2622 salt_t *salt_buf = &data.salts_buf[salt_pos];
2623
2624 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2625 {
2626 uint idx = salt_buf->digests_offset + digest_pos;
2627
2628 if (data.digests_shown[idx] == 1) continue;
2629
2630 if (data.hash_mode != 2500)
2631 {
2632 if (data.username == 1)
2633 {
2634 user_t *user = data.hash_info[idx]->user;
2635
2636 uint i;
2637
2638 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2639
2640 fputc (separator, fp);
2641 }
2642
2643 char out_buf[HCBUFSIZ]; // scratch buffer
2644
2645 out_buf[0] = 0;
2646
2647 ascii_digest (out_buf, salt_pos, digest_pos);
2648
2649 fputs (out_buf, fp);
2650
2651 fputc ('\n', fp);
2652 }
2653 else
2654 {
2655 hccap_t hccap;
2656
2657 to_hccap_t (&hccap, salt_pos, digest_pos);
2658
2659 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2660 }
2661 }
2662 }
2663
2664 fflush (fp);
2665
2666 fclose (fp);
2667
2668 unlink (old_hashfile);
2669
2670 if (rename (hashfile, old_hashfile) != 0)
2671 {
2672 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2673
2674 exit (-1);
2675 }
2676
2677 unlink (hashfile);
2678
2679 if (rename (new_hashfile, hashfile) != 0)
2680 {
2681 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2682
2683 exit (-1);
2684 }
2685
2686 unlink (old_hashfile);
2687 }
2688
2689 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2690 {
2691 uint num_elements = num;
2692
2693 device_param->kernel_params_buf32[33] = data.combs_mode;
2694 device_param->kernel_params_buf32[34] = num;
2695
2696 uint kernel_threads = device_param->kernel_threads;
2697
2698 while (num_elements % kernel_threads) num_elements++;
2699
2700 cl_kernel kernel = NULL;
2701
2702 switch (kern_run)
2703 {
2704 case KERN_RUN_1: kernel = device_param->kernel1; break;
2705 case KERN_RUN_12: kernel = device_param->kernel12; break;
2706 case KERN_RUN_2: kernel = device_param->kernel2; break;
2707 case KERN_RUN_23: kernel = device_param->kernel23; break;
2708 case KERN_RUN_3: kernel = device_param->kernel3; break;
2709 }
2710
2711 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2712 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2713 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2714 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2715 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2716 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2717 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2718 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2719 hc_clSetKernelArg (data.ocl, kernel, 32, sizeof (cl_uint), device_param->kernel_params[32]);
2720 hc_clSetKernelArg (data.ocl, kernel, 33, sizeof (cl_uint), device_param->kernel_params[33]);
2721 hc_clSetKernelArg (data.ocl, kernel, 34, sizeof (cl_uint), device_param->kernel_params[34]);
2722
2723 cl_event event;
2724
2725 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2726 {
2727 const size_t global_work_size[3] = { num_elements, 32, 1 };
2728 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2729
2730 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2731 }
2732 else
2733 {
2734 if (kern_run == KERN_RUN_2)
2735 {
2736 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2737 {
2738 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2739 }
2740 }
2741
2742 while (num_elements % kernel_threads) num_elements++;
2743
2744 const size_t global_work_size[3] = { num_elements, 1, 1 };
2745 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2746
2747 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2748 }
2749
2750 hc_clFlush (data.ocl, device_param->command_queue);
2751
2752 if (device_param->nvidia_spin_damp)
2753 {
2754 if (data.devices_status == STATUS_RUNNING)
2755 {
2756 if (iteration < EXPECTED_ITERATIONS)
2757 {
2758 switch (kern_run)
2759 {
2760 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2761 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2762 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2763 }
2764 }
2765 }
2766 }
2767
2768 hc_clWaitForEvents (data.ocl, 1, &event);
2769
2770 cl_ulong time_start;
2771 cl_ulong time_end;
2772
2773 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2774 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2775
2776 const double exec_us = (double) (time_end - time_start) / 1000;
2777
2778 if (data.devices_status == STATUS_RUNNING)
2779 {
2780 if (iteration < EXPECTED_ITERATIONS)
2781 {
2782 switch (kern_run)
2783 {
2784 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2785 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2786 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2787 }
2788 }
2789 }
2790
2791 if (event_update)
2792 {
2793 uint exec_pos = device_param->exec_pos;
2794
2795 device_param->exec_ms[exec_pos] = exec_us / 1000;
2796
2797 exec_pos++;
2798
2799 if (exec_pos == EXEC_CACHE)
2800 {
2801 exec_pos = 0;
2802 }
2803
2804 device_param->exec_pos = exec_pos;
2805 }
2806
2807 hc_clReleaseEvent (data.ocl, event);
2808
2809 hc_clFinish (data.ocl, device_param->command_queue);
2810 }
2811
2812 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2813 {
2814 uint num_elements = num;
2815
2816 switch (kern_run)
2817 {
2818 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2819 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2820 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2821 }
2822
2823 // causes problems with special threads like in bcrypt
2824 // const uint kernel_threads = device_param->kernel_threads;
2825
2826 uint kernel_threads = device_param->kernel_threads;
2827
2828 while (num_elements % kernel_threads) num_elements++;
2829
2830 cl_kernel kernel = NULL;
2831
2832 switch (kern_run)
2833 {
2834 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2835 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2836 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2837 }
2838
2839 switch (kern_run)
2840 {
2841 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2842 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2843 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2844 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2845 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2846 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2847 break;
2848 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2849 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2850 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2851 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2852 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2853 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2854 break;
2855 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2856 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2857 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2858 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2859 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2860 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2861 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2862 break;
2863 }
2864
2865 const size_t global_work_size[3] = { num_elements, 1, 1 };
2866 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2867
2868 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2869
2870 hc_clFlush (data.ocl, device_param->command_queue);
2871
2872 hc_clFinish (data.ocl, device_param->command_queue);
2873 }
2874
2875 static void run_kernel_tm (hc_device_param_t *device_param)
2876 {
2877 const uint num_elements = 1024; // fixed
2878
2879 uint kernel_threads = 32;
2880
2881 cl_kernel kernel = device_param->kernel_tm;
2882
2883 const size_t global_work_size[3] = { num_elements, 1, 1 };
2884 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2885
2886 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2887
2888 hc_clFlush (data.ocl, device_param->command_queue);
2889
2890 hc_clFinish (data.ocl, device_param->command_queue);
2891 }
2892
2893 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2894 {
2895 uint num_elements = num;
2896
2897 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2898 device_param->kernel_params_amp_buf32[6] = num_elements;
2899
2900 // causes problems with special threads like in bcrypt
2901 // const uint kernel_threads = device_param->kernel_threads;
2902
2903 uint kernel_threads = device_param->kernel_threads;
2904
2905 while (num_elements % kernel_threads) num_elements++;
2906
2907 cl_kernel kernel = device_param->kernel_amp;
2908
2909 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2910 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2911
2912 const size_t global_work_size[3] = { num_elements, 1, 1 };
2913 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2914
2915 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2916
2917 hc_clFlush (data.ocl, device_param->command_queue);
2918
2919 hc_clFinish (data.ocl, device_param->command_queue);
2920 }
2921
2922 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2923 {
2924 const u32 num16d = num / 16;
2925 const u32 num16m = num % 16;
2926
2927 if (num16d)
2928 {
2929 device_param->kernel_params_memset_buf32[1] = value;
2930 device_param->kernel_params_memset_buf32[2] = num16d;
2931
2932 uint kernel_threads = device_param->kernel_threads;
2933
2934 uint num_elements = num16d;
2935
2936 while (num_elements % kernel_threads) num_elements++;
2937
2938 cl_kernel kernel = device_param->kernel_memset;
2939
2940 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2941 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2942 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2943
2944 const size_t global_work_size[3] = { num_elements, 1, 1 };
2945 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2946
2947 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2948
2949 hc_clFlush (data.ocl, device_param->command_queue);
2950
2951 hc_clFinish (data.ocl, device_param->command_queue);
2952 }
2953
2954 if (num16m)
2955 {
2956 u32 tmp[4];
2957
2958 tmp[0] = value;
2959 tmp[1] = value;
2960 tmp[2] = value;
2961 tmp[3] = value;
2962
2963 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2964 }
2965 }
2966
2967 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2968 {
2969 run_kernel_memset (device_param, buf, 0, size);
2970
2971 /*
2972 int rc = -1;
2973
2974 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2975 {
2976 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2977
2978 const cl_uchar zero = 0;
2979
2980 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2981 }
2982
2983 if (rc != 0)
2984 {
2985 // NOTE: clEnqueueFillBuffer () always fails with -59
2986 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2987 // How's that possible, OpenCL 1.2 support is advertised??
2988 // We need to workaround...
2989
2990 #define FILLSZ 0x100000
2991
2992 char *tmp = (char *) mymalloc (FILLSZ);
2993
2994 for (size_t i = 0; i < size; i += FILLSZ)
2995 {
2996 const size_t left = size - i;
2997
2998 const size_t fillsz = MIN (FILLSZ, left);
2999
3000 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
3001 }
3002
3003 myfree (tmp);
3004 }
3005 */
3006 }
3007
3008 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)
3009 {
3010 if (data.hash_mode == 2000)
3011 {
3012 process_stdout (device_param, pws_cnt);
3013
3014 return;
3015 }
3016
3017 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3018 {
3019 if (attack_mode == ATTACK_MODE_BF)
3020 {
3021 if (opts_type & OPTS_TYPE_PT_BITSLICE)
3022 {
3023 const uint size_tm = 32 * sizeof (bs_word_t);
3024
3025 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
3026
3027 run_kernel_tm (device_param);
3028
3029 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);
3030 }
3031 }
3032
3033 if (highest_pw_len < 16)
3034 {
3035 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
3036 }
3037 else if (highest_pw_len < 32)
3038 {
3039 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
3040 }
3041 else
3042 {
3043 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3044 }
3045 }
3046 else
3047 {
3048 run_kernel_amp (device_param, pws_cnt);
3049
3050 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3051
3052 if (opts_type & OPTS_TYPE_HOOK12)
3053 {
3054 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3055
3056 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);
3057
3058 // do something with data
3059
3060 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);
3061 }
3062
3063 uint iter = salt_buf->salt_iter;
3064
3065 uint loop_step = device_param->kernel_loops;
3066
3067 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3068 {
3069 uint loop_left = iter - loop_pos;
3070
3071 loop_left = MIN (loop_left, loop_step);
3072
3073 device_param->kernel_params_buf32[28] = loop_pos;
3074 device_param->kernel_params_buf32[29] = loop_left;
3075
3076 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3077
3078 if (data.devices_status == STATUS_CRACKED) break;
3079 if (data.devices_status == STATUS_ABORTED) break;
3080 if (data.devices_status == STATUS_QUIT) break;
3081 if (data.devices_status == STATUS_BYPASS) break;
3082
3083 /**
3084 * speed
3085 */
3086
3087 const float iter_part = (float) (loop_pos + loop_left) / iter;
3088
3089 const u64 perf_sum_all = pws_cnt * iter_part;
3090
3091 double speed_ms;
3092
3093 hc_timer_get (device_param->timer_speed, speed_ms);
3094
3095 const u32 speed_pos = device_param->speed_pos;
3096
3097 device_param->speed_cnt[speed_pos] = perf_sum_all;
3098
3099 device_param->speed_ms[speed_pos] = speed_ms;
3100
3101 if (data.benchmark == 1)
3102 {
3103 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3104 }
3105 }
3106
3107 if (opts_type & OPTS_TYPE_HOOK23)
3108 {
3109 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3110
3111 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);
3112
3113 // do something with data
3114
3115 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);
3116 }
3117
3118 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3119 }
3120 }
3121
3122 static int run_rule_engine (const int rule_len, const char *rule_buf)
3123 {
3124 if (rule_len == 0)
3125 {
3126 return 0;
3127 }
3128 else if (rule_len == 1)
3129 {
3130 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3131 }
3132
3133 return 1;
3134 }
3135
3136 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3137 {
3138 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3139 {
3140 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);
3141 }
3142 else if (data.attack_kern == ATTACK_KERN_COMBI)
3143 {
3144 if (data.attack_mode == ATTACK_MODE_COMBI)
3145 {
3146 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3147 {
3148 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3149 {
3150 for (u32 i = 0; i < pws_cnt; i++)
3151 {
3152 const u32 pw_len = device_param->pws_buf[i].pw_len;
3153
3154 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3155
3156 ptr[pw_len] = 0x01;
3157 }
3158 }
3159 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3160 {
3161 for (u32 i = 0; i < pws_cnt; i++)
3162 {
3163 const u32 pw_len = device_param->pws_buf[i].pw_len;
3164
3165 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3166
3167 ptr[pw_len] = 0x80;
3168 }
3169 }
3170 }
3171 }
3172 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3173 {
3174 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3175 {
3176 for (u32 i = 0; i < pws_cnt; i++)
3177 {
3178 const u32 pw_len = device_param->pws_buf[i].pw_len;
3179
3180 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3181
3182 ptr[pw_len] = 0x01;
3183 }
3184 }
3185 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3186 {
3187 for (u32 i = 0; i < pws_cnt; i++)
3188 {
3189 const u32 pw_len = device_param->pws_buf[i].pw_len;
3190
3191 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3192
3193 ptr[pw_len] = 0x80;
3194 }
3195 }
3196 }
3197
3198 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);
3199 }
3200 else if (data.attack_kern == ATTACK_KERN_BF)
3201 {
3202 const u64 off = device_param->words_off;
3203
3204 device_param->kernel_params_mp_l_buf64[3] = off;
3205
3206 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3207 }
3208 }
3209
3210 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3211 {
3212 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3213
3214 device_param->kernel_params_buf32[28] = 0;
3215 device_param->kernel_params_buf32[29] = kernel_loops; // not a bug, both need to be set
3216 device_param->kernel_params_buf32[30] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3217
3218 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3219 {
3220 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3221 }
3222 else
3223 {
3224 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3225 }
3226
3227 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3228
3229 return exec_ms_prev;
3230 }
3231
3232 static void autotune (hc_device_param_t *device_param)
3233 {
3234 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3235
3236 const u32 kernel_accel_min = device_param->kernel_accel_min;
3237 const u32 kernel_accel_max = device_param->kernel_accel_max;
3238
3239 const u32 kernel_loops_min = device_param->kernel_loops_min;
3240 const u32 kernel_loops_max = device_param->kernel_loops_max;
3241
3242 u32 kernel_accel = kernel_accel_min;
3243 u32 kernel_loops = kernel_loops_min;
3244
3245 // in this case the user specified a fixed -u and -n on the commandline
3246 // no way to tune anything
3247 // but we need to run a few caching rounds
3248
3249 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3250 {
3251 if (data.hash_mode != 2000)
3252 {
3253 try_run (device_param, kernel_accel, kernel_loops);
3254 try_run (device_param, kernel_accel, kernel_loops);
3255 try_run (device_param, kernel_accel, kernel_loops);
3256 try_run (device_param, kernel_accel, kernel_loops);
3257 }
3258
3259 device_param->kernel_accel = kernel_accel;
3260 device_param->kernel_loops = kernel_loops;
3261
3262 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3263
3264 device_param->kernel_power = kernel_power;
3265
3266 return;
3267 }
3268
3269 // from here it's clear we are allowed to autotune
3270 // so let's init some fake words
3271
3272 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3273
3274 if (data.attack_kern == ATTACK_KERN_BF)
3275 {
3276 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3277 }
3278 else
3279 {
3280 for (u32 i = 0; i < kernel_power_max; i++)
3281 {
3282 device_param->pws_buf[i].i[0] = i;
3283 device_param->pws_buf[i].i[1] = 0x01234567;
3284 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3285 }
3286
3287 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);
3288 }
3289
3290 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3291 {
3292 if (data.kernel_rules_cnt > 1)
3293 {
3294 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);
3295 }
3296 }
3297 else
3298 {
3299 run_kernel_amp (device_param, kernel_power_max);
3300 }
3301
3302 #define VERIFIER_CNT 1
3303
3304 // first find out highest kernel-loops that stays below target_ms
3305
3306 if (kernel_loops_min < kernel_loops_max)
3307 {
3308 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3309 {
3310 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3311
3312 for (int i = 0; i < VERIFIER_CNT; i++)
3313 {
3314 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3315
3316 exec_ms = MIN (exec_ms, exec_ms_v);
3317 }
3318
3319 if (exec_ms < target_ms) break;
3320 }
3321 }
3322
3323 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3324
3325 #define STEPS_CNT 10
3326
3327 if (kernel_accel_min < kernel_accel_max)
3328 {
3329 for (int i = 0; i < STEPS_CNT; i++)
3330 {
3331 const u32 kernel_accel_try = 1 << i;
3332
3333 if (kernel_accel_try < kernel_accel_min) continue;
3334 if (kernel_accel_try > kernel_accel_max) break;
3335
3336 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3337
3338 for (int i = 0; i < VERIFIER_CNT; i++)
3339 {
3340 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3341
3342 exec_ms = MIN (exec_ms, exec_ms_v);
3343 }
3344
3345 if (exec_ms > target_ms) break;
3346
3347 kernel_accel = kernel_accel_try;
3348 }
3349 }
3350
3351 // at this point we want to know the actual runtime for the following reason:
3352 // we need a reference for the balancing loop following up, and this
3353 // the balancing loop can have an effect that the creates a new opportunity, for example:
3354 // if the target is 95 ms and the current runtime is 48ms the above loop
3355 // stopped the execution because the previous exec_ms was > 95ms
3356 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3357 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3358
3359 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3360
3361 for (int i = 0; i < VERIFIER_CNT; i++)
3362 {
3363 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3364
3365 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3366 }
3367
3368 u32 diff = kernel_loops - kernel_accel;
3369
3370 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3371 {
3372 u32 kernel_accel_orig = kernel_accel;
3373 u32 kernel_loops_orig = kernel_loops;
3374
3375 for (u32 f = 1; f < 1024; f++)
3376 {
3377 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3378 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3379
3380 if (kernel_accel_try > kernel_accel_max) break;
3381 if (kernel_loops_try < kernel_loops_min) break;
3382
3383 u32 diff_new = kernel_loops_try - kernel_accel_try;
3384
3385 if (diff_new > diff) break;
3386
3387 diff_new = diff;
3388
3389 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3390
3391 for (int i = 0; i < VERIFIER_CNT; i++)
3392 {
3393 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3394
3395 exec_ms = MIN (exec_ms, exec_ms_v);
3396 }
3397
3398 if (exec_ms < exec_ms_pre_final)
3399 {
3400 exec_ms_pre_final = exec_ms;
3401
3402 kernel_accel = kernel_accel_try;
3403 kernel_loops = kernel_loops_try;
3404 }
3405 }
3406 }
3407
3408 const double exec_left = target_ms / exec_ms_pre_final;
3409
3410 const double accel_left = kernel_accel_max / kernel_accel;
3411
3412 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3413
3414 if (exec_accel_min >= 1.0)
3415 {
3416 // this is safe to not overflow kernel_accel_max because of accel_left
3417
3418 kernel_accel = (double) kernel_accel * exec_accel_min;
3419 }
3420
3421 // reset them fake words
3422
3423 /*
3424 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3425
3426 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);
3427 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);
3428 */
3429
3430 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3431
3432 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3433 {
3434 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3435 }
3436
3437 // reset timer
3438
3439 device_param->exec_pos = 0;
3440
3441 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3442
3443 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3444 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3445 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3446
3447 // store
3448
3449 device_param->kernel_accel = kernel_accel;
3450 device_param->kernel_loops = kernel_loops;
3451
3452 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3453
3454 device_param->kernel_power = kernel_power;
3455
3456 #ifdef DEBUG
3457
3458 if (data.quiet == 0)
3459 {
3460 clear_prompt ();
3461
3462 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3463 "- Device #%u: autotuned kernel-loops to %u\n",
3464 device_param->device_id + 1, kernel_accel,
3465 device_param->device_id + 1, kernel_loops);
3466
3467 fprintf (stdout, "%s", PROMPT);
3468
3469 fflush (stdout);
3470 }
3471
3472 #endif
3473 }
3474
3475 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3476 {
3477 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3478
3479 // init speed timer
3480
3481 uint speed_pos = device_param->speed_pos;
3482
3483 #ifdef _POSIX
3484 if (device_param->timer_speed.tv_sec == 0)
3485 {
3486 hc_timer_set (&device_param->timer_speed);
3487 }
3488 #endif
3489
3490 #ifdef _WIN
3491 if (device_param->timer_speed.QuadPart == 0)
3492 {
3493 hc_timer_set (&device_param->timer_speed);
3494 }
3495 #endif
3496
3497 // find higest password length, this is for optimization stuff
3498
3499 uint highest_pw_len = 0;
3500
3501 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3502 {
3503 }
3504 else if (data.attack_kern == ATTACK_KERN_COMBI)
3505 {
3506 }
3507 else if (data.attack_kern == ATTACK_KERN_BF)
3508 {
3509 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3510 + device_param->kernel_params_mp_l_buf32[5];
3511 }
3512
3513 // iteration type
3514
3515 uint innerloop_step = 0;
3516 uint innerloop_cnt = 0;
3517
3518 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3519 else innerloop_step = 1;
3520
3521 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3522 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3523 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3524
3525 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3526
3527 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3528 {
3529 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3530
3531 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3532
3533 if (data.devices_status == STATUS_CRACKED) break;
3534 if (data.devices_status == STATUS_ABORTED) break;
3535 if (data.devices_status == STATUS_QUIT) break;
3536 if (data.devices_status == STATUS_BYPASS) break;
3537
3538 salt_t *salt_buf = &data.salts_buf[salt_pos];
3539
3540 device_param->kernel_params_buf32[27] = salt_pos;
3541 device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
3542 device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
3543
3544 FILE *combs_fp = device_param->combs_fp;
3545
3546 if (data.attack_mode == ATTACK_MODE_COMBI)
3547 {
3548 rewind (combs_fp);
3549 }
3550
3551 // innerloops
3552
3553 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3554 {
3555 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3556
3557 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3558
3559 if (data.devices_status == STATUS_CRACKED) break;
3560 if (data.devices_status == STATUS_ABORTED) break;
3561 if (data.devices_status == STATUS_QUIT) break;
3562 if (data.devices_status == STATUS_BYPASS) break;
3563
3564 uint fast_iteration = 0;
3565
3566 uint innerloop_left = innerloop_cnt - innerloop_pos;
3567
3568 if (innerloop_left > innerloop_step)
3569 {
3570 innerloop_left = innerloop_step;
3571
3572 fast_iteration = 1;
3573 }
3574
3575 device_param->innerloop_pos = innerloop_pos;
3576 device_param->innerloop_left = innerloop_left;
3577
3578 device_param->kernel_params_buf32[30] = innerloop_left;
3579
3580 // i think we can get rid of this
3581 if (innerloop_left == 0)
3582 {
3583 puts ("bug, how should this happen????\n");
3584
3585 continue;
3586 }
3587
3588 if (data.salts_shown[salt_pos] == 1)
3589 {
3590 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3591
3592 continue;
3593 }
3594
3595 // initialize amplifiers
3596
3597 if (data.attack_mode == ATTACK_MODE_COMBI)
3598 {
3599 uint i = 0;
3600
3601 while (i < innerloop_left)
3602 {
3603 if (feof (combs_fp)) break;
3604
3605 int line_len = fgetl (combs_fp, line_buf);
3606
3607 if (line_len >= PW_MAX1) continue;
3608
3609 line_len = convert_from_hex (line_buf, line_len);
3610
3611 char *line_buf_new = line_buf;
3612
3613 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3614 {
3615 char rule_buf_out[BLOCK_SIZE] = { 0 };
3616
3617 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3618
3619 if (rule_len_out < 0)
3620 {
3621 data.words_progress_rejected[salt_pos] += pws_cnt;
3622
3623 continue;
3624 }
3625
3626 line_len = rule_len_out;
3627
3628 line_buf_new = rule_buf_out;
3629 }
3630
3631 line_len = MIN (line_len, PW_DICTMAX);
3632
3633 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3634
3635 memcpy (ptr, line_buf_new, line_len);
3636
3637 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3638
3639 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3640 {
3641 uppercase (ptr, line_len);
3642 }
3643
3644 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3645 {
3646 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3647 {
3648 ptr[line_len] = 0x80;
3649 }
3650
3651 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3652 {
3653 ptr[line_len] = 0x01;
3654 }
3655 }
3656
3657 device_param->combs_buf[i].pw_len = line_len;
3658
3659 i++;
3660 }
3661
3662 for (uint j = i; j < innerloop_left; j++)
3663 {
3664 device_param->combs_buf[j].i[0] = 0;
3665 device_param->combs_buf[j].i[1] = 0;
3666 device_param->combs_buf[j].i[2] = 0;
3667 device_param->combs_buf[j].i[3] = 0;
3668 device_param->combs_buf[j].i[4] = 0;
3669 device_param->combs_buf[j].i[5] = 0;
3670 device_param->combs_buf[j].i[6] = 0;
3671 device_param->combs_buf[j].i[7] = 0;
3672
3673 device_param->combs_buf[j].pw_len = 0;
3674 }
3675
3676 innerloop_left = i;
3677 }
3678 else if (data.attack_mode == ATTACK_MODE_BF)
3679 {
3680 u64 off = innerloop_pos;
3681
3682 device_param->kernel_params_mp_r_buf64[3] = off;
3683
3684 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3685 }
3686 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3687 {
3688 u64 off = innerloop_pos;
3689
3690 device_param->kernel_params_mp_buf64[3] = off;
3691
3692 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3693 }
3694 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3695 {
3696 u64 off = innerloop_pos;
3697
3698 device_param->kernel_params_mp_buf64[3] = off;
3699
3700 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3701 }
3702
3703 // copy amplifiers
3704
3705 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3706 {
3707 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);
3708 }
3709 else if (data.attack_mode == ATTACK_MODE_COMBI)
3710 {
3711 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);
3712 }
3713 else if (data.attack_mode == ATTACK_MODE_BF)
3714 {
3715 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);
3716 }
3717 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3718 {
3719 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3720 }
3721 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3722 {
3723 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);
3724 }
3725
3726 if (data.benchmark == 1)
3727 {
3728 hc_timer_set (&device_param->timer_speed);
3729 }
3730
3731 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3732
3733 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3734
3735 if (data.devices_status == STATUS_CRACKED) break;
3736 if (data.devices_status == STATUS_ABORTED) break;
3737 if (data.devices_status == STATUS_QUIT) break;
3738 if (data.devices_status == STATUS_BYPASS) break;
3739
3740 /**
3741 * result
3742 */
3743
3744 if (data.benchmark == 0)
3745 {
3746 check_cracked (device_param, salt_pos);
3747 }
3748
3749 /**
3750 * progress
3751 */
3752
3753 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3754
3755 hc_thread_mutex_lock (mux_counter);
3756
3757 data.words_progress_done[salt_pos] += perf_sum_all;
3758
3759 hc_thread_mutex_unlock (mux_counter);
3760
3761 /**
3762 * speed
3763 */
3764
3765 double speed_ms;
3766
3767 hc_timer_get (device_param->timer_speed, speed_ms);
3768
3769 hc_timer_set (&device_param->timer_speed);
3770
3771 // current speed
3772
3773 //hc_thread_mutex_lock (mux_display);
3774
3775 device_param->speed_cnt[speed_pos] = perf_sum_all;
3776
3777 device_param->speed_ms[speed_pos] = speed_ms;
3778
3779 //hc_thread_mutex_unlock (mux_display);
3780
3781 speed_pos++;
3782
3783 if (speed_pos == SPEED_CACHE)
3784 {
3785 speed_pos = 0;
3786 }
3787
3788 /**
3789 * benchmark
3790 */
3791
3792 if (data.benchmark == 1) break;
3793 }
3794 }
3795
3796 device_param->speed_pos = speed_pos;
3797
3798 myfree (line_buf);
3799 }
3800
3801 static void load_segment (wl_data_t *wl_data, FILE *fd)
3802 {
3803 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3804
3805 wl_data->pos = 0;
3806
3807 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3808
3809 wl_data->buf[wl_data->cnt] = 0;
3810
3811 if (wl_data->cnt == 0) return;
3812
3813 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3814
3815 while (!feof (fd))
3816 {
3817 if (wl_data->cnt == wl_data->avail)
3818 {
3819 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3820
3821 wl_data->avail += wl_data->incr;
3822 }
3823
3824 const int c = fgetc (fd);
3825
3826 if (c == EOF) break;
3827
3828 wl_data->buf[wl_data->cnt] = (char) c;
3829
3830 wl_data->cnt++;
3831
3832 if (c == '\n') break;
3833 }
3834
3835 // ensure stream ends with a newline
3836
3837 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3838 {
3839 wl_data->cnt++;
3840
3841 wl_data->buf[wl_data->cnt - 1] = '\n';
3842 }
3843
3844 return;
3845 }
3846
3847 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3848 {
3849 char *ptr = buf;
3850
3851 for (u32 i = 0; i < sz; i++, ptr++)
3852 {
3853 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3854
3855 if (i == 7)
3856 {
3857 *off = i;
3858 *len = i;
3859
3860 return;
3861 }
3862
3863 if (*ptr != '\n') continue;
3864
3865 *off = i + 1;
3866
3867 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3868
3869 *len = i;
3870
3871 return;
3872 }
3873
3874 *off = sz;
3875 *len = sz;
3876 }
3877
3878 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3879 {
3880 char *ptr = buf;
3881
3882 for (u32 i = 0; i < sz; i++, ptr++)
3883 {
3884 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3885
3886 if (*ptr != '\n') continue;
3887
3888 *off = i + 1;
3889
3890 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3891
3892 *len = i;
3893
3894 return;
3895 }
3896
3897 *off = sz;
3898 *len = sz;
3899 }
3900
3901 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3902 {
3903 char *ptr = buf;
3904
3905 for (u32 i = 0; i < sz; i++, ptr++)
3906 {
3907 if (*ptr != '\n') continue;
3908
3909 *off = i + 1;
3910
3911 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3912
3913 *len = i;
3914
3915 return;
3916 }
3917
3918 *off = sz;
3919 *len = sz;
3920 }
3921
3922 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3923 {
3924 while (wl_data->pos < wl_data->cnt)
3925 {
3926 uint off;
3927 uint len;
3928
3929 char *ptr = wl_data->buf + wl_data->pos;
3930
3931 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3932
3933 wl_data->pos += off;
3934
3935 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3936 {
3937 char rule_buf_out[BLOCK_SIZE] = { 0 };
3938
3939 int rule_len_out = -1;
3940
3941 if (len < BLOCK_SIZE)
3942 {
3943 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3944 }
3945
3946 if (rule_len_out < 0)
3947 {
3948 continue;
3949 }
3950
3951 if (rule_len_out > PW_MAX)
3952 {
3953 continue;
3954 }
3955 }
3956 else
3957 {
3958 if (len > PW_MAX)
3959 {
3960 continue;
3961 }
3962 }
3963
3964 *out_buf = ptr;
3965 *out_len = len;
3966
3967 return;
3968 }
3969
3970 if (feof (fd))
3971 {
3972 fprintf (stderr, "BUG feof()!!\n");
3973
3974 return;
3975 }
3976
3977 load_segment (wl_data, fd);
3978
3979 get_next_word (wl_data, fd, out_buf, out_len);
3980 }
3981
3982 #ifdef _POSIX
3983 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3984 #endif
3985
3986 #ifdef _WIN
3987 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3988 #endif
3989 {
3990 hc_signal (NULL);
3991
3992 dictstat_t d;
3993
3994 d.cnt = 0;
3995
3996 #ifdef _POSIX
3997 fstat (fileno (fd), &d.stat);
3998 #endif
3999
4000 #ifdef _WIN
4001 _fstat64 (fileno (fd), &d.stat);
4002 #endif
4003
4004 d.stat.st_mode = 0;
4005 d.stat.st_nlink = 0;
4006 d.stat.st_uid = 0;
4007 d.stat.st_gid = 0;
4008 d.stat.st_rdev = 0;
4009 d.stat.st_atime = 0;
4010
4011 #ifdef _POSIX
4012 d.stat.st_blksize = 0;
4013 d.stat.st_blocks = 0;
4014 #endif
4015
4016 if (d.stat.st_size == 0) return 0;
4017
4018 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4019
4020 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
4021 {
4022 if (d_cache)
4023 {
4024 u64 cnt = d_cache->cnt;
4025
4026 u64 keyspace = cnt;
4027
4028 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4029 {
4030 keyspace *= data.kernel_rules_cnt;
4031 }
4032 else if (data.attack_kern == ATTACK_KERN_COMBI)
4033 {
4034 keyspace *= data.combs_cnt;
4035 }
4036
4037 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);
4038 if (data.quiet == 0) log_info ("");
4039
4040 hc_signal (sigHandler_default);
4041
4042 return (keyspace);
4043 }
4044 }
4045
4046 time_t now = 0;
4047 time_t prev = 0;
4048
4049 u64 comp = 0;
4050 u64 cnt = 0;
4051 u64 cnt2 = 0;
4052
4053 while (!feof (fd))
4054 {
4055 load_segment (wl_data, fd);
4056
4057 comp += wl_data->cnt;
4058
4059 u32 i = 0;
4060
4061 while (i < wl_data->cnt)
4062 {
4063 u32 len;
4064 u32 off;
4065
4066 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4067
4068 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4069 {
4070 char rule_buf_out[BLOCK_SIZE] = { 0 };
4071
4072 int rule_len_out = -1;
4073
4074 if (len < BLOCK_SIZE)
4075 {
4076 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4077 }
4078
4079 if (rule_len_out < 0)
4080 {
4081 len = PW_MAX1;
4082 }
4083 else
4084 {
4085 len = rule_len_out;
4086 }
4087 }
4088
4089 if (len < PW_MAX1)
4090 {
4091 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4092 {
4093 cnt += data.kernel_rules_cnt;
4094 }
4095 else if (data.attack_kern == ATTACK_KERN_COMBI)
4096 {
4097 cnt += data.combs_cnt;
4098 }
4099
4100 d.cnt++;
4101 }
4102
4103 i += off;
4104
4105 cnt2++;
4106 }
4107
4108 time (&now);
4109
4110 if ((now - prev) == 0) continue;
4111
4112 float percent = (float) comp / (float) d.stat.st_size;
4113
4114 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);
4115
4116 time (&prev);
4117 }
4118
4119 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);
4120 if (data.quiet == 0) log_info ("");
4121
4122 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4123
4124 hc_signal (sigHandler_default);
4125
4126 return (cnt);
4127 }
4128
4129 static void *thread_monitor (void *p)
4130 {
4131 uint runtime_check = 0;
4132 uint remove_check = 0;
4133 uint status_check = 0;
4134 uint restore_check = 0;
4135
4136 uint restore_left = data.restore_timer;
4137 uint remove_left = data.remove_timer;
4138 uint status_left = data.status_timer;
4139
4140 #ifdef HAVE_HWMON
4141 uint hwmon_check = 0;
4142
4143 int slowdown_warnings = 0;
4144
4145 // these variables are mainly used for fan control
4146
4147 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4148
4149 // temperature controller "loopback" values
4150
4151 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4152 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4153
4154 int temp_threshold = 1; // degrees celcius
4155
4156 int fan_speed_min = 15; // in percentage
4157 int fan_speed_max = 100;
4158
4159 time_t last_temp_check_time;
4160 #endif // HAVE_HWMON
4161
4162 uint sleep_time = 1;
4163
4164 if (data.runtime)
4165 {
4166 runtime_check = 1;
4167 }
4168
4169 if (data.restore_timer)
4170 {
4171 restore_check = 1;
4172 }
4173
4174 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4175 {
4176 remove_check = 1;
4177 }
4178
4179 if (data.status == 1)
4180 {
4181 status_check = 1;
4182 }
4183
4184 #ifdef HAVE_HWMON
4185 if (data.gpu_temp_disable == 0)
4186 {
4187 time (&last_temp_check_time);
4188
4189 hwmon_check = 1;
4190 }
4191 #endif
4192
4193 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4194 {
4195 #ifdef HAVE_HWMON
4196 if (hwmon_check == 0)
4197 #endif
4198 return (p);
4199 }
4200
4201 while (data.shutdown_inner == 0)
4202 {
4203 hc_sleep (sleep_time);
4204
4205 if (data.devices_status != STATUS_RUNNING) continue;
4206
4207 #ifdef HAVE_HWMON
4208
4209 if (hwmon_check == 1)
4210 {
4211 hc_thread_mutex_lock (mux_adl);
4212
4213 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4214 {
4215 hc_device_param_t *device_param = &data.devices_param[device_id];
4216
4217 if (device_param->skipped) continue;
4218
4219 if (device_param->device_vendor_id == VENDOR_ID_NV)
4220 {
4221 if (data.hm_nvapi)
4222 {
4223 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info;
4224 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status;
4225
4226 memset (&perfPolicies_info, 0, sizeof (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1));
4227 memset (&perfPolicies_status, 0, sizeof (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1));
4228
4229 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4230 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4231
4232 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4233
4234 perfPolicies_status.info_value = perfPolicies_info.info_value;
4235
4236 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4237
4238 if (perfPolicies_status.throttle & 2)
4239 {
4240 if (slowdown_warnings < 3)
4241 {
4242 if (data.quiet == 0) clear_prompt ();
4243
4244 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4245
4246 if (slowdown_warnings == 2)
4247 {
4248 log_info ("");
4249 }
4250
4251 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4252 if (data.quiet == 0) fflush (stdout);
4253
4254 slowdown_warnings++;
4255 }
4256 }
4257 else
4258 {
4259 slowdown_warnings = 0;
4260 }
4261 }
4262 }
4263 }
4264
4265 hc_thread_mutex_unlock (mux_adl);
4266 }
4267
4268 if (hwmon_check == 1)
4269 {
4270 hc_thread_mutex_lock (mux_adl);
4271
4272 time_t temp_check_time;
4273
4274 time (&temp_check_time);
4275
4276 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4277
4278 if (Ta == 0) Ta = 1;
4279
4280 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4281 {
4282 hc_device_param_t *device_param = &data.devices_param[device_id];
4283
4284 if (device_param->skipped) continue;
4285
4286 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4287
4288 const int temperature = hm_get_temperature_with_device_id (device_id);
4289
4290 if (temperature > (int) data.gpu_temp_abort)
4291 {
4292 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4293
4294 if (data.devices_status != STATUS_QUIT) myabort ();
4295
4296 break;
4297 }
4298
4299 const int gpu_temp_retain = data.gpu_temp_retain;
4300
4301 if (gpu_temp_retain)
4302 {
4303 if (data.hm_device[device_id].fan_set_supported == 1)
4304 {
4305 int temp_cur = temperature;
4306
4307 int temp_diff_new = gpu_temp_retain - temp_cur;
4308
4309 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4310
4311 // calculate Ta value (time difference in seconds between the last check and this check)
4312
4313 last_temp_check_time = temp_check_time;
4314
4315 float Kp = 1.8;
4316 float Ki = 0.005;
4317 float Kd = 6;
4318
4319 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4320
4321 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);
4322
4323 if (abs (fan_diff_required) >= temp_threshold)
4324 {
4325 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4326
4327 int fan_speed_level = fan_speed_cur;
4328
4329 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4330
4331 int fan_speed_new = fan_speed_level - fan_diff_required;
4332
4333 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4334 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4335
4336 if (fan_speed_new != fan_speed_cur)
4337 {
4338 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4339 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4340
4341 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4342 {
4343 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4344 {
4345 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4346 }
4347 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4348 {
4349 #ifdef WIN
4350 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4351 #endif
4352
4353 #ifdef LINUX
4354 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4355 #endif
4356 }
4357
4358 fan_speed_chgd[device_id] = 1;
4359 }
4360
4361 temp_diff_old[device_id] = temp_diff_new;
4362 }
4363 }
4364 }
4365 }
4366 }
4367
4368 hc_thread_mutex_unlock (mux_adl);
4369 }
4370 #endif // HAVE_HWMON
4371
4372 if (restore_check == 1)
4373 {
4374 restore_left--;
4375
4376 if (restore_left == 0)
4377 {
4378 if (data.restore_disable == 0) cycle_restore ();
4379
4380 restore_left = data.restore_timer;
4381 }
4382 }
4383
4384 if ((runtime_check == 1) && (data.runtime_start > 0))
4385 {
4386 time_t runtime_cur;
4387
4388 time (&runtime_cur);
4389
4390 int runtime_left = data.proc_start + data.runtime - runtime_cur;
4391
4392 if (runtime_left <= 0)
4393 {
4394 if (data.benchmark == 0)
4395 {
4396 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4397 }
4398
4399 if (data.devices_status != STATUS_QUIT) myabort ();
4400 }
4401 }
4402
4403 if (remove_check == 1)
4404 {
4405 remove_left--;
4406
4407 if (remove_left == 0)
4408 {
4409 if (data.digests_saved != data.digests_done)
4410 {
4411 data.digests_saved = data.digests_done;
4412
4413 save_hash ();
4414 }
4415
4416 remove_left = data.remove_timer;
4417 }
4418 }
4419
4420 if (status_check == 1)
4421 {
4422 status_left--;
4423
4424 if (status_left == 0)
4425 {
4426 hc_thread_mutex_lock (mux_display);
4427
4428 if (data.quiet == 0) clear_prompt ();
4429
4430 if (data.quiet == 0) log_info ("");
4431
4432 status_display ();
4433
4434 if (data.quiet == 0) log_info ("");
4435
4436 hc_thread_mutex_unlock (mux_display);
4437
4438 status_left = data.status_timer;
4439 }
4440 }
4441 }
4442
4443 #ifdef HAVE_HWMON
4444 myfree (fan_speed_chgd);
4445
4446 myfree (temp_diff_old);
4447 myfree (temp_diff_sum);
4448 #endif
4449
4450 p = NULL;
4451
4452 return (p);
4453 }
4454
4455 static void *thread_outfile_remove (void *p)
4456 {
4457 // some hash-dependent constants
4458 char *outfile_dir = data.outfile_check_directory;
4459 uint dgst_size = data.dgst_size;
4460 uint isSalted = data.isSalted;
4461 uint esalt_size = data.esalt_size;
4462 uint hash_mode = data.hash_mode;
4463
4464 uint outfile_check_timer = data.outfile_check_timer;
4465
4466 char separator = data.separator;
4467
4468 // some hash-dependent functions
4469 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4470 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4471
4472 // buffers
4473 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4474
4475 hash_buf.digest = mymalloc (dgst_size);
4476
4477 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4478
4479 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4480
4481 uint digest_buf[64] = { 0 };
4482
4483 outfile_data_t *out_info = NULL;
4484
4485 char **out_files = NULL;
4486
4487 time_t folder_mtime = 0;
4488
4489 int out_cnt = 0;
4490
4491 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4492
4493 while (data.shutdown_inner == 0)
4494 {
4495 hc_sleep (1);
4496
4497 if (data.devices_status != STATUS_RUNNING) continue;
4498
4499 check_left--;
4500
4501 if (check_left == 0)
4502 {
4503 struct stat outfile_check_stat;
4504
4505 if (stat (outfile_dir, &outfile_check_stat) == 0)
4506 {
4507 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4508
4509 if (is_dir == 1)
4510 {
4511 if (outfile_check_stat.st_mtime > folder_mtime)
4512 {
4513 char **out_files_new = scan_directory (outfile_dir);
4514
4515 int out_cnt_new = count_dictionaries (out_files_new);
4516
4517 outfile_data_t *out_info_new = NULL;
4518
4519 if (out_cnt_new > 0)
4520 {
4521 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4522
4523 for (int i = 0; i < out_cnt_new; i++)
4524 {
4525 out_info_new[i].file_name = out_files_new[i];
4526
4527 // check if there are files that we have seen/checked before (and not changed)
4528
4529 for (int j = 0; j < out_cnt; j++)
4530 {
4531 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4532 {
4533 struct stat outfile_stat;
4534
4535 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4536 {
4537 if (outfile_stat.st_ctime == out_info[j].ctime)
4538 {
4539 out_info_new[i].ctime = out_info[j].ctime;
4540 out_info_new[i].seek = out_info[j].seek;
4541 }
4542 }
4543 }
4544 }
4545 }
4546 }
4547
4548 local_free (out_info);
4549 local_free (out_files);
4550
4551 out_files = out_files_new;
4552 out_cnt = out_cnt_new;
4553 out_info = out_info_new;
4554
4555 folder_mtime = outfile_check_stat.st_mtime;
4556 }
4557
4558 for (int j = 0; j < out_cnt; j++)
4559 {
4560 FILE *fp = fopen (out_info[j].file_name, "rb");
4561
4562 if (fp != NULL)
4563 {
4564 //hc_thread_mutex_lock (mux_display);
4565
4566 #ifdef _POSIX
4567 struct stat outfile_stat;
4568
4569 fstat (fileno (fp), &outfile_stat);
4570 #endif
4571
4572 #ifdef _WIN
4573 struct stat64 outfile_stat;
4574
4575 _fstat64 (fileno (fp), &outfile_stat);
4576 #endif
4577
4578 if (outfile_stat.st_ctime > out_info[j].ctime)
4579 {
4580 out_info[j].ctime = outfile_stat.st_ctime;
4581 out_info[j].seek = 0;
4582 }
4583
4584 fseek (fp, out_info[j].seek, SEEK_SET);
4585
4586 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4587
4588 while (!feof (fp))
4589 {
4590 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4591
4592 if (ptr == NULL) break;
4593
4594 int line_len = strlen (line_buf);
4595
4596 if (line_len <= 0) continue;
4597
4598 int iter = MAX_CUT_TRIES;
4599
4600 for (uint i = line_len - 1; i && iter; i--, line_len--)
4601 {
4602 if (line_buf[i] != separator) continue;
4603
4604 int parser_status = PARSER_OK;
4605
4606 if ((hash_mode != 2500) && (hash_mode != 6800))
4607 {
4608 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4609 }
4610
4611 uint found = 0;
4612
4613 if (parser_status == PARSER_OK)
4614 {
4615 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4616 {
4617 if (data.salts_shown[salt_pos] == 1) continue;
4618
4619 salt_t *salt_buf = &data.salts_buf[salt_pos];
4620
4621 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4622 {
4623 uint idx = salt_buf->digests_offset + digest_pos;
4624
4625 if (data.digests_shown[idx] == 1) continue;
4626
4627 uint cracked = 0;
4628
4629 if (hash_mode == 6800)
4630 {
4631 if (i == salt_buf->salt_len)
4632 {
4633 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4634 }
4635 }
4636 else if (hash_mode == 2500)
4637 {
4638 // BSSID : MAC1 : MAC2 (:plain)
4639 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4640 {
4641 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4642
4643 if (!cracked) continue;
4644
4645 // now compare MAC1 and MAC2 too, since we have this additional info
4646 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4647 char *mac2_pos = mac1_pos + 12 + 1;
4648
4649 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4650 wpa_t *wpa = &wpas[salt_pos];
4651
4652 // compare hex string(s) vs binary MAC address(es)
4653
4654 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4655 {
4656 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4657 {
4658 cracked = 0;
4659
4660 break;
4661 }
4662 }
4663
4664 // early skip ;)
4665 if (!cracked) continue;
4666
4667 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4668 {
4669 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4670 {
4671 cracked = 0;
4672
4673 break;
4674 }
4675 }
4676 }
4677 }
4678 else
4679 {
4680 char *digests_buf_ptr = (char *) data.digests_buf;
4681
4682 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4683
4684 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4685 }
4686
4687 if (cracked == 1)
4688 {
4689 found = 1;
4690
4691 data.digests_shown[idx] = 1;
4692
4693 data.digests_done++;
4694
4695 salt_buf->digests_done++;
4696
4697 if (salt_buf->digests_done == salt_buf->digests_cnt)
4698 {
4699 data.salts_shown[salt_pos] = 1;
4700
4701 data.salts_done++;
4702
4703 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4704 }
4705 }
4706 }
4707
4708 if (data.devices_status == STATUS_CRACKED) break;
4709 }
4710 }
4711
4712 if (found) break;
4713
4714 if (data.devices_status == STATUS_CRACKED) break;
4715
4716 iter--;
4717 }
4718
4719 if (data.devices_status == STATUS_CRACKED) break;
4720 }
4721
4722 myfree (line_buf);
4723
4724 out_info[j].seek = ftell (fp);
4725
4726 //hc_thread_mutex_unlock (mux_display);
4727
4728 fclose (fp);
4729 }
4730 }
4731 }
4732 }
4733
4734 check_left = outfile_check_timer;
4735 }
4736 }
4737
4738 if (esalt_size) local_free (hash_buf.esalt);
4739
4740 if (isSalted) local_free (hash_buf.salt);
4741
4742 local_free (hash_buf.digest);
4743
4744 local_free (out_info);
4745
4746 local_free (out_files);
4747
4748 p = NULL;
4749
4750 return (p);
4751 }
4752
4753 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4754 {
4755 //if (device_param->pws_cnt < device_param->kernel_power)
4756 //{
4757 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4758
4759 u8 *ptr = (u8 *) pw->i;
4760
4761 memcpy (ptr, pw_buf, pw_len);
4762
4763 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4764
4765 pw->pw_len = pw_len;
4766
4767 device_param->pws_cnt++;
4768 //}
4769 //else
4770 //{
4771 // fprintf (stderr, "BUG pw_add()!!\n");
4772 //
4773 // return;
4774 //}
4775 }
4776
4777 static void set_kernel_power_final (const u64 kernel_power_final)
4778 {
4779 if (data.quiet == 0)
4780 {
4781 clear_prompt ();
4782
4783 //log_info ("");
4784
4785 log_info ("INFO: approaching final keyspace, workload adjusted");
4786 log_info ("");
4787
4788 fprintf (stdout, "%s", PROMPT);
4789
4790 fflush (stdout);
4791 }
4792
4793 data.kernel_power_final = kernel_power_final;
4794 }
4795
4796 static u32 get_power (hc_device_param_t *device_param)
4797 {
4798 const u64 kernel_power_final = data.kernel_power_final;
4799
4800 if (kernel_power_final)
4801 {
4802 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4803
4804 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4805
4806 // work should be at least the hardware power available without any accelerator
4807
4808 const u64 work = MAX (words_left_device, device_param->hardware_power);
4809
4810 return work;
4811 }
4812
4813 return device_param->kernel_power;
4814 }
4815
4816 static uint get_work (hc_device_param_t *device_param, const u64 max)
4817 {
4818 hc_thread_mutex_lock (mux_dispatcher);
4819
4820 const u64 words_cur = data.words_cur;
4821 const u64 words_base = (data.limit == 0) ? data.words_base : MIN (data.limit, data.words_base);
4822
4823 device_param->words_off = words_cur;
4824
4825 const u64 kernel_power_all = data.kernel_power_all;
4826
4827 const u64 words_left = words_base - words_cur;
4828
4829 if (words_left < kernel_power_all)
4830 {
4831 if (data.kernel_power_final == 0)
4832 {
4833 set_kernel_power_final (words_left);
4834 }
4835 }
4836
4837 const u32 kernel_power = get_power (device_param);
4838
4839 uint work = MIN (words_left, kernel_power);
4840
4841 work = MIN (work, max);
4842
4843 data.words_cur += work;
4844
4845 hc_thread_mutex_unlock (mux_dispatcher);
4846
4847 return work;
4848 }
4849
4850 static void *thread_autotune (void *p)
4851 {
4852 hc_device_param_t *device_param = (hc_device_param_t *) p;
4853
4854 if (device_param->skipped) return NULL;
4855
4856 autotune (device_param);
4857
4858 return NULL;
4859 }
4860
4861 static void *thread_calc_stdin (void *p)
4862 {
4863 hc_device_param_t *device_param = (hc_device_param_t *) p;
4864
4865 if (device_param->skipped) return NULL;
4866
4867 char *buf = (char *) mymalloc (HCBUFSIZ);
4868
4869 const uint attack_kern = data.attack_kern;
4870
4871 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4872 {
4873 hc_thread_mutex_lock (mux_dispatcher);
4874
4875 if (feof (stdin) != 0)
4876 {
4877 hc_thread_mutex_unlock (mux_dispatcher);
4878
4879 break;
4880 }
4881
4882 uint words_cur = 0;
4883
4884 while (words_cur < device_param->kernel_power)
4885 {
4886 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4887
4888 if (line_buf == NULL) break;
4889
4890 uint line_len = in_superchop (line_buf);
4891
4892 line_len = convert_from_hex (line_buf, line_len);
4893
4894 // post-process rule engine
4895
4896 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4897 {
4898 char rule_buf_out[BLOCK_SIZE] = { 0 };
4899
4900 int rule_len_out = -1;
4901
4902 if (line_len < BLOCK_SIZE)
4903 {
4904 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4905 }
4906
4907 if (rule_len_out < 0) continue;
4908
4909 line_buf = rule_buf_out;
4910 line_len = rule_len_out;
4911 }
4912
4913 if (line_len > PW_MAX)
4914 {
4915 continue;
4916 }
4917
4918 // hmm that's always the case, or?
4919
4920 if (attack_kern == ATTACK_KERN_STRAIGHT)
4921 {
4922 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4923 {
4924 hc_thread_mutex_lock (mux_counter);
4925
4926 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4927 {
4928 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4929 }
4930
4931 hc_thread_mutex_unlock (mux_counter);
4932
4933 continue;
4934 }
4935 }
4936
4937 pw_add (device_param, (u8 *) line_buf, line_len);
4938
4939 words_cur++;
4940
4941 if (data.devices_status == STATUS_CRACKED) break;
4942 if (data.devices_status == STATUS_ABORTED) break;
4943 if (data.devices_status == STATUS_QUIT) break;
4944 if (data.devices_status == STATUS_BYPASS) break;
4945 }
4946
4947 hc_thread_mutex_unlock (mux_dispatcher);
4948
4949 if (data.devices_status == STATUS_CRACKED) break;
4950 if (data.devices_status == STATUS_ABORTED) break;
4951 if (data.devices_status == STATUS_QUIT) break;
4952 if (data.devices_status == STATUS_BYPASS) break;
4953
4954 // flush
4955
4956 const uint pws_cnt = device_param->pws_cnt;
4957
4958 if (pws_cnt)
4959 {
4960 run_copy (device_param, pws_cnt);
4961
4962 run_cracker (device_param, pws_cnt);
4963
4964 device_param->pws_cnt = 0;
4965
4966 /*
4967 still required?
4968 if (attack_kern == ATTACK_KERN_STRAIGHT)
4969 {
4970 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4971 }
4972 else if (attack_kern == ATTACK_KERN_COMBI)
4973 {
4974 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4975 }
4976 */
4977 }
4978 }
4979
4980 device_param->kernel_accel = 0;
4981 device_param->kernel_loops = 0;
4982
4983 myfree (buf);
4984
4985 return NULL;
4986 }
4987
4988 static void *thread_calc (void *p)
4989 {
4990 hc_device_param_t *device_param = (hc_device_param_t *) p;
4991
4992 if (device_param->skipped) return NULL;
4993
4994 const uint attack_mode = data.attack_mode;
4995 const uint attack_kern = data.attack_kern;
4996
4997 if (attack_mode == ATTACK_MODE_BF)
4998 {
4999 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5000 {
5001 const uint work = get_work (device_param, -1);
5002
5003 if (work == 0) break;
5004
5005 const u64 words_off = device_param->words_off;
5006 const u64 words_fin = words_off + work;
5007
5008 const uint pws_cnt = work;
5009
5010 device_param->pws_cnt = pws_cnt;
5011
5012 if (pws_cnt)
5013 {
5014 run_copy (device_param, pws_cnt);
5015
5016 run_cracker (device_param, pws_cnt);
5017
5018 device_param->pws_cnt = 0;
5019
5020 /*
5021 still required?
5022 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
5023 */
5024 }
5025
5026 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5027
5028 if (data.devices_status == STATUS_CRACKED) break;
5029 if (data.devices_status == STATUS_ABORTED) break;
5030 if (data.devices_status == STATUS_QUIT) break;
5031 if (data.devices_status == STATUS_BYPASS) break;
5032
5033 if (data.benchmark == 1) break;
5034
5035 device_param->words_done = words_fin;
5036 }
5037 }
5038 else
5039 {
5040 const uint segment_size = data.segment_size;
5041
5042 char *dictfile = data.dictfile;
5043
5044 if (attack_mode == ATTACK_MODE_COMBI)
5045 {
5046 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5047 {
5048 dictfile = data.dictfile2;
5049 }
5050 }
5051
5052 FILE *fd = fopen (dictfile, "rb");
5053
5054 if (fd == NULL)
5055 {
5056 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5057
5058 return NULL;
5059 }
5060
5061 if (attack_mode == ATTACK_MODE_COMBI)
5062 {
5063 const uint combs_mode = data.combs_mode;
5064
5065 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5066 {
5067 const char *dictfilec = data.dictfile2;
5068
5069 FILE *combs_fp = fopen (dictfilec, "rb");
5070
5071 if (combs_fp == NULL)
5072 {
5073 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5074
5075 fclose (fd);
5076
5077 return NULL;
5078 }
5079
5080 device_param->combs_fp = combs_fp;
5081 }
5082 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5083 {
5084 const char *dictfilec = data.dictfile;
5085
5086 FILE *combs_fp = fopen (dictfilec, "rb");
5087
5088 if (combs_fp == NULL)
5089 {
5090 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5091
5092 fclose (fd);
5093
5094 return NULL;
5095 }
5096
5097 device_param->combs_fp = combs_fp;
5098 }
5099 }
5100
5101 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5102
5103 wl_data->buf = (char *) mymalloc (segment_size);
5104 wl_data->avail = segment_size;
5105 wl_data->incr = segment_size;
5106 wl_data->cnt = 0;
5107 wl_data->pos = 0;
5108
5109 u64 words_cur = 0;
5110
5111 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5112 {
5113 u64 words_off = 0;
5114 u64 words_fin = 0;
5115
5116 u64 max = -1;
5117
5118 while (max)
5119 {
5120 const uint work = get_work (device_param, max);
5121
5122 if (work == 0) break;
5123
5124 max = 0;
5125
5126 words_off = device_param->words_off;
5127 words_fin = words_off + work;
5128
5129 char *line_buf;
5130 uint line_len;
5131
5132 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5133
5134 for ( ; words_cur < words_fin; words_cur++)
5135 {
5136 get_next_word (wl_data, fd, &line_buf, &line_len);
5137
5138 line_len = convert_from_hex (line_buf, line_len);
5139
5140 // post-process rule engine
5141
5142 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5143 {
5144 char rule_buf_out[BLOCK_SIZE] = { 0 };
5145
5146 int rule_len_out = -1;
5147
5148 if (line_len < BLOCK_SIZE)
5149 {
5150 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5151 }
5152
5153 if (rule_len_out < 0) continue;
5154
5155 line_buf = rule_buf_out;
5156 line_len = rule_len_out;
5157 }
5158
5159 if (attack_kern == ATTACK_KERN_STRAIGHT)
5160 {
5161 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5162 {
5163 max++;
5164
5165 hc_thread_mutex_lock (mux_counter);
5166
5167 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5168 {
5169 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5170 }
5171
5172 hc_thread_mutex_unlock (mux_counter);
5173
5174 continue;
5175 }
5176 }
5177 else if (attack_kern == ATTACK_KERN_COMBI)
5178 {
5179 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5180 // since we still need to combine the plains
5181
5182 if (line_len > data.pw_max)
5183 {
5184 max++;
5185
5186 hc_thread_mutex_lock (mux_counter);
5187
5188 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5189 {
5190 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5191 }
5192
5193 hc_thread_mutex_unlock (mux_counter);
5194
5195 continue;
5196 }
5197 }
5198
5199 pw_add (device_param, (u8 *) line_buf, line_len);
5200
5201 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5202
5203 if (data.devices_status == STATUS_CRACKED) break;
5204 if (data.devices_status == STATUS_ABORTED) break;
5205 if (data.devices_status == STATUS_QUIT) break;
5206 if (data.devices_status == STATUS_BYPASS) break;
5207 }
5208
5209 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5210
5211 if (data.devices_status == STATUS_CRACKED) break;
5212 if (data.devices_status == STATUS_ABORTED) break;
5213 if (data.devices_status == STATUS_QUIT) break;
5214 if (data.devices_status == STATUS_BYPASS) break;
5215 }
5216
5217 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5218
5219 if (data.devices_status == STATUS_CRACKED) break;
5220 if (data.devices_status == STATUS_ABORTED) break;
5221 if (data.devices_status == STATUS_QUIT) break;
5222 if (data.devices_status == STATUS_BYPASS) break;
5223
5224 //
5225 // flush
5226 //
5227
5228 const uint pws_cnt = device_param->pws_cnt;
5229
5230 if (pws_cnt)
5231 {
5232 run_copy (device_param, pws_cnt);
5233
5234 run_cracker (device_param, pws_cnt);
5235
5236 device_param->pws_cnt = 0;
5237
5238 /*
5239 still required?
5240 if (attack_kern == ATTACK_KERN_STRAIGHT)
5241 {
5242 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5243 }
5244 else if (attack_kern == ATTACK_KERN_COMBI)
5245 {
5246 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5247 }
5248 */
5249 }
5250
5251 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5252
5253 if (data.devices_status == STATUS_CRACKED) break;
5254 if (data.devices_status == STATUS_ABORTED) break;
5255 if (data.devices_status == STATUS_QUIT) break;
5256 if (data.devices_status == STATUS_BYPASS) break;
5257
5258 if (words_fin == 0) break;
5259
5260 device_param->words_done = words_fin;
5261 }
5262
5263 if (attack_mode == ATTACK_MODE_COMBI)
5264 {
5265 fclose (device_param->combs_fp);
5266 }
5267
5268 free (wl_data->buf);
5269 free (wl_data);
5270
5271 fclose (fd);
5272 }
5273
5274 device_param->kernel_accel = 0;
5275 device_param->kernel_loops = 0;
5276
5277 return NULL;
5278 }
5279
5280 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5281 {
5282 if (!device_param)
5283 {
5284 log_error ("ERROR: %s : Invalid argument", __func__);
5285
5286 exit (-1);
5287 }
5288
5289 salt_t *salt_buf = &data.salts_buf[salt_pos];
5290
5291 device_param->kernel_params_buf32[27] = salt_pos;
5292 device_param->kernel_params_buf32[30] = 1;
5293 device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
5294 device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
5295 device_param->kernel_params_buf32[33] = 0;
5296 device_param->kernel_params_buf32[34] = 1;
5297
5298 char *dictfile_old = data.dictfile;
5299
5300 const char *weak_hash_check = "weak-hash-check";
5301
5302 data.dictfile = (char *) weak_hash_check;
5303
5304 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5305
5306 data.kernel_rules_buf[0].cmds[0] = 0;
5307
5308 /**
5309 * run the kernel
5310 */
5311
5312 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5313 {
5314 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5315 }
5316 else
5317 {
5318 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5319
5320 uint loop_step = 16;
5321
5322 const uint iter = salt_buf->salt_iter;
5323
5324 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5325 {
5326 uint loop_left = iter - loop_pos;
5327
5328 loop_left = MIN (loop_left, loop_step);
5329
5330 device_param->kernel_params_buf32[28] = loop_pos;
5331 device_param->kernel_params_buf32[29] = loop_left;
5332
5333 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5334 }
5335
5336 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5337 }
5338
5339 /**
5340 * result
5341 */
5342
5343 check_cracked (device_param, salt_pos);
5344
5345 /**
5346 * cleanup
5347 */
5348
5349 device_param->kernel_params_buf32[27] = 0;
5350 device_param->kernel_params_buf32[28] = 0;
5351 device_param->kernel_params_buf32[29] = 0;
5352 device_param->kernel_params_buf32[30] = 0;
5353 device_param->kernel_params_buf32[31] = 0;
5354 device_param->kernel_params_buf32[32] = 0;
5355 device_param->kernel_params_buf32[33] = 0;
5356 device_param->kernel_params_buf32[34] = 0;
5357
5358 data.dictfile = dictfile_old;
5359
5360 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5361 }
5362
5363 // hlfmt hashcat
5364
5365 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5366 {
5367 if (data.username == 0)
5368 {
5369 *hashbuf_pos = line_buf;
5370 *hashbuf_len = line_len;
5371 }
5372 else
5373 {
5374 char *pos = line_buf;
5375 int len = line_len;
5376
5377 for (int i = 0; i < line_len; i++, pos++, len--)
5378 {
5379 if (line_buf[i] == data.separator)
5380 {
5381 pos++;
5382
5383 len--;
5384
5385 break;
5386 }
5387 }
5388
5389 *hashbuf_pos = pos;
5390 *hashbuf_len = len;
5391 }
5392 }
5393
5394 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5395 {
5396 char *pos = NULL;
5397 int len = 0;
5398
5399 int sep_cnt = 0;
5400
5401 for (int i = 0; i < line_len; i++)
5402 {
5403 if (line_buf[i] == data.separator)
5404 {
5405 sep_cnt++;
5406
5407 continue;
5408 }
5409
5410 if (sep_cnt == 0)
5411 {
5412 if (pos == NULL) pos = line_buf + i;
5413
5414 len++;
5415 }
5416 }
5417
5418 *userbuf_pos = pos;
5419 *userbuf_len = len;
5420 }
5421
5422 // hlfmt pwdump
5423
5424 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5425 {
5426 int sep_cnt = 0;
5427
5428 int sep2_len = 0;
5429 int sep3_len = 0;
5430
5431 for (int i = 0; i < line_len; i++)
5432 {
5433 if (line_buf[i] == ':')
5434 {
5435 sep_cnt++;
5436
5437 continue;
5438 }
5439
5440 if (sep_cnt == 2) sep2_len++;
5441 if (sep_cnt == 3) sep3_len++;
5442 }
5443
5444 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5445
5446 return 0;
5447 }
5448
5449 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5450 {
5451 char *pos = NULL;
5452 int len = 0;
5453
5454 int sep_cnt = 0;
5455
5456 for (int i = 0; i < line_len; i++)
5457 {
5458 if (line_buf[i] == ':')
5459 {
5460 sep_cnt++;
5461
5462 continue;
5463 }
5464
5465 if (data.hash_mode == 1000)
5466 {
5467 if (sep_cnt == 3)
5468 {
5469 if (pos == NULL) pos = line_buf + i;
5470
5471 len++;
5472 }
5473 }
5474 else if (data.hash_mode == 3000)
5475 {
5476 if (sep_cnt == 2)
5477 {
5478 if (pos == NULL) pos = line_buf + i;
5479
5480 len++;
5481 }
5482 }
5483 }
5484
5485 *hashbuf_pos = pos;
5486 *hashbuf_len = len;
5487 }
5488
5489 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5490 {
5491 char *pos = NULL;
5492 int len = 0;
5493
5494 int sep_cnt = 0;
5495
5496 for (int i = 0; i < line_len; i++)
5497 {
5498 if (line_buf[i] == ':')
5499 {
5500 sep_cnt++;
5501
5502 continue;
5503 }
5504
5505 if (sep_cnt == 0)
5506 {
5507 if (pos == NULL) pos = line_buf + i;
5508
5509 len++;
5510 }
5511 }
5512
5513 *userbuf_pos = pos;
5514 *userbuf_len = len;
5515 }
5516
5517 // hlfmt passwd
5518
5519 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5520 {
5521 int sep_cnt = 0;
5522
5523 char sep5_first = 0;
5524 char sep6_first = 0;
5525
5526 for (int i = 0; i < line_len; i++)
5527 {
5528 if (line_buf[i] == ':')
5529 {
5530 sep_cnt++;
5531
5532 continue;
5533 }
5534
5535 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5536 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5537 }
5538
5539 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5540
5541 return 0;
5542 }
5543
5544 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5545 {
5546 char *pos = NULL;
5547 int len = 0;
5548
5549 int sep_cnt = 0;
5550
5551 for (int i = 0; i < line_len; i++)
5552 {
5553 if (line_buf[i] == ':')
5554 {
5555 sep_cnt++;
5556
5557 continue;
5558 }
5559
5560 if (sep_cnt == 1)
5561 {
5562 if (pos == NULL) pos = line_buf + i;
5563
5564 len++;
5565 }
5566 }
5567
5568 *hashbuf_pos = pos;
5569 *hashbuf_len = len;
5570 }
5571
5572 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5573 {
5574 char *pos = NULL;
5575 int len = 0;
5576
5577 int sep_cnt = 0;
5578
5579 for (int i = 0; i < line_len; i++)
5580 {
5581 if (line_buf[i] == ':')
5582 {
5583 sep_cnt++;
5584
5585 continue;
5586 }
5587
5588 if (sep_cnt == 0)
5589 {
5590 if (pos == NULL) pos = line_buf + i;
5591
5592 len++;
5593 }
5594 }
5595
5596 *userbuf_pos = pos;
5597 *userbuf_len = len;
5598 }
5599
5600 // hlfmt shadow
5601
5602 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5603 {
5604 int sep_cnt = 0;
5605
5606 for (int i = 0; i < line_len; i++)
5607 {
5608 if (line_buf[i] == ':') sep_cnt++;
5609 }
5610
5611 if (sep_cnt == 8) return 1;
5612
5613 return 0;
5614 }
5615
5616 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5617 {
5618 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5619 }
5620
5621 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5622 {
5623 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5624 }
5625
5626 // hlfmt main
5627
5628 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5629 {
5630 switch (hashfile_format)
5631 {
5632 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5633 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5634 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5635 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5636 }
5637 }
5638
5639 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5640 {
5641 switch (hashfile_format)
5642 {
5643 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5644 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5645 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5646 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5647 }
5648 }
5649
5650 char *strhlfmt (const uint hashfile_format)
5651 {
5652 switch (hashfile_format)
5653 {
5654 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5655 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5656 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5657 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5658 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5659 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5660 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5661 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5662 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5663 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5664 }
5665
5666 return ((char *) "Unknown");
5667 }
5668
5669 static uint hlfmt_detect (FILE *fp, uint max_check)
5670 {
5671 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5672
5673 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5674 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5675
5676 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5677
5678 uint num_check = 0;
5679
5680 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5681
5682 while (!feof (fp))
5683 {
5684 int line_len = fgetl (fp, line_buf);
5685
5686 if (line_len == 0) continue;
5687
5688 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5689 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5690 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5691
5692 if (num_check == max_check) break;
5693
5694 num_check++;
5695 }
5696
5697 myfree (line_buf);
5698
5699 uint hashlist_format = HLFMT_HASHCAT;
5700
5701 for (int i = 1; i < HLFMTS_CNT; i++)
5702 {
5703 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5704
5705 hashlist_format = i;
5706 }
5707
5708 free (formats_cnt);
5709
5710 return hashlist_format;
5711 }
5712
5713 /**
5714 * some further helper function
5715 */
5716
5717 // wrapper around mymalloc for ADL
5718
5719 #if defined(HAVE_HWMON)
5720 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5721 {
5722 return mymalloc (iSize);
5723 }
5724 #endif
5725
5726 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)
5727 {
5728 u64 collisions = 0;
5729
5730 const uint dgst_pos0 = data.dgst_pos0;
5731 const uint dgst_pos1 = data.dgst_pos1;
5732 const uint dgst_pos2 = data.dgst_pos2;
5733 const uint dgst_pos3 = data.dgst_pos3;
5734
5735 memset (bitmap_a, 0, bitmap_size);
5736 memset (bitmap_b, 0, bitmap_size);
5737 memset (bitmap_c, 0, bitmap_size);
5738 memset (bitmap_d, 0, bitmap_size);
5739
5740 for (uint i = 0; i < digests_cnt; i++)
5741 {
5742 uint *digest_ptr = (uint *) digests_buf_ptr;
5743
5744 digests_buf_ptr += dgst_size;
5745
5746 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5747 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5748 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5749 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5750
5751 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5752 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5753 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5754 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5755
5756 if (bitmap_a[idx0] & val0) collisions++;
5757 if (bitmap_b[idx1] & val1) collisions++;
5758 if (bitmap_c[idx2] & val2) collisions++;
5759 if (bitmap_d[idx3] & val3) collisions++;
5760
5761 bitmap_a[idx0] |= val0;
5762 bitmap_b[idx1] |= val1;
5763 bitmap_c[idx2] |= val2;
5764 bitmap_d[idx3] |= val3;
5765
5766 if (collisions >= collisions_max) return 0x7fffffff;
5767 }
5768
5769 return collisions;
5770 }
5771
5772 /**
5773 * main
5774 */
5775
5776 #ifdef WIN
5777 void SetConsoleWindowSize (const int x)
5778 {
5779 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5780
5781 if (h == INVALID_HANDLE_VALUE) return;
5782
5783 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5784
5785 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5786
5787 SMALL_RECT *sr = &bufferInfo.srWindow;
5788
5789 sr->Right = MAX (sr->Right, x - 1);
5790
5791 COORD co;
5792
5793 co.X = sr->Right + 1;
5794 co.Y = 9999;
5795
5796 if (!SetConsoleScreenBufferSize (h, co)) return;
5797
5798 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5799 }
5800 #endif
5801
5802 int main (int argc, char **argv)
5803 {
5804 #ifdef WIN
5805 SetConsoleWindowSize (132);
5806 #endif
5807
5808 /**
5809 * To help users a bit
5810 */
5811
5812 char *compute = getenv ("COMPUTE");
5813
5814 if (compute)
5815 {
5816 static char display[100];
5817
5818 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5819
5820 putenv (display);
5821 }
5822 else
5823 {
5824 if (getenv ("DISPLAY") == NULL)
5825 putenv ((char *) "DISPLAY=:0");
5826 }
5827
5828 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5829 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5830
5831 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5832 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5833
5834 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5835 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5836
5837 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5838 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5839
5840 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5841 putenv ((char *) "POCL_KERNEL_CACHE=0");
5842
5843 umask (077);
5844
5845 /**
5846 * Real init
5847 */
5848
5849 memset (&data, 0, sizeof (hc_global_data_t));
5850
5851 time_t proc_start;
5852
5853 time (&proc_start);
5854
5855 data.proc_start = proc_start;
5856
5857 int myargc = argc;
5858 char **myargv = argv;
5859
5860 hc_thread_mutex_init (mux_dispatcher);
5861 hc_thread_mutex_init (mux_counter);
5862 hc_thread_mutex_init (mux_display);
5863 hc_thread_mutex_init (mux_adl);
5864
5865 /**
5866 * commandline parameters
5867 */
5868
5869 uint usage = USAGE;
5870 uint version = VERSION;
5871 uint quiet = QUIET;
5872 uint benchmark = BENCHMARK;
5873 uint stdout_flag = STDOUT_FLAG;
5874 uint show = SHOW;
5875 uint left = LEFT;
5876 uint username = USERNAME;
5877 uint remove = REMOVE;
5878 uint remove_timer = REMOVE_TIMER;
5879 u64 skip = SKIP;
5880 u64 limit = LIMIT;
5881 uint keyspace = KEYSPACE;
5882 uint potfile_disable = POTFILE_DISABLE;
5883 char *potfile_path = NULL;
5884 uint debug_mode = DEBUG_MODE;
5885 char *debug_file = NULL;
5886 char *induction_dir = NULL;
5887 char *outfile_check_dir = NULL;
5888 uint force = FORCE;
5889 uint runtime = RUNTIME;
5890 uint hash_mode = HASH_MODE;
5891 uint attack_mode = ATTACK_MODE;
5892 uint markov_disable = MARKOV_DISABLE;
5893 uint markov_classic = MARKOV_CLASSIC;
5894 uint markov_threshold = MARKOV_THRESHOLD;
5895 char *markov_hcstat = NULL;
5896 char *outfile = NULL;
5897 uint outfile_format = OUTFILE_FORMAT;
5898 uint outfile_autohex = OUTFILE_AUTOHEX;
5899 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5900 uint restore = RESTORE;
5901 uint restore_timer = RESTORE_TIMER;
5902 uint restore_disable = RESTORE_DISABLE;
5903 uint status = STATUS;
5904 uint status_timer = STATUS_TIMER;
5905 uint machine_readable = MACHINE_READABLE;
5906 uint loopback = LOOPBACK;
5907 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5908 char *session = NULL;
5909 uint hex_charset = HEX_CHARSET;
5910 uint hex_salt = HEX_SALT;
5911 uint hex_wordlist = HEX_WORDLIST;
5912 uint rp_gen = RP_GEN;
5913 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5914 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5915 uint rp_gen_seed = RP_GEN_SEED;
5916 char *rule_buf_l = (char *) RULE_BUF_L;
5917 char *rule_buf_r = (char *) RULE_BUF_R;
5918 uint increment = INCREMENT;
5919 uint increment_min = INCREMENT_MIN;
5920 uint increment_max = INCREMENT_MAX;
5921 char *cpu_affinity = NULL;
5922 OCL_PTR *ocl = NULL;
5923 char *opencl_devices = NULL;
5924 char *opencl_platforms = NULL;
5925 char *opencl_device_types = NULL;
5926 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5927 char *truecrypt_keyfiles = NULL;
5928 char *veracrypt_keyfiles = NULL;
5929 uint veracrypt_pim = 0;
5930 uint workload_profile = WORKLOAD_PROFILE;
5931 uint kernel_accel = KERNEL_ACCEL;
5932 uint kernel_loops = KERNEL_LOOPS;
5933 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
5934 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5935 #ifdef HAVE_HWMON
5936 uint gpu_temp_abort = GPU_TEMP_ABORT;
5937 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5938 uint powertune_enable = POWERTUNE_ENABLE;
5939 #endif
5940 uint logfile_disable = LOGFILE_DISABLE;
5941 uint segment_size = SEGMENT_SIZE;
5942 uint scrypt_tmto = SCRYPT_TMTO;
5943 char separator = SEPARATOR;
5944 uint bitmap_min = BITMAP_MIN;
5945 uint bitmap_max = BITMAP_MAX;
5946 char *custom_charset_1 = NULL;
5947 char *custom_charset_2 = NULL;
5948 char *custom_charset_3 = NULL;
5949 char *custom_charset_4 = NULL;
5950
5951 #define IDX_HELP 'h'
5952 #define IDX_VERSION 'V'
5953 #define IDX_VERSION_LOWER 'v'
5954 #define IDX_QUIET 0xff02
5955 #define IDX_SHOW 0xff03
5956 #define IDX_LEFT 0xff04
5957 #define IDX_REMOVE 0xff05
5958 #define IDX_REMOVE_TIMER 0xff37
5959 #define IDX_SKIP 's'
5960 #define IDX_LIMIT 'l'
5961 #define IDX_KEYSPACE 0xff35
5962 #define IDX_POTFILE_DISABLE 0xff06
5963 #define IDX_POTFILE_PATH 0xffe0
5964 #define IDX_DEBUG_MODE 0xff43
5965 #define IDX_DEBUG_FILE 0xff44
5966 #define IDX_INDUCTION_DIR 0xff46
5967 #define IDX_OUTFILE_CHECK_DIR 0xff47
5968 #define IDX_USERNAME 0xff07
5969 #define IDX_FORCE 0xff08
5970 #define IDX_RUNTIME 0xff09
5971 #define IDX_BENCHMARK 'b'
5972 #define IDX_STDOUT_FLAG 0xff77
5973 #define IDX_HASH_MODE 'm'
5974 #define IDX_ATTACK_MODE 'a'
5975 #define IDX_RP_FILE 'r'
5976 #define IDX_RP_GEN 'g'
5977 #define IDX_RP_GEN_FUNC_MIN 0xff10
5978 #define IDX_RP_GEN_FUNC_MAX 0xff11
5979 #define IDX_RP_GEN_SEED 0xff34
5980 #define IDX_RULE_BUF_L 'j'
5981 #define IDX_RULE_BUF_R 'k'
5982 #define IDX_INCREMENT 'i'
5983 #define IDX_INCREMENT_MIN 0xff12
5984 #define IDX_INCREMENT_MAX 0xff13
5985 #define IDX_OUTFILE 'o'
5986 #define IDX_OUTFILE_FORMAT 0xff14
5987 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5988 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5989 #define IDX_RESTORE 0xff15
5990 #define IDX_RESTORE_DISABLE 0xff27
5991 #define IDX_STATUS 0xff17
5992 #define IDX_STATUS_TIMER 0xff18
5993 #define IDX_MACHINE_READABLE 0xff50
5994 #define IDX_LOOPBACK 0xff38
5995 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5996 #define IDX_SESSION 0xff19
5997 #define IDX_HEX_CHARSET 0xff20
5998 #define IDX_HEX_SALT 0xff21
5999 #define IDX_HEX_WORDLIST 0xff40
6000 #define IDX_MARKOV_DISABLE 0xff22
6001 #define IDX_MARKOV_CLASSIC 0xff23
6002 #define IDX_MARKOV_THRESHOLD 't'
6003 #define IDX_MARKOV_HCSTAT 0xff24
6004 #define IDX_CPU_AFFINITY 0xff25
6005 #define IDX_OPENCL_DEVICES 'd'
6006 #define IDX_OPENCL_PLATFORMS 0xff72
6007 #define IDX_OPENCL_DEVICE_TYPES 'D'
6008 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
6009 #define IDX_WORKLOAD_PROFILE 'w'
6010 #define IDX_KERNEL_ACCEL 'n'
6011 #define IDX_KERNEL_LOOPS 'u'
6012 #define IDX_NVIDIA_SPIN_DAMP 0xff79
6013 #define IDX_GPU_TEMP_DISABLE 0xff29
6014 #define IDX_GPU_TEMP_ABORT 0xff30
6015 #define IDX_GPU_TEMP_RETAIN 0xff31
6016 #define IDX_POWERTUNE_ENABLE 0xff41
6017 #define IDX_LOGFILE_DISABLE 0xff51
6018 #define IDX_TRUECRYPT_KEYFILES 0xff52
6019 #define IDX_VERACRYPT_KEYFILES 0xff53
6020 #define IDX_VERACRYPT_PIM 0xff54
6021 #define IDX_SCRYPT_TMTO 0xff61
6022 #define IDX_SEGMENT_SIZE 'c'
6023 #define IDX_SEPARATOR 'p'
6024 #define IDX_BITMAP_MIN 0xff70
6025 #define IDX_BITMAP_MAX 0xff71
6026 #define IDX_CUSTOM_CHARSET_1 '1'
6027 #define IDX_CUSTOM_CHARSET_2 '2'
6028 #define IDX_CUSTOM_CHARSET_3 '3'
6029 #define IDX_CUSTOM_CHARSET_4 '4'
6030
6031 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
6032
6033 struct option long_options[] =
6034 {
6035 {"help", no_argument, 0, IDX_HELP},
6036 {"version", no_argument, 0, IDX_VERSION},
6037 {"quiet", no_argument, 0, IDX_QUIET},
6038 {"show", no_argument, 0, IDX_SHOW},
6039 {"left", no_argument, 0, IDX_LEFT},
6040 {"username", no_argument, 0, IDX_USERNAME},
6041 {"remove", no_argument, 0, IDX_REMOVE},
6042 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
6043 {"skip", required_argument, 0, IDX_SKIP},
6044 {"limit", required_argument, 0, IDX_LIMIT},
6045 {"keyspace", no_argument, 0, IDX_KEYSPACE},
6046 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
6047 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
6048 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
6049 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
6050 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
6051 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6052 {"force", no_argument, 0, IDX_FORCE},
6053 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6054 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
6055 {"restore", no_argument, 0, IDX_RESTORE},
6056 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6057 {"status", no_argument, 0, IDX_STATUS},
6058 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6059 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
6060 {"loopback", no_argument, 0, IDX_LOOPBACK},
6061 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6062 {"session", required_argument, 0, IDX_SESSION},
6063 {"runtime", required_argument, 0, IDX_RUNTIME},
6064 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6065 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6066 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6067 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
6068 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6069 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6070 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6071 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6072 {"rules-file", required_argument, 0, IDX_RP_FILE},
6073 {"outfile", required_argument, 0, IDX_OUTFILE},
6074 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6075 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6076 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6077 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6078 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6079 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6080 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6081 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6082 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6083 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6084 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6085 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
6086 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
6087 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6088 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6089 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6090 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6091 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6092 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6093 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6094 #ifdef HAVE_HWMON
6095 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6096 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6097 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6098 #endif // HAVE_HWMON
6099 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6100 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6101 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6102 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6103 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6104 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6105 {"seperator", required_argument, 0, IDX_SEPARATOR},
6106 {"separator", required_argument, 0, IDX_SEPARATOR},
6107 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6108 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6109 {"increment", no_argument, 0, IDX_INCREMENT},
6110 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6111 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6112 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6113 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6114 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6115 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6116 {0, 0, 0, 0}
6117 };
6118
6119 uint rp_files_cnt = 0;
6120
6121 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6122
6123 int option_index = 0;
6124 int c = -1;
6125
6126 optind = 1;
6127 optopt = 0;
6128
6129 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6130 {
6131 switch (c)
6132 {
6133 case IDX_HELP: usage = 1; break;
6134 case IDX_VERSION:
6135 case IDX_VERSION_LOWER: version = 1; break;
6136 case IDX_RESTORE: restore = 1; break;
6137 case IDX_SESSION: session = optarg; break;
6138 case IDX_SHOW: show = 1; break;
6139 case IDX_LEFT: left = 1; break;
6140 case '?': return (-1);
6141 }
6142 }
6143
6144 if (optopt != 0)
6145 {
6146 log_error ("ERROR: Invalid argument specified");
6147
6148 return (-1);
6149 }
6150
6151 /**
6152 * exit functions
6153 */
6154
6155 if (version)
6156 {
6157 log_info ("%s", VERSION_TAG);
6158
6159 return (0);
6160 }
6161
6162 if (usage)
6163 {
6164 usage_big_print (PROGNAME);
6165
6166 return (0);
6167 }
6168
6169 /**
6170 * session needs to be set, always!
6171 */
6172
6173 if (session == NULL) session = (char *) PROGNAME;
6174
6175 /**
6176 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6177 */
6178
6179 char *exec_path = get_exec_path ();
6180
6181
6182 #if defined(LINUX) || defined(__APPLE__) || defined(__FreeBSD__)
6183
6184 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6185 char *resolved_exec_path = realpath (exec_path, NULL);
6186
6187 if (resolved_install_folder == NULL)
6188 {
6189 log_error ("ERROR: %s: %s", resolved_install_folder, strerror (errno));
6190
6191 return (-1);
6192 }
6193
6194 if (resolved_exec_path == NULL)
6195 {
6196 log_error ("ERROR: %s: %s", resolved_exec_path, strerror (errno));
6197
6198 return (-1);
6199 }
6200
6201 char *install_dir = get_install_dir (resolved_exec_path);
6202 char *profile_dir = NULL;
6203 char *session_dir = NULL;
6204 char *shared_dir = NULL;
6205
6206 if (strcmp (install_dir, resolved_install_folder) == 0)
6207 {
6208 struct passwd *pw = getpwuid (getuid ());
6209
6210 const char *homedir = pw->pw_dir;
6211
6212 profile_dir = get_profile_dir (homedir);
6213 session_dir = get_session_dir (profile_dir);
6214 shared_dir = strdup (SHARED_FOLDER);
6215
6216 mkdir (profile_dir, 0700);
6217 mkdir (session_dir, 0700);
6218 }
6219 else
6220 {
6221 profile_dir = install_dir;
6222 session_dir = install_dir;
6223 shared_dir = install_dir;
6224 }
6225
6226 myfree (resolved_install_folder);
6227 myfree (resolved_exec_path);
6228
6229 #else
6230
6231 char *install_dir = get_install_dir (exec_path);
6232 char *profile_dir = install_dir;
6233 char *session_dir = install_dir;
6234 char *shared_dir = install_dir;
6235
6236 #endif
6237
6238 data.install_dir = install_dir;
6239 data.profile_dir = profile_dir;
6240 data.session_dir = session_dir;
6241 data.shared_dir = shared_dir;
6242
6243 myfree (exec_path);
6244
6245 /**
6246 * kernel cache, we need to make sure folder exist
6247 */
6248
6249 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6250
6251 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6252
6253 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6254
6255 mkdir (kernels_folder, 0700);
6256
6257 myfree (kernels_folder);
6258
6259 /**
6260 * session
6261 */
6262
6263 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6264
6265 data.session = session;
6266
6267 char *eff_restore_file = (char *) mymalloc (session_size);
6268 char *new_restore_file = (char *) mymalloc (session_size);
6269
6270 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6271 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6272
6273 data.eff_restore_file = eff_restore_file;
6274 data.new_restore_file = new_restore_file;
6275
6276 if (((show == 1) || (left == 1)) && (restore == 1))
6277 {
6278 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6279 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6280
6281 return (-1);
6282 }
6283
6284 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6285 if ((show == 1) || (left == 1))
6286 {
6287 restore_disable = 1;
6288
6289 restore = 0;
6290 }
6291
6292 data.restore_disable = restore_disable;
6293
6294 restore_data_t *rd = init_restore (argc, argv);
6295
6296 data.rd = rd;
6297
6298 /**
6299 * restore file
6300 */
6301
6302 if (restore == 1)
6303 {
6304 read_restore (eff_restore_file, rd);
6305
6306 if (rd->version_bin < RESTORE_MIN)
6307 {
6308 log_error ("ERROR: Incompatible restore-file version");
6309
6310 return (-1);
6311 }
6312
6313 myargc = rd->argc;
6314 myargv = rd->argv;
6315
6316 #ifdef _POSIX
6317 rd->pid = getpid ();
6318 #elif _WIN
6319 rd->pid = GetCurrentProcessId ();
6320 #endif
6321 }
6322
6323 uint hash_mode_chgd = 0;
6324 uint runtime_chgd = 0;
6325 uint kernel_loops_chgd = 0;
6326 uint kernel_accel_chgd = 0;
6327 uint nvidia_spin_damp_chgd = 0;
6328 uint attack_mode_chgd = 0;
6329 uint outfile_format_chgd = 0;
6330 uint rp_gen_seed_chgd = 0;
6331 uint remove_timer_chgd = 0;
6332 uint increment_min_chgd = 0;
6333 uint increment_max_chgd = 0;
6334 uint workload_profile_chgd = 0;
6335 uint opencl_vector_width_chgd = 0;
6336
6337 optind = 1;
6338 optopt = 0;
6339 option_index = 0;
6340
6341 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6342 {
6343 switch (c)
6344 {
6345 //case IDX_HELP: usage = 1; break;
6346 //case IDX_VERSION: version = 1; break;
6347 //case IDX_RESTORE: restore = 1; break;
6348 case IDX_QUIET: quiet = 1; break;
6349 //case IDX_SHOW: show = 1; break;
6350 case IDX_SHOW: break;
6351 //case IDX_LEFT: left = 1; break;
6352 case IDX_LEFT: break;
6353 case IDX_USERNAME: username = 1; break;
6354 case IDX_REMOVE: remove = 1; break;
6355 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6356 remove_timer_chgd = 1; break;
6357 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6358 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6359 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6360 case IDX_DEBUG_FILE: debug_file = optarg; break;
6361 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6362 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6363 case IDX_FORCE: force = 1; break;
6364 case IDX_SKIP: skip = atoll (optarg); break;
6365 case IDX_LIMIT: limit = atoll (optarg); break;
6366 case IDX_KEYSPACE: keyspace = 1; break;
6367 case IDX_BENCHMARK: benchmark = 1; break;
6368 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6369 case IDX_RESTORE: break;
6370 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6371 case IDX_STATUS: status = 1; break;
6372 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6373 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6374 case IDX_LOOPBACK: loopback = 1; break;
6375 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6376 //case IDX_SESSION: session = optarg; break;
6377 case IDX_SESSION: break;
6378 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6379 hash_mode_chgd = 1; break;
6380 case IDX_RUNTIME: runtime = atoi (optarg);
6381 runtime_chgd = 1; break;
6382 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6383 attack_mode_chgd = 1; break;
6384 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6385 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6386 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6387 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6388 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6389 rp_gen_seed_chgd = 1; break;
6390 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6391 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6392 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6393 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6394 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6395 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6396 case IDX_OUTFILE: outfile = optarg; break;
6397 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6398 outfile_format_chgd = 1; break;
6399 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6400 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6401 case IDX_HEX_CHARSET: hex_charset = 1; break;
6402 case IDX_HEX_SALT: hex_salt = 1; break;
6403 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6404 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6405 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6406 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6407 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6408 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6409 opencl_vector_width_chgd = 1; break;
6410 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6411 workload_profile_chgd = 1; break;
6412 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6413 kernel_accel_chgd = 1; break;
6414 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6415 kernel_loops_chgd = 1; break;
6416 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6417 nvidia_spin_damp_chgd = 1; break;
6418 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6419 #ifdef HAVE_HWMON
6420 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6421 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6422 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6423 #endif // HAVE_HWMON
6424 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6425 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6426 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6427 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6428 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6429 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6430 case IDX_SEPARATOR: separator = optarg[0]; break;
6431 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6432 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6433 case IDX_INCREMENT: increment = 1; break;
6434 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6435 increment_min_chgd = 1; break;
6436 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6437 increment_max_chgd = 1; break;
6438 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6439 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6440 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6441 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6442
6443 default:
6444 log_error ("ERROR: Invalid argument specified");
6445 return (-1);
6446 }
6447 }
6448
6449 if (optopt != 0)
6450 {
6451 log_error ("ERROR: Invalid argument specified");
6452
6453 return (-1);
6454 }
6455
6456 /**
6457 * Inform user things getting started,
6458 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6459 * - we do not need to check algorithm_pos
6460 */
6461
6462 if (quiet == 0)
6463 {
6464 if (benchmark == 1)
6465 {
6466 if (machine_readable == 0)
6467 {
6468 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6469 log_info ("");
6470 }
6471 else
6472 {
6473 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6474 }
6475 }
6476 else if (restore == 1)
6477 {
6478 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6479 log_info ("");
6480 }
6481 else if (stdout_flag == 1)
6482 {
6483 // do nothing
6484 }
6485 else if (keyspace == 1)
6486 {
6487 // do nothing
6488 }
6489 else
6490 {
6491 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6492 log_info ("");
6493 }
6494 }
6495
6496 /**
6497 * sanity check
6498 */
6499
6500 if (attack_mode > 7)
6501 {
6502 log_error ("ERROR: Invalid attack-mode specified");
6503
6504 return (-1);
6505 }
6506
6507 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6508 {
6509 log_error ("ERROR: Invalid runtime specified");
6510
6511 return (-1);
6512 }
6513
6514 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6515 {
6516 log_error ("ERROR: Invalid hash-type specified");
6517
6518 return (-1);
6519 }
6520
6521 // renamed hash modes
6522
6523 if (hash_mode_chgd)
6524 {
6525 int n = -1;
6526
6527 switch (hash_mode)
6528 {
6529 case 123: n = 124;
6530 break;
6531 }
6532
6533 if (n >= 0)
6534 {
6535 log_error ("Old -m specified, use -m %d instead", n);
6536
6537 return (-1);
6538 }
6539 }
6540
6541 if (username == 1)
6542 {
6543 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6544 {
6545 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6546
6547 return (-1);
6548 }
6549 }
6550
6551 if (outfile_format > 16)
6552 {
6553 log_error ("ERROR: Invalid outfile-format specified");
6554
6555 return (-1);
6556 }
6557
6558 if (left == 1)
6559 {
6560 if (outfile_format_chgd == 1)
6561 {
6562 if (outfile_format > 1)
6563 {
6564 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6565
6566 return (-1);
6567 }
6568 }
6569 else
6570 {
6571 outfile_format = OUTFILE_FMT_HASH;
6572 }
6573 }
6574
6575 if (show == 1)
6576 {
6577 if (outfile_format_chgd == 1)
6578 {
6579 if ((outfile_format > 7) && (outfile_format < 16))
6580 {
6581 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6582
6583 return (-1);
6584 }
6585 }
6586 }
6587
6588 if (increment_min < INCREMENT_MIN)
6589 {
6590 log_error ("ERROR: Invalid increment-min specified");
6591
6592 return (-1);
6593 }
6594
6595 if (increment_max > INCREMENT_MAX)
6596 {
6597 log_error ("ERROR: Invalid increment-max specified");
6598
6599 return (-1);
6600 }
6601
6602 if (increment_min > increment_max)
6603 {
6604 log_error ("ERROR: Invalid increment-min specified");
6605
6606 return (-1);
6607 }
6608
6609 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6610 {
6611 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6612
6613 return (-1);
6614 }
6615
6616 if ((increment == 0) && (increment_min_chgd == 1))
6617 {
6618 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6619
6620 return (-1);
6621 }
6622
6623 if ((increment == 0) && (increment_max_chgd == 1))
6624 {
6625 log_error ("ERROR: Increment-max is only supported combined with increment switch");
6626
6627 return (-1);
6628 }
6629
6630 if (rp_files_cnt && rp_gen)
6631 {
6632 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6633
6634 return (-1);
6635 }
6636
6637 if (rp_files_cnt || rp_gen)
6638 {
6639 if (attack_mode != ATTACK_MODE_STRAIGHT)
6640 {
6641 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6642
6643 return (-1);
6644 }
6645 }
6646
6647 if (rp_gen_func_min > rp_gen_func_max)
6648 {
6649 log_error ("ERROR: Invalid rp-gen-func-min specified");
6650
6651 return (-1);
6652 }
6653
6654 if (kernel_accel_chgd == 1)
6655 {
6656 if (force == 0)
6657 {
6658 log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6659 log_info ("Please consider using the -w option instead");
6660 log_info ("You can use --force to override this but do not post error reports if you do so");
6661 log_info ("");
6662
6663 return (-1);
6664 }
6665
6666 if (kernel_accel < 1)
6667 {
6668 log_error ("ERROR: Invalid kernel-accel specified");
6669
6670 return (-1);
6671 }
6672
6673 if (kernel_accel > 1024)
6674 {
6675 log_error ("ERROR: Invalid kernel-accel specified");
6676
6677 return (-1);
6678 }
6679 }
6680
6681 if (kernel_loops_chgd == 1)
6682 {
6683 if (force == 0)
6684 {
6685 log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
6686 log_info ("Please consider using the -w option instead");
6687 log_info ("You can use --force to override this but do not post error reports if you do so");
6688 log_info ("");
6689
6690 return (-1);
6691 }
6692
6693 if (kernel_loops < 1)
6694 {
6695 log_error ("ERROR: Invalid kernel-loops specified");
6696
6697 return (-1);
6698 }
6699
6700 if (kernel_loops > 1024)
6701 {
6702 log_error ("ERROR: Invalid kernel-loops specified");
6703
6704 return (-1);
6705 }
6706 }
6707
6708 if ((workload_profile < 1) || (workload_profile > 4))
6709 {
6710 log_error ("ERROR: workload-profile %i not available", workload_profile);
6711
6712 return (-1);
6713 }
6714
6715 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6716 {
6717 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6718
6719 return (-1);
6720 }
6721
6722 if (show == 1 || left == 1)
6723 {
6724 attack_mode = ATTACK_MODE_NONE;
6725
6726 if (remove == 1)
6727 {
6728 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6729
6730 return (-1);
6731 }
6732
6733 if (potfile_disable == 1)
6734 {
6735 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6736
6737 return (-1);
6738 }
6739 }
6740
6741 uint attack_kern = ATTACK_KERN_NONE;
6742
6743 switch (attack_mode)
6744 {
6745 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6746 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6747 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6748 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6749 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6750 }
6751
6752 if (benchmark == 1)
6753 {
6754 if (myargv[optind] != 0)
6755 {
6756 log_error ("ERROR: Invalid argument for benchmark mode specified");
6757
6758 return (-1);
6759 }
6760
6761 if (attack_mode_chgd == 1)
6762 {
6763 if (attack_mode != ATTACK_MODE_BF)
6764 {
6765 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6766
6767 return (-1);
6768 }
6769 }
6770 }
6771 else
6772 {
6773 if (stdout_flag == 1) // no hash here
6774 {
6775 optind--;
6776 }
6777
6778 if (keyspace == 1)
6779 {
6780 int num_additional_params = 1;
6781
6782 if (attack_kern == ATTACK_KERN_COMBI)
6783 {
6784 num_additional_params = 2;
6785 }
6786
6787 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6788
6789 if (keyspace_wordlist_specified == 0) optind--;
6790 }
6791
6792 if (attack_kern == ATTACK_KERN_NONE)
6793 {
6794 if ((optind + 1) != myargc)
6795 {
6796 usage_mini_print (myargv[0]);
6797
6798 return (-1);
6799 }
6800 }
6801 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6802 {
6803 if ((optind + 1) > myargc)
6804 {
6805 usage_mini_print (myargv[0]);
6806
6807 return (-1);
6808 }
6809 }
6810 else if (attack_kern == ATTACK_KERN_COMBI)
6811 {
6812 if ((optind + 3) != myargc)
6813 {
6814 usage_mini_print (myargv[0]);
6815
6816 return (-1);
6817 }
6818 }
6819 else if (attack_kern == ATTACK_KERN_BF)
6820 {
6821 if ((optind + 1) > myargc)
6822 {
6823 usage_mini_print (myargv[0]);
6824
6825 return (-1);
6826 }
6827 }
6828 else
6829 {
6830 usage_mini_print (myargv[0]);
6831
6832 return (-1);
6833 }
6834 }
6835
6836 if (skip != 0 && limit != 0)
6837 {
6838 limit += skip;
6839 }
6840
6841 if (keyspace == 1)
6842 {
6843 if (show == 1)
6844 {
6845 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
6846
6847 return (-1);
6848 }
6849 else if (left == 1)
6850 {
6851 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
6852
6853 return (-1);
6854 }
6855
6856 potfile_disable = 1;
6857
6858 restore_disable = 1;
6859
6860 restore = 0;
6861
6862 weak_hash_threshold = 0;
6863
6864 quiet = 1;
6865 }
6866
6867 if (stdout_flag == 1)
6868 {
6869 status_timer = 0;
6870 restore_timer = 0;
6871 restore_disable = 1;
6872 restore = 0;
6873 potfile_disable = 1;
6874 weak_hash_threshold = 0;
6875 gpu_temp_disable = 1;
6876 hash_mode = 2000;
6877 quiet = 1;
6878 outfile_format = OUTFILE_FMT_PLAIN;
6879 kernel_accel = 1024;
6880 kernel_loops = 1024;
6881 force = 1;
6882 outfile_check_timer = 0;
6883 session = "stdout";
6884 opencl_vector_width = 1;
6885 }
6886
6887 if (remove_timer_chgd == 1)
6888 {
6889 if (remove == 0)
6890 {
6891 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6892
6893 return (-1);
6894 }
6895
6896 if (remove_timer < 1)
6897 {
6898 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6899
6900 return (-1);
6901 }
6902 }
6903
6904 if (loopback == 1)
6905 {
6906 if (attack_mode == ATTACK_MODE_STRAIGHT)
6907 {
6908 if ((rp_files_cnt == 0) && (rp_gen == 0))
6909 {
6910 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6911
6912 return (-1);
6913 }
6914 }
6915 else
6916 {
6917 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6918
6919 return (-1);
6920 }
6921 }
6922
6923 if (debug_mode > 0)
6924 {
6925 if (attack_mode != ATTACK_MODE_STRAIGHT)
6926 {
6927 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6928
6929 return (-1);
6930 }
6931
6932 if ((rp_files_cnt == 0) && (rp_gen == 0))
6933 {
6934 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6935
6936 return (-1);
6937 }
6938 }
6939
6940 if (debug_mode > 4)
6941 {
6942 log_error ("ERROR: Invalid debug-mode specified");
6943
6944 return (-1);
6945 }
6946
6947 if (debug_file != NULL)
6948 {
6949 if (debug_mode < 1)
6950 {
6951 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6952
6953 return (-1);
6954 }
6955 }
6956
6957 if (induction_dir != NULL)
6958 {
6959 if (attack_mode == ATTACK_MODE_BF)
6960 {
6961 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6962
6963 return (-1);
6964 }
6965 }
6966
6967 if (attack_mode != ATTACK_MODE_STRAIGHT)
6968 {
6969 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6970 {
6971 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6972
6973 return (-1);
6974 }
6975
6976 weak_hash_threshold = 0;
6977 }
6978
6979 if (nvidia_spin_damp > 100)
6980 {
6981 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
6982
6983 return (-1);
6984 }
6985
6986
6987 /**
6988 * induction directory
6989 */
6990
6991 char *induction_directory = NULL;
6992
6993 if (attack_mode != ATTACK_MODE_BF)
6994 {
6995 if (induction_dir == NULL)
6996 {
6997 induction_directory = (char *) mymalloc (session_size);
6998
6999 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
7000
7001 // create induction folder if it does not already exist
7002
7003 if (keyspace == 0)
7004 {
7005 if (rmdir (induction_directory) == -1)
7006 {
7007 if (errno == ENOENT)
7008 {
7009 // good, we can ignore
7010 }
7011 else if (errno == ENOTEMPTY)
7012 {
7013 char *induction_directory_mv = (char *) mymalloc (session_size);
7014
7015 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
7016
7017 if (rename (induction_directory, induction_directory_mv) != 0)
7018 {
7019 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
7020
7021 return (-1);
7022 }
7023 }
7024 else
7025 {
7026 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7027
7028 return (-1);
7029 }
7030 }
7031
7032 if (mkdir (induction_directory, 0700) == -1)
7033 {
7034 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7035
7036 return (-1);
7037 }
7038 }
7039 }
7040 else
7041 {
7042 induction_directory = induction_dir;
7043 }
7044 }
7045
7046 data.induction_directory = induction_directory;
7047
7048 /**
7049 * loopback
7050 */
7051
7052 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
7053
7054 char *loopback_file = (char *) mymalloc (loopback_size);
7055
7056 /**
7057 * tuning db
7058 */
7059
7060 char tuning_db_file[256] = { 0 };
7061
7062 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
7063
7064 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7065
7066 /**
7067 * outfile-check directory
7068 */
7069
7070 char *outfile_check_directory = NULL;
7071
7072 if (outfile_check_dir == NULL)
7073 {
7074 outfile_check_directory = (char *) mymalloc (session_size);
7075
7076 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7077 }
7078 else
7079 {
7080 outfile_check_directory = outfile_check_dir;
7081 }
7082
7083 data.outfile_check_directory = outfile_check_directory;
7084
7085 if (keyspace == 0)
7086 {
7087 struct stat outfile_check_stat;
7088
7089 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7090 {
7091 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7092
7093 if (is_dir == 0)
7094 {
7095 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7096
7097 return (-1);
7098 }
7099 }
7100 else if (outfile_check_dir == NULL)
7101 {
7102 if (mkdir (outfile_check_directory, 0700) == -1)
7103 {
7104 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7105
7106 return (-1);
7107 }
7108 }
7109 }
7110
7111 /**
7112 * special other stuff
7113 */
7114
7115 if (hash_mode == 9710)
7116 {
7117 outfile_format = 5;
7118 outfile_format_chgd = 1;
7119 }
7120
7121 if (hash_mode == 9810)
7122 {
7123 outfile_format = 5;
7124 outfile_format_chgd = 1;
7125 }
7126
7127 if (hash_mode == 10410)
7128 {
7129 outfile_format = 5;
7130 outfile_format_chgd = 1;
7131 }
7132
7133 /**
7134 * store stuff
7135 */
7136
7137 data.hash_mode = hash_mode;
7138 data.restore = restore;
7139 data.restore_timer = restore_timer;
7140 data.restore_disable = restore_disable;
7141 data.status = status;
7142 data.status_timer = status_timer;
7143 data.machine_readable = machine_readable;
7144 data.loopback = loopback;
7145 data.runtime = runtime;
7146 data.remove = remove;
7147 data.remove_timer = remove_timer;
7148 data.debug_mode = debug_mode;
7149 data.debug_file = debug_file;
7150 data.username = username;
7151 data.quiet = quiet;
7152 data.outfile = outfile;
7153 data.outfile_format = outfile_format;
7154 data.outfile_autohex = outfile_autohex;
7155 data.hex_charset = hex_charset;
7156 data.hex_salt = hex_salt;
7157 data.hex_wordlist = hex_wordlist;
7158 data.separator = separator;
7159 data.rp_files = rp_files;
7160 data.rp_files_cnt = rp_files_cnt;
7161 data.rp_gen = rp_gen;
7162 data.rp_gen_seed = rp_gen_seed;
7163 data.force = force;
7164 data.benchmark = benchmark;
7165 data.skip = skip;
7166 data.limit = limit;
7167 #ifdef HAVE_HWMON
7168 data.powertune_enable = powertune_enable;
7169 #endif
7170 data.logfile_disable = logfile_disable;
7171 data.truecrypt_keyfiles = truecrypt_keyfiles;
7172 data.veracrypt_keyfiles = veracrypt_keyfiles;
7173 data.veracrypt_pim = veracrypt_pim;
7174 data.scrypt_tmto = scrypt_tmto;
7175 data.workload_profile = workload_profile;
7176
7177 /**
7178 * cpu affinity
7179 */
7180
7181 if (cpu_affinity)
7182 {
7183 set_cpu_affinity (cpu_affinity);
7184 }
7185
7186 if (rp_gen_seed_chgd == 0)
7187 {
7188 srand (proc_start);
7189 }
7190 else
7191 {
7192 srand (rp_gen_seed);
7193 }
7194
7195 /**
7196 * logfile init
7197 */
7198
7199 if (logfile_disable == 0)
7200 {
7201 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7202
7203 char *logfile = (char *) mymalloc (logfile_size);
7204
7205 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7206
7207 data.logfile = logfile;
7208
7209 char *topid = logfile_generate_topid ();
7210
7211 data.topid = topid;
7212 }
7213
7214 // logfile_append() checks for logfile_disable internally to make it easier from here
7215
7216 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7217 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7218 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7219 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7220 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7221 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7222 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7223 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7224 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7225 #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));
7226
7227 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7228 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7229 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7230 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7231 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7232 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7233 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7234 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7235
7236 logfile_top_msg ("START");
7237
7238 logfile_top_uint (attack_mode);
7239 logfile_top_uint (attack_kern);
7240 logfile_top_uint (benchmark);
7241 logfile_top_uint (stdout_flag);
7242 logfile_top_uint (bitmap_min);
7243 logfile_top_uint (bitmap_max);
7244 logfile_top_uint (debug_mode);
7245 logfile_top_uint (force);
7246 logfile_top_uint (kernel_accel);
7247 logfile_top_uint (kernel_loops);
7248 logfile_top_uint (nvidia_spin_damp);
7249 logfile_top_uint (gpu_temp_disable);
7250 #ifdef HAVE_HWMON
7251 logfile_top_uint (gpu_temp_abort);
7252 logfile_top_uint (gpu_temp_retain);
7253 #endif
7254 logfile_top_uint (hash_mode);
7255 logfile_top_uint (hex_charset);
7256 logfile_top_uint (hex_salt);
7257 logfile_top_uint (hex_wordlist);
7258 logfile_top_uint (increment);
7259 logfile_top_uint (increment_max);
7260 logfile_top_uint (increment_min);
7261 logfile_top_uint (keyspace);
7262 logfile_top_uint (left);
7263 logfile_top_uint (logfile_disable);
7264 logfile_top_uint (loopback);
7265 logfile_top_uint (markov_classic);
7266 logfile_top_uint (markov_disable);
7267 logfile_top_uint (markov_threshold);
7268 logfile_top_uint (outfile_autohex);
7269 logfile_top_uint (outfile_check_timer);
7270 logfile_top_uint (outfile_format);
7271 logfile_top_uint (potfile_disable);
7272 logfile_top_string (potfile_path);
7273 #if defined(HAVE_HWMON)
7274 logfile_top_uint (powertune_enable);
7275 #endif
7276 logfile_top_uint (scrypt_tmto);
7277 logfile_top_uint (quiet);
7278 logfile_top_uint (remove);
7279 logfile_top_uint (remove_timer);
7280 logfile_top_uint (restore);
7281 logfile_top_uint (restore_disable);
7282 logfile_top_uint (restore_timer);
7283 logfile_top_uint (rp_gen);
7284 logfile_top_uint (rp_gen_func_max);
7285 logfile_top_uint (rp_gen_func_min);
7286 logfile_top_uint (rp_gen_seed);
7287 logfile_top_uint (runtime);
7288 logfile_top_uint (segment_size);
7289 logfile_top_uint (show);
7290 logfile_top_uint (status);
7291 logfile_top_uint (machine_readable);
7292 logfile_top_uint (status_timer);
7293 logfile_top_uint (usage);
7294 logfile_top_uint (username);
7295 logfile_top_uint (version);
7296 logfile_top_uint (weak_hash_threshold);
7297 logfile_top_uint (workload_profile);
7298 logfile_top_uint64 (limit);
7299 logfile_top_uint64 (skip);
7300 logfile_top_char (separator);
7301 logfile_top_string (cpu_affinity);
7302 logfile_top_string (custom_charset_1);
7303 logfile_top_string (custom_charset_2);
7304 logfile_top_string (custom_charset_3);
7305 logfile_top_string (custom_charset_4);
7306 logfile_top_string (debug_file);
7307 logfile_top_string (opencl_devices);
7308 logfile_top_string (opencl_platforms);
7309 logfile_top_string (opencl_device_types);
7310 logfile_top_uint (opencl_vector_width);
7311 logfile_top_string (induction_dir);
7312 logfile_top_string (markov_hcstat);
7313 logfile_top_string (outfile);
7314 logfile_top_string (outfile_check_dir);
7315 logfile_top_string (rule_buf_l);
7316 logfile_top_string (rule_buf_r);
7317 logfile_top_string (session);
7318 logfile_top_string (truecrypt_keyfiles);
7319 logfile_top_string (veracrypt_keyfiles);
7320 logfile_top_uint (veracrypt_pim);
7321
7322 /**
7323 * Init OpenCL library loader
7324 */
7325
7326 if (keyspace == 0)
7327 {
7328 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7329
7330 ocl_init (ocl);
7331
7332 data.ocl = ocl;
7333 }
7334
7335 /**
7336 * OpenCL platform selection
7337 */
7338
7339 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7340
7341 /**
7342 * OpenCL device selection
7343 */
7344
7345 u32 devices_filter = setup_devices_filter (opencl_devices);
7346
7347 /**
7348 * OpenCL device type selection
7349 */
7350
7351 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7352
7353 /**
7354 * benchmark
7355 */
7356
7357 if (benchmark == 1)
7358 {
7359 /**
7360 * disable useless stuff for benchmark
7361 */
7362
7363 status_timer = 0;
7364 restore_timer = 0;
7365 restore_disable = 1;
7366 potfile_disable = 1;
7367 weak_hash_threshold = 0;
7368 nvidia_spin_damp = 0;
7369 gpu_temp_disable = 1;
7370 outfile_check_timer = 0;
7371
7372 #ifdef HAVE_HWMON
7373 if (powertune_enable == 1)
7374 {
7375 gpu_temp_disable = 0;
7376 }
7377 #endif
7378
7379 data.status_timer = status_timer;
7380 data.restore_timer = restore_timer;
7381 data.restore_disable = restore_disable;
7382 data.outfile_check_timer = outfile_check_timer;
7383
7384 /**
7385 * force attack mode to be bruteforce
7386 */
7387
7388 attack_mode = ATTACK_MODE_BF;
7389 attack_kern = ATTACK_KERN_BF;
7390
7391 if (workload_profile_chgd == 0)
7392 {
7393 workload_profile = 3;
7394
7395 data.workload_profile = workload_profile;
7396 }
7397 }
7398
7399 /**
7400 * status, monitor and outfile remove threads
7401 */
7402
7403 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
7404
7405 data.wordlist_mode = wordlist_mode;
7406
7407 if (wordlist_mode == WL_MODE_STDIN)
7408 {
7409 status = 1;
7410
7411 data.status = status;
7412 }
7413
7414 uint outer_threads_cnt = 0;
7415
7416 hc_thread_t *outer_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
7417
7418 data.shutdown_outer = 0;
7419
7420 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
7421 {
7422 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
7423 {
7424 hc_thread_create (outer_threads[outer_threads_cnt], thread_keypress, NULL);
7425
7426 outer_threads_cnt++;
7427 }
7428 }
7429
7430 /**
7431 * config
7432 */
7433
7434 uint hash_type = 0;
7435 uint salt_type = 0;
7436 uint attack_exec = 0;
7437 uint opts_type = 0;
7438 uint kern_type = 0;
7439 uint dgst_size = 0;
7440 uint esalt_size = 0;
7441 uint opti_type = 0;
7442 uint dgst_pos0 = -1;
7443 uint dgst_pos1 = -1;
7444 uint dgst_pos2 = -1;
7445 uint dgst_pos3 = -1;
7446
7447 int (*parse_func) (char *, uint, hash_t *);
7448 int (*sort_by_digest) (const void *, const void *);
7449
7450 uint algorithm_pos = 0;
7451 uint algorithm_max = 1;
7452
7453 uint *algorithms = default_benchmark_algorithms;
7454
7455 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7456
7457 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7458 {
7459 /*
7460 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7461 * the following algos are skipped entirely
7462 */
7463
7464 if (algorithm_pos > 0)
7465 {
7466 local_free (rd);
7467
7468 rd = init_restore (argc, argv);
7469
7470 data.rd = rd;
7471 }
7472
7473 /**
7474 * update hash_mode in case of multihash benchmark
7475 */
7476
7477 if (benchmark == 1)
7478 {
7479 if (hash_mode_chgd == 0)
7480 {
7481 hash_mode = algorithms[algorithm_pos];
7482
7483 data.hash_mode = hash_mode;
7484 }
7485
7486 quiet = 1;
7487
7488 data.quiet = quiet;
7489 }
7490
7491 switch (hash_mode)
7492 {
7493 case 0: hash_type = HASH_TYPE_MD5;
7494 salt_type = SALT_TYPE_NONE;
7495 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7496 opts_type = OPTS_TYPE_PT_GENERATE_LE
7497 | OPTS_TYPE_PT_ADD80
7498 | OPTS_TYPE_PT_ADDBITS14;
7499 kern_type = KERN_TYPE_MD5;
7500 dgst_size = DGST_SIZE_4_4;
7501 parse_func = md5_parse_hash;
7502 sort_by_digest = sort_by_digest_4_4;
7503 opti_type = OPTI_TYPE_ZERO_BYTE
7504 | OPTI_TYPE_PRECOMPUTE_INIT
7505 | OPTI_TYPE_PRECOMPUTE_MERKLE
7506 | OPTI_TYPE_MEET_IN_MIDDLE
7507 | OPTI_TYPE_EARLY_SKIP
7508 | OPTI_TYPE_NOT_ITERATED
7509 | OPTI_TYPE_NOT_SALTED
7510 | OPTI_TYPE_RAW_HASH;
7511 dgst_pos0 = 0;
7512 dgst_pos1 = 3;
7513 dgst_pos2 = 2;
7514 dgst_pos3 = 1;
7515 break;
7516
7517 case 10: hash_type = HASH_TYPE_MD5;
7518 salt_type = SALT_TYPE_INTERN;
7519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7520 opts_type = OPTS_TYPE_PT_GENERATE_LE
7521 | OPTS_TYPE_ST_ADD80
7522 | OPTS_TYPE_ST_ADDBITS14;
7523 kern_type = KERN_TYPE_MD5_PWSLT;
7524 dgst_size = DGST_SIZE_4_4;
7525 parse_func = md5s_parse_hash;
7526 sort_by_digest = sort_by_digest_4_4;
7527 opti_type = OPTI_TYPE_ZERO_BYTE
7528 | OPTI_TYPE_PRECOMPUTE_INIT
7529 | OPTI_TYPE_PRECOMPUTE_MERKLE
7530 | OPTI_TYPE_MEET_IN_MIDDLE
7531 | OPTI_TYPE_EARLY_SKIP
7532 | OPTI_TYPE_NOT_ITERATED
7533 | OPTI_TYPE_APPENDED_SALT
7534 | OPTI_TYPE_RAW_HASH;
7535 dgst_pos0 = 0;
7536 dgst_pos1 = 3;
7537 dgst_pos2 = 2;
7538 dgst_pos3 = 1;
7539 break;
7540
7541 case 11: hash_type = HASH_TYPE_MD5;
7542 salt_type = SALT_TYPE_INTERN;
7543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7544 opts_type = OPTS_TYPE_PT_GENERATE_LE
7545 | OPTS_TYPE_ST_ADD80
7546 | OPTS_TYPE_ST_ADDBITS14;
7547 kern_type = KERN_TYPE_MD5_PWSLT;
7548 dgst_size = DGST_SIZE_4_4;
7549 parse_func = joomla_parse_hash;
7550 sort_by_digest = sort_by_digest_4_4;
7551 opti_type = OPTI_TYPE_ZERO_BYTE
7552 | OPTI_TYPE_PRECOMPUTE_INIT
7553 | OPTI_TYPE_PRECOMPUTE_MERKLE
7554 | OPTI_TYPE_MEET_IN_MIDDLE
7555 | OPTI_TYPE_EARLY_SKIP
7556 | OPTI_TYPE_NOT_ITERATED
7557 | OPTI_TYPE_APPENDED_SALT
7558 | OPTI_TYPE_RAW_HASH;
7559 dgst_pos0 = 0;
7560 dgst_pos1 = 3;
7561 dgst_pos2 = 2;
7562 dgst_pos3 = 1;
7563 break;
7564
7565 case 12: hash_type = HASH_TYPE_MD5;
7566 salt_type = SALT_TYPE_INTERN;
7567 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7568 opts_type = OPTS_TYPE_PT_GENERATE_LE
7569 | OPTS_TYPE_ST_ADD80
7570 | OPTS_TYPE_ST_ADDBITS14;
7571 kern_type = KERN_TYPE_MD5_PWSLT;
7572 dgst_size = DGST_SIZE_4_4;
7573 parse_func = postgresql_parse_hash;
7574 sort_by_digest = sort_by_digest_4_4;
7575 opti_type = OPTI_TYPE_ZERO_BYTE
7576 | OPTI_TYPE_PRECOMPUTE_INIT
7577 | OPTI_TYPE_PRECOMPUTE_MERKLE
7578 | OPTI_TYPE_MEET_IN_MIDDLE
7579 | OPTI_TYPE_EARLY_SKIP
7580 | OPTI_TYPE_NOT_ITERATED
7581 | OPTI_TYPE_APPENDED_SALT
7582 | OPTI_TYPE_RAW_HASH;
7583 dgst_pos0 = 0;
7584 dgst_pos1 = 3;
7585 dgst_pos2 = 2;
7586 dgst_pos3 = 1;
7587 break;
7588
7589 case 20: hash_type = HASH_TYPE_MD5;
7590 salt_type = SALT_TYPE_INTERN;
7591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7592 opts_type = OPTS_TYPE_PT_GENERATE_LE
7593 | OPTS_TYPE_PT_ADD80
7594 | OPTS_TYPE_PT_ADDBITS14;
7595 kern_type = KERN_TYPE_MD5_SLTPW;
7596 dgst_size = DGST_SIZE_4_4;
7597 parse_func = md5s_parse_hash;
7598 sort_by_digest = sort_by_digest_4_4;
7599 opti_type = OPTI_TYPE_ZERO_BYTE
7600 | OPTI_TYPE_PRECOMPUTE_INIT
7601 | OPTI_TYPE_PRECOMPUTE_MERKLE
7602 | OPTI_TYPE_EARLY_SKIP
7603 | OPTI_TYPE_NOT_ITERATED
7604 | OPTI_TYPE_PREPENDED_SALT
7605 | OPTI_TYPE_RAW_HASH;
7606 dgst_pos0 = 0;
7607 dgst_pos1 = 3;
7608 dgst_pos2 = 2;
7609 dgst_pos3 = 1;
7610 break;
7611
7612 case 21: hash_type = HASH_TYPE_MD5;
7613 salt_type = SALT_TYPE_INTERN;
7614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7615 opts_type = OPTS_TYPE_PT_GENERATE_LE
7616 | OPTS_TYPE_PT_ADD80
7617 | OPTS_TYPE_PT_ADDBITS14;
7618 kern_type = KERN_TYPE_MD5_SLTPW;
7619 dgst_size = DGST_SIZE_4_4;
7620 parse_func = osc_parse_hash;
7621 sort_by_digest = sort_by_digest_4_4;
7622 opti_type = OPTI_TYPE_ZERO_BYTE
7623 | OPTI_TYPE_PRECOMPUTE_INIT
7624 | OPTI_TYPE_PRECOMPUTE_MERKLE
7625 | OPTI_TYPE_EARLY_SKIP
7626 | OPTI_TYPE_NOT_ITERATED
7627 | OPTI_TYPE_PREPENDED_SALT
7628 | OPTI_TYPE_RAW_HASH;
7629 dgst_pos0 = 0;
7630 dgst_pos1 = 3;
7631 dgst_pos2 = 2;
7632 dgst_pos3 = 1;
7633 break;
7634
7635 case 22: hash_type = HASH_TYPE_MD5;
7636 salt_type = SALT_TYPE_EMBEDDED;
7637 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7638 opts_type = OPTS_TYPE_PT_GENERATE_LE
7639 | OPTS_TYPE_PT_ADD80
7640 | OPTS_TYPE_PT_ADDBITS14;
7641 kern_type = KERN_TYPE_MD5_SLTPW;
7642 dgst_size = DGST_SIZE_4_4;
7643 parse_func = netscreen_parse_hash;
7644 sort_by_digest = sort_by_digest_4_4;
7645 opti_type = OPTI_TYPE_ZERO_BYTE
7646 | OPTI_TYPE_PRECOMPUTE_INIT
7647 | OPTI_TYPE_PRECOMPUTE_MERKLE
7648 | OPTI_TYPE_EARLY_SKIP
7649 | OPTI_TYPE_NOT_ITERATED
7650 | OPTI_TYPE_PREPENDED_SALT
7651 | OPTI_TYPE_RAW_HASH;
7652 dgst_pos0 = 0;
7653 dgst_pos1 = 3;
7654 dgst_pos2 = 2;
7655 dgst_pos3 = 1;
7656 break;
7657
7658 case 23: hash_type = HASH_TYPE_MD5;
7659 salt_type = SALT_TYPE_EMBEDDED;
7660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7661 opts_type = OPTS_TYPE_PT_GENERATE_LE
7662 | OPTS_TYPE_PT_ADD80
7663 | OPTS_TYPE_PT_ADDBITS14;
7664 kern_type = KERN_TYPE_MD5_SLTPW;
7665 dgst_size = DGST_SIZE_4_4;
7666 parse_func = skype_parse_hash;
7667 sort_by_digest = sort_by_digest_4_4;
7668 opti_type = OPTI_TYPE_ZERO_BYTE
7669 | OPTI_TYPE_PRECOMPUTE_INIT
7670 | OPTI_TYPE_PRECOMPUTE_MERKLE
7671 | OPTI_TYPE_EARLY_SKIP
7672 | OPTI_TYPE_NOT_ITERATED
7673 | OPTI_TYPE_PREPENDED_SALT
7674 | OPTI_TYPE_RAW_HASH;
7675 dgst_pos0 = 0;
7676 dgst_pos1 = 3;
7677 dgst_pos2 = 2;
7678 dgst_pos3 = 1;
7679 break;
7680
7681 case 30: hash_type = HASH_TYPE_MD5;
7682 salt_type = SALT_TYPE_INTERN;
7683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7684 opts_type = OPTS_TYPE_PT_GENERATE_LE
7685 | OPTS_TYPE_PT_UNICODE
7686 | OPTS_TYPE_ST_ADD80
7687 | OPTS_TYPE_ST_ADDBITS14;
7688 kern_type = KERN_TYPE_MD5_PWUSLT;
7689 dgst_size = DGST_SIZE_4_4;
7690 parse_func = md5s_parse_hash;
7691 sort_by_digest = sort_by_digest_4_4;
7692 opti_type = OPTI_TYPE_ZERO_BYTE
7693 | OPTI_TYPE_PRECOMPUTE_INIT
7694 | OPTI_TYPE_PRECOMPUTE_MERKLE
7695 | OPTI_TYPE_MEET_IN_MIDDLE
7696 | OPTI_TYPE_EARLY_SKIP
7697 | OPTI_TYPE_NOT_ITERATED
7698 | OPTI_TYPE_APPENDED_SALT
7699 | OPTI_TYPE_RAW_HASH;
7700 dgst_pos0 = 0;
7701 dgst_pos1 = 3;
7702 dgst_pos2 = 2;
7703 dgst_pos3 = 1;
7704 break;
7705
7706 case 40: hash_type = HASH_TYPE_MD5;
7707 salt_type = SALT_TYPE_INTERN;
7708 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7709 opts_type = OPTS_TYPE_PT_GENERATE_LE
7710 | OPTS_TYPE_PT_ADD80
7711 | OPTS_TYPE_PT_ADDBITS14
7712 | OPTS_TYPE_PT_UNICODE;
7713 kern_type = KERN_TYPE_MD5_SLTPWU;
7714 dgst_size = DGST_SIZE_4_4;
7715 parse_func = md5s_parse_hash;
7716 sort_by_digest = sort_by_digest_4_4;
7717 opti_type = OPTI_TYPE_ZERO_BYTE
7718 | OPTI_TYPE_PRECOMPUTE_INIT
7719 | OPTI_TYPE_PRECOMPUTE_MERKLE
7720 | OPTI_TYPE_EARLY_SKIP
7721 | OPTI_TYPE_NOT_ITERATED
7722 | OPTI_TYPE_PREPENDED_SALT
7723 | OPTI_TYPE_RAW_HASH;
7724 dgst_pos0 = 0;
7725 dgst_pos1 = 3;
7726 dgst_pos2 = 2;
7727 dgst_pos3 = 1;
7728 break;
7729
7730 case 50: hash_type = HASH_TYPE_MD5;
7731 salt_type = SALT_TYPE_INTERN;
7732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7733 opts_type = OPTS_TYPE_PT_GENERATE_LE
7734 | OPTS_TYPE_ST_ADD80
7735 | OPTS_TYPE_ST_ADDBITS14;
7736 kern_type = KERN_TYPE_HMACMD5_PW;
7737 dgst_size = DGST_SIZE_4_4;
7738 parse_func = hmacmd5_parse_hash;
7739 sort_by_digest = sort_by_digest_4_4;
7740 opti_type = OPTI_TYPE_ZERO_BYTE
7741 | OPTI_TYPE_NOT_ITERATED;
7742 dgst_pos0 = 0;
7743 dgst_pos1 = 3;
7744 dgst_pos2 = 2;
7745 dgst_pos3 = 1;
7746 break;
7747
7748 case 60: hash_type = HASH_TYPE_MD5;
7749 salt_type = SALT_TYPE_INTERN;
7750 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7751 opts_type = OPTS_TYPE_PT_GENERATE_LE
7752 | OPTS_TYPE_PT_ADD80
7753 | OPTS_TYPE_PT_ADDBITS14;
7754 kern_type = KERN_TYPE_HMACMD5_SLT;
7755 dgst_size = DGST_SIZE_4_4;
7756 parse_func = hmacmd5_parse_hash;
7757 sort_by_digest = sort_by_digest_4_4;
7758 opti_type = OPTI_TYPE_ZERO_BYTE
7759 | OPTI_TYPE_NOT_ITERATED;
7760 dgst_pos0 = 0;
7761 dgst_pos1 = 3;
7762 dgst_pos2 = 2;
7763 dgst_pos3 = 1;
7764 break;
7765
7766 case 100: hash_type = HASH_TYPE_SHA1;
7767 salt_type = SALT_TYPE_NONE;
7768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7769 opts_type = OPTS_TYPE_PT_GENERATE_BE
7770 | OPTS_TYPE_PT_ADD80
7771 | OPTS_TYPE_PT_ADDBITS15;
7772 kern_type = KERN_TYPE_SHA1;
7773 dgst_size = DGST_SIZE_4_5;
7774 parse_func = sha1_parse_hash;
7775 sort_by_digest = sort_by_digest_4_5;
7776 opti_type = OPTI_TYPE_ZERO_BYTE
7777 | OPTI_TYPE_PRECOMPUTE_INIT
7778 | OPTI_TYPE_PRECOMPUTE_MERKLE
7779 | OPTI_TYPE_EARLY_SKIP
7780 | OPTI_TYPE_NOT_ITERATED
7781 | OPTI_TYPE_NOT_SALTED
7782 | OPTI_TYPE_RAW_HASH;
7783 dgst_pos0 = 3;
7784 dgst_pos1 = 4;
7785 dgst_pos2 = 2;
7786 dgst_pos3 = 1;
7787 break;
7788
7789 case 101: hash_type = HASH_TYPE_SHA1;
7790 salt_type = SALT_TYPE_NONE;
7791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7792 opts_type = OPTS_TYPE_PT_GENERATE_BE
7793 | OPTS_TYPE_PT_ADD80
7794 | OPTS_TYPE_PT_ADDBITS15;
7795 kern_type = KERN_TYPE_SHA1;
7796 dgst_size = DGST_SIZE_4_5;
7797 parse_func = sha1b64_parse_hash;
7798 sort_by_digest = sort_by_digest_4_5;
7799 opti_type = OPTI_TYPE_ZERO_BYTE
7800 | OPTI_TYPE_PRECOMPUTE_INIT
7801 | OPTI_TYPE_PRECOMPUTE_MERKLE
7802 | OPTI_TYPE_EARLY_SKIP
7803 | OPTI_TYPE_NOT_ITERATED
7804 | OPTI_TYPE_NOT_SALTED
7805 | OPTI_TYPE_RAW_HASH;
7806 dgst_pos0 = 3;
7807 dgst_pos1 = 4;
7808 dgst_pos2 = 2;
7809 dgst_pos3 = 1;
7810 break;
7811
7812 case 110: hash_type = HASH_TYPE_SHA1;
7813 salt_type = SALT_TYPE_INTERN;
7814 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7815 opts_type = OPTS_TYPE_PT_GENERATE_BE
7816 | OPTS_TYPE_ST_ADD80
7817 | OPTS_TYPE_ST_ADDBITS15;
7818 kern_type = KERN_TYPE_SHA1_PWSLT;
7819 dgst_size = DGST_SIZE_4_5;
7820 parse_func = sha1s_parse_hash;
7821 sort_by_digest = sort_by_digest_4_5;
7822 opti_type = OPTI_TYPE_ZERO_BYTE
7823 | OPTI_TYPE_PRECOMPUTE_INIT
7824 | OPTI_TYPE_PRECOMPUTE_MERKLE
7825 | OPTI_TYPE_EARLY_SKIP
7826 | OPTI_TYPE_NOT_ITERATED
7827 | OPTI_TYPE_APPENDED_SALT
7828 | OPTI_TYPE_RAW_HASH;
7829 dgst_pos0 = 3;
7830 dgst_pos1 = 4;
7831 dgst_pos2 = 2;
7832 dgst_pos3 = 1;
7833 break;
7834
7835 case 111: hash_type = HASH_TYPE_SHA1;
7836 salt_type = SALT_TYPE_EMBEDDED;
7837 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7838 opts_type = OPTS_TYPE_PT_GENERATE_BE
7839 | OPTS_TYPE_ST_ADD80
7840 | OPTS_TYPE_ST_ADDBITS15;
7841 kern_type = KERN_TYPE_SHA1_PWSLT;
7842 dgst_size = DGST_SIZE_4_5;
7843 parse_func = sha1b64s_parse_hash;
7844 sort_by_digest = sort_by_digest_4_5;
7845 opti_type = OPTI_TYPE_ZERO_BYTE
7846 | OPTI_TYPE_PRECOMPUTE_INIT
7847 | OPTI_TYPE_PRECOMPUTE_MERKLE
7848 | OPTI_TYPE_EARLY_SKIP
7849 | OPTI_TYPE_NOT_ITERATED
7850 | OPTI_TYPE_APPENDED_SALT
7851 | OPTI_TYPE_RAW_HASH;
7852 dgst_pos0 = 3;
7853 dgst_pos1 = 4;
7854 dgst_pos2 = 2;
7855 dgst_pos3 = 1;
7856 break;
7857
7858 case 112: hash_type = HASH_TYPE_SHA1;
7859 salt_type = SALT_TYPE_INTERN;
7860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7861 opts_type = OPTS_TYPE_PT_GENERATE_BE
7862 | OPTS_TYPE_ST_ADD80
7863 | OPTS_TYPE_ST_ADDBITS15
7864 | OPTS_TYPE_ST_HEX;
7865 kern_type = KERN_TYPE_SHA1_PWSLT;
7866 dgst_size = DGST_SIZE_4_5;
7867 parse_func = oracles_parse_hash;
7868 sort_by_digest = sort_by_digest_4_5;
7869 opti_type = OPTI_TYPE_ZERO_BYTE
7870 | OPTI_TYPE_PRECOMPUTE_INIT
7871 | OPTI_TYPE_PRECOMPUTE_MERKLE
7872 | OPTI_TYPE_EARLY_SKIP
7873 | OPTI_TYPE_NOT_ITERATED
7874 | OPTI_TYPE_APPENDED_SALT
7875 | OPTI_TYPE_RAW_HASH;
7876 dgst_pos0 = 3;
7877 dgst_pos1 = 4;
7878 dgst_pos2 = 2;
7879 dgst_pos3 = 1;
7880 break;
7881
7882 case 120: hash_type = HASH_TYPE_SHA1;
7883 salt_type = SALT_TYPE_INTERN;
7884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7885 opts_type = OPTS_TYPE_PT_GENERATE_BE
7886 | OPTS_TYPE_PT_ADD80
7887 | OPTS_TYPE_PT_ADDBITS15;
7888 kern_type = KERN_TYPE_SHA1_SLTPW;
7889 dgst_size = DGST_SIZE_4_5;
7890 parse_func = sha1s_parse_hash;
7891 sort_by_digest = sort_by_digest_4_5;
7892 opti_type = OPTI_TYPE_ZERO_BYTE
7893 | OPTI_TYPE_PRECOMPUTE_INIT
7894 | OPTI_TYPE_PRECOMPUTE_MERKLE
7895 | OPTI_TYPE_EARLY_SKIP
7896 | OPTI_TYPE_NOT_ITERATED
7897 | OPTI_TYPE_PREPENDED_SALT
7898 | OPTI_TYPE_RAW_HASH;
7899 dgst_pos0 = 3;
7900 dgst_pos1 = 4;
7901 dgst_pos2 = 2;
7902 dgst_pos3 = 1;
7903 break;
7904
7905 case 121: hash_type = HASH_TYPE_SHA1;
7906 salt_type = SALT_TYPE_INTERN;
7907 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7908 opts_type = OPTS_TYPE_PT_GENERATE_BE
7909 | OPTS_TYPE_PT_ADD80
7910 | OPTS_TYPE_PT_ADDBITS15
7911 | OPTS_TYPE_ST_LOWER;
7912 kern_type = KERN_TYPE_SHA1_SLTPW;
7913 dgst_size = DGST_SIZE_4_5;
7914 parse_func = smf_parse_hash;
7915 sort_by_digest = sort_by_digest_4_5;
7916 opti_type = OPTI_TYPE_ZERO_BYTE
7917 | OPTI_TYPE_PRECOMPUTE_INIT
7918 | OPTI_TYPE_PRECOMPUTE_MERKLE
7919 | OPTI_TYPE_EARLY_SKIP
7920 | OPTI_TYPE_NOT_ITERATED
7921 | OPTI_TYPE_PREPENDED_SALT
7922 | OPTI_TYPE_RAW_HASH;
7923 dgst_pos0 = 3;
7924 dgst_pos1 = 4;
7925 dgst_pos2 = 2;
7926 dgst_pos3 = 1;
7927 break;
7928
7929 case 122: hash_type = HASH_TYPE_SHA1;
7930 salt_type = SALT_TYPE_EMBEDDED;
7931 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7932 opts_type = OPTS_TYPE_PT_GENERATE_BE
7933 | OPTS_TYPE_PT_ADD80
7934 | OPTS_TYPE_PT_ADDBITS15
7935 | OPTS_TYPE_ST_HEX;
7936 kern_type = KERN_TYPE_SHA1_SLTPW;
7937 dgst_size = DGST_SIZE_4_5;
7938 parse_func = osx1_parse_hash;
7939 sort_by_digest = sort_by_digest_4_5;
7940 opti_type = OPTI_TYPE_ZERO_BYTE
7941 | OPTI_TYPE_PRECOMPUTE_INIT
7942 | OPTI_TYPE_PRECOMPUTE_MERKLE
7943 | OPTI_TYPE_EARLY_SKIP
7944 | OPTI_TYPE_NOT_ITERATED
7945 | OPTI_TYPE_PREPENDED_SALT
7946 | OPTI_TYPE_RAW_HASH;
7947 dgst_pos0 = 3;
7948 dgst_pos1 = 4;
7949 dgst_pos2 = 2;
7950 dgst_pos3 = 1;
7951 break;
7952
7953 case 124: hash_type = HASH_TYPE_SHA1;
7954 salt_type = SALT_TYPE_EMBEDDED;
7955 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7956 opts_type = OPTS_TYPE_PT_GENERATE_BE
7957 | OPTS_TYPE_PT_ADD80
7958 | OPTS_TYPE_PT_ADDBITS15;
7959 kern_type = KERN_TYPE_SHA1_SLTPW;
7960 dgst_size = DGST_SIZE_4_5;
7961 parse_func = djangosha1_parse_hash;
7962 sort_by_digest = sort_by_digest_4_5;
7963 opti_type = OPTI_TYPE_ZERO_BYTE
7964 | OPTI_TYPE_PRECOMPUTE_INIT
7965 | OPTI_TYPE_PRECOMPUTE_MERKLE
7966 | OPTI_TYPE_EARLY_SKIP
7967 | OPTI_TYPE_NOT_ITERATED
7968 | OPTI_TYPE_PREPENDED_SALT
7969 | OPTI_TYPE_RAW_HASH;
7970 dgst_pos0 = 3;
7971 dgst_pos1 = 4;
7972 dgst_pos2 = 2;
7973 dgst_pos3 = 1;
7974 break;
7975
7976 case 125: hash_type = HASH_TYPE_SHA1;
7977 salt_type = SALT_TYPE_EMBEDDED;
7978 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7979 opts_type = OPTS_TYPE_PT_GENERATE_BE
7980 | OPTS_TYPE_PT_ADD80
7981 | OPTS_TYPE_PT_ADDBITS15
7982 | OPTS_TYPE_ST_HEX;
7983 kern_type = KERN_TYPE_SHA1_SLTPW;
7984 dgst_size = DGST_SIZE_4_5;
7985 parse_func = arubaos_parse_hash;
7986 sort_by_digest = sort_by_digest_4_5;
7987 opti_type = OPTI_TYPE_ZERO_BYTE
7988 | OPTI_TYPE_PRECOMPUTE_INIT
7989 | OPTI_TYPE_PRECOMPUTE_MERKLE
7990 | OPTI_TYPE_EARLY_SKIP
7991 | OPTI_TYPE_NOT_ITERATED
7992 | OPTI_TYPE_PREPENDED_SALT
7993 | OPTI_TYPE_RAW_HASH;
7994 dgst_pos0 = 3;
7995 dgst_pos1 = 4;
7996 dgst_pos2 = 2;
7997 dgst_pos3 = 1;
7998 break;
7999
8000 case 130: hash_type = HASH_TYPE_SHA1;
8001 salt_type = SALT_TYPE_INTERN;
8002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8003 opts_type = OPTS_TYPE_PT_GENERATE_BE
8004 | OPTS_TYPE_PT_UNICODE
8005 | OPTS_TYPE_ST_ADD80
8006 | OPTS_TYPE_ST_ADDBITS15;
8007 kern_type = KERN_TYPE_SHA1_PWUSLT;
8008 dgst_size = DGST_SIZE_4_5;
8009 parse_func = sha1s_parse_hash;
8010 sort_by_digest = sort_by_digest_4_5;
8011 opti_type = OPTI_TYPE_ZERO_BYTE
8012 | OPTI_TYPE_PRECOMPUTE_INIT
8013 | OPTI_TYPE_PRECOMPUTE_MERKLE
8014 | OPTI_TYPE_EARLY_SKIP
8015 | OPTI_TYPE_NOT_ITERATED
8016 | OPTI_TYPE_APPENDED_SALT
8017 | OPTI_TYPE_RAW_HASH;
8018 dgst_pos0 = 3;
8019 dgst_pos1 = 4;
8020 dgst_pos2 = 2;
8021 dgst_pos3 = 1;
8022 break;
8023
8024 case 131: hash_type = HASH_TYPE_SHA1;
8025 salt_type = SALT_TYPE_EMBEDDED;
8026 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8027 opts_type = OPTS_TYPE_PT_GENERATE_BE
8028 | OPTS_TYPE_PT_UNICODE
8029 | OPTS_TYPE_PT_UPPER
8030 | OPTS_TYPE_ST_ADD80
8031 | OPTS_TYPE_ST_ADDBITS15
8032 | OPTS_TYPE_ST_HEX;
8033 kern_type = KERN_TYPE_SHA1_PWUSLT;
8034 dgst_size = DGST_SIZE_4_5;
8035 parse_func = mssql2000_parse_hash;
8036 sort_by_digest = sort_by_digest_4_5;
8037 opti_type = OPTI_TYPE_ZERO_BYTE
8038 | OPTI_TYPE_PRECOMPUTE_INIT
8039 | OPTI_TYPE_PRECOMPUTE_MERKLE
8040 | OPTI_TYPE_EARLY_SKIP
8041 | OPTI_TYPE_NOT_ITERATED
8042 | OPTI_TYPE_APPENDED_SALT
8043 | OPTI_TYPE_RAW_HASH;
8044 dgst_pos0 = 3;
8045 dgst_pos1 = 4;
8046 dgst_pos2 = 2;
8047 dgst_pos3 = 1;
8048 break;
8049
8050 case 132: hash_type = HASH_TYPE_SHA1;
8051 salt_type = SALT_TYPE_EMBEDDED;
8052 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8053 opts_type = OPTS_TYPE_PT_GENERATE_BE
8054 | OPTS_TYPE_PT_UNICODE
8055 | OPTS_TYPE_ST_ADD80
8056 | OPTS_TYPE_ST_ADDBITS15
8057 | OPTS_TYPE_ST_HEX;
8058 kern_type = KERN_TYPE_SHA1_PWUSLT;
8059 dgst_size = DGST_SIZE_4_5;
8060 parse_func = mssql2005_parse_hash;
8061 sort_by_digest = sort_by_digest_4_5;
8062 opti_type = OPTI_TYPE_ZERO_BYTE
8063 | OPTI_TYPE_PRECOMPUTE_INIT
8064 | OPTI_TYPE_PRECOMPUTE_MERKLE
8065 | OPTI_TYPE_EARLY_SKIP
8066 | OPTI_TYPE_NOT_ITERATED
8067 | OPTI_TYPE_APPENDED_SALT
8068 | OPTI_TYPE_RAW_HASH;
8069 dgst_pos0 = 3;
8070 dgst_pos1 = 4;
8071 dgst_pos2 = 2;
8072 dgst_pos3 = 1;
8073 break;
8074
8075 case 133: hash_type = HASH_TYPE_SHA1;
8076 salt_type = SALT_TYPE_EMBEDDED;
8077 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8078 opts_type = OPTS_TYPE_PT_GENERATE_BE
8079 | OPTS_TYPE_PT_UNICODE
8080 | OPTS_TYPE_ST_ADD80
8081 | OPTS_TYPE_ST_ADDBITS15;
8082 kern_type = KERN_TYPE_SHA1_PWUSLT;
8083 dgst_size = DGST_SIZE_4_5;
8084 parse_func = peoplesoft_parse_hash;
8085 sort_by_digest = sort_by_digest_4_5;
8086 opti_type = OPTI_TYPE_ZERO_BYTE
8087 | OPTI_TYPE_PRECOMPUTE_INIT
8088 | OPTI_TYPE_PRECOMPUTE_MERKLE
8089 | OPTI_TYPE_EARLY_SKIP
8090 | OPTI_TYPE_NOT_ITERATED
8091 | OPTI_TYPE_APPENDED_SALT
8092 | OPTI_TYPE_RAW_HASH;
8093 dgst_pos0 = 3;
8094 dgst_pos1 = 4;
8095 dgst_pos2 = 2;
8096 dgst_pos3 = 1;
8097 break;
8098
8099 case 140: hash_type = HASH_TYPE_SHA1;
8100 salt_type = SALT_TYPE_INTERN;
8101 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8102 opts_type = OPTS_TYPE_PT_GENERATE_BE
8103 | OPTS_TYPE_PT_ADD80
8104 | OPTS_TYPE_PT_ADDBITS15
8105 | OPTS_TYPE_PT_UNICODE;
8106 kern_type = KERN_TYPE_SHA1_SLTPWU;
8107 dgst_size = DGST_SIZE_4_5;
8108 parse_func = sha1s_parse_hash;
8109 sort_by_digest = sort_by_digest_4_5;
8110 opti_type = OPTI_TYPE_ZERO_BYTE
8111 | OPTI_TYPE_PRECOMPUTE_INIT
8112 | OPTI_TYPE_PRECOMPUTE_MERKLE
8113 | OPTI_TYPE_EARLY_SKIP
8114 | OPTI_TYPE_NOT_ITERATED
8115 | OPTI_TYPE_PREPENDED_SALT
8116 | OPTI_TYPE_RAW_HASH;
8117 dgst_pos0 = 3;
8118 dgst_pos1 = 4;
8119 dgst_pos2 = 2;
8120 dgst_pos3 = 1;
8121 break;
8122
8123 case 141: hash_type = HASH_TYPE_SHA1;
8124 salt_type = SALT_TYPE_EMBEDDED;
8125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8126 opts_type = OPTS_TYPE_PT_GENERATE_BE
8127 | OPTS_TYPE_PT_ADD80
8128 | OPTS_TYPE_PT_ADDBITS15
8129 | OPTS_TYPE_PT_UNICODE
8130 | OPTS_TYPE_ST_BASE64;
8131 kern_type = KERN_TYPE_SHA1_SLTPWU;
8132 dgst_size = DGST_SIZE_4_5;
8133 parse_func = episerver_parse_hash;
8134 sort_by_digest = sort_by_digest_4_5;
8135 opti_type = OPTI_TYPE_ZERO_BYTE
8136 | OPTI_TYPE_PRECOMPUTE_INIT
8137 | OPTI_TYPE_PRECOMPUTE_MERKLE
8138 | OPTI_TYPE_EARLY_SKIP
8139 | OPTI_TYPE_NOT_ITERATED
8140 | OPTI_TYPE_PREPENDED_SALT
8141 | OPTI_TYPE_RAW_HASH;
8142 dgst_pos0 = 3;
8143 dgst_pos1 = 4;
8144 dgst_pos2 = 2;
8145 dgst_pos3 = 1;
8146 break;
8147
8148 case 150: hash_type = HASH_TYPE_SHA1;
8149 salt_type = SALT_TYPE_INTERN;
8150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8151 opts_type = OPTS_TYPE_PT_GENERATE_BE
8152 | OPTS_TYPE_ST_ADD80
8153 | OPTS_TYPE_ST_ADDBITS15;
8154 kern_type = KERN_TYPE_HMACSHA1_PW;
8155 dgst_size = DGST_SIZE_4_5;
8156 parse_func = hmacsha1_parse_hash;
8157 sort_by_digest = sort_by_digest_4_5;
8158 opti_type = OPTI_TYPE_ZERO_BYTE
8159 | OPTI_TYPE_NOT_ITERATED;
8160 dgst_pos0 = 3;
8161 dgst_pos1 = 4;
8162 dgst_pos2 = 2;
8163 dgst_pos3 = 1;
8164 break;
8165
8166 case 160: hash_type = HASH_TYPE_SHA1;
8167 salt_type = SALT_TYPE_INTERN;
8168 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8169 opts_type = OPTS_TYPE_PT_GENERATE_BE
8170 | OPTS_TYPE_PT_ADD80
8171 | OPTS_TYPE_PT_ADDBITS15;
8172 kern_type = KERN_TYPE_HMACSHA1_SLT;
8173 dgst_size = DGST_SIZE_4_5;
8174 parse_func = hmacsha1_parse_hash;
8175 sort_by_digest = sort_by_digest_4_5;
8176 opti_type = OPTI_TYPE_ZERO_BYTE
8177 | OPTI_TYPE_NOT_ITERATED;
8178 dgst_pos0 = 3;
8179 dgst_pos1 = 4;
8180 dgst_pos2 = 2;
8181 dgst_pos3 = 1;
8182 break;
8183
8184 case 200: hash_type = HASH_TYPE_MYSQL;
8185 salt_type = SALT_TYPE_NONE;
8186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8187 opts_type = 0;
8188 kern_type = KERN_TYPE_MYSQL;
8189 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8190 parse_func = mysql323_parse_hash;
8191 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8192 opti_type = OPTI_TYPE_ZERO_BYTE;
8193 dgst_pos0 = 0;
8194 dgst_pos1 = 1;
8195 dgst_pos2 = 2;
8196 dgst_pos3 = 3;
8197 break;
8198
8199 case 300: hash_type = HASH_TYPE_SHA1;
8200 salt_type = SALT_TYPE_NONE;
8201 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8202 opts_type = OPTS_TYPE_PT_GENERATE_BE
8203 | OPTS_TYPE_PT_ADD80
8204 | OPTS_TYPE_PT_ADDBITS15;
8205 kern_type = KERN_TYPE_MYSQL41;
8206 dgst_size = DGST_SIZE_4_5;
8207 parse_func = sha1_parse_hash;
8208 sort_by_digest = sort_by_digest_4_5;
8209 opti_type = OPTI_TYPE_ZERO_BYTE
8210 | OPTI_TYPE_PRECOMPUTE_INIT
8211 | OPTI_TYPE_PRECOMPUTE_MERKLE
8212 | OPTI_TYPE_EARLY_SKIP
8213 | OPTI_TYPE_NOT_ITERATED
8214 | OPTI_TYPE_NOT_SALTED;
8215 dgst_pos0 = 3;
8216 dgst_pos1 = 4;
8217 dgst_pos2 = 2;
8218 dgst_pos3 = 1;
8219 break;
8220
8221 case 400: hash_type = HASH_TYPE_MD5;
8222 salt_type = SALT_TYPE_EMBEDDED;
8223 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8224 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8225 kern_type = KERN_TYPE_PHPASS;
8226 dgst_size = DGST_SIZE_4_4;
8227 parse_func = phpass_parse_hash;
8228 sort_by_digest = sort_by_digest_4_4;
8229 opti_type = OPTI_TYPE_ZERO_BYTE
8230 | OPTI_TYPE_SLOW_HASH_SIMD;
8231 dgst_pos0 = 0;
8232 dgst_pos1 = 1;
8233 dgst_pos2 = 2;
8234 dgst_pos3 = 3;
8235 break;
8236
8237 case 500: hash_type = HASH_TYPE_MD5;
8238 salt_type = SALT_TYPE_EMBEDDED;
8239 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8240 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8241 kern_type = KERN_TYPE_MD5CRYPT;
8242 dgst_size = DGST_SIZE_4_4;
8243 parse_func = md5crypt_parse_hash;
8244 sort_by_digest = sort_by_digest_4_4;
8245 opti_type = OPTI_TYPE_ZERO_BYTE;
8246 dgst_pos0 = 0;
8247 dgst_pos1 = 1;
8248 dgst_pos2 = 2;
8249 dgst_pos3 = 3;
8250 break;
8251
8252 case 501: hash_type = HASH_TYPE_MD5;
8253 salt_type = SALT_TYPE_EMBEDDED;
8254 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8255 opts_type = OPTS_TYPE_PT_GENERATE_LE
8256 | OPTS_TYPE_HASH_COPY;
8257 kern_type = KERN_TYPE_MD5CRYPT;
8258 dgst_size = DGST_SIZE_4_4;
8259 parse_func = juniper_parse_hash;
8260 sort_by_digest = sort_by_digest_4_4;
8261 opti_type = OPTI_TYPE_ZERO_BYTE;
8262 dgst_pos0 = 0;
8263 dgst_pos1 = 1;
8264 dgst_pos2 = 2;
8265 dgst_pos3 = 3;
8266 break;
8267
8268 case 900: hash_type = HASH_TYPE_MD4;
8269 salt_type = SALT_TYPE_NONE;
8270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8271 opts_type = OPTS_TYPE_PT_GENERATE_LE
8272 | OPTS_TYPE_PT_ADD80
8273 | OPTS_TYPE_PT_ADDBITS14;
8274 kern_type = KERN_TYPE_MD4;
8275 dgst_size = DGST_SIZE_4_4;
8276 parse_func = md4_parse_hash;
8277 sort_by_digest = sort_by_digest_4_4;
8278 opti_type = OPTI_TYPE_ZERO_BYTE
8279 | OPTI_TYPE_PRECOMPUTE_INIT
8280 | OPTI_TYPE_PRECOMPUTE_MERKLE
8281 | OPTI_TYPE_MEET_IN_MIDDLE
8282 | OPTI_TYPE_EARLY_SKIP
8283 | OPTI_TYPE_NOT_ITERATED
8284 | OPTI_TYPE_NOT_SALTED
8285 | OPTI_TYPE_RAW_HASH;
8286 dgst_pos0 = 0;
8287 dgst_pos1 = 3;
8288 dgst_pos2 = 2;
8289 dgst_pos3 = 1;
8290 break;
8291
8292 case 1000: hash_type = HASH_TYPE_MD4;
8293 salt_type = SALT_TYPE_NONE;
8294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8295 opts_type = OPTS_TYPE_PT_GENERATE_LE
8296 | OPTS_TYPE_PT_ADD80
8297 | OPTS_TYPE_PT_ADDBITS14
8298 | OPTS_TYPE_PT_UNICODE;
8299 kern_type = KERN_TYPE_MD4_PWU;
8300 dgst_size = DGST_SIZE_4_4;
8301 parse_func = md4_parse_hash;
8302 sort_by_digest = sort_by_digest_4_4;
8303 opti_type = OPTI_TYPE_ZERO_BYTE
8304 | OPTI_TYPE_PRECOMPUTE_INIT
8305 | OPTI_TYPE_PRECOMPUTE_MERKLE
8306 | OPTI_TYPE_MEET_IN_MIDDLE
8307 | OPTI_TYPE_EARLY_SKIP
8308 | OPTI_TYPE_NOT_ITERATED
8309 | OPTI_TYPE_NOT_SALTED
8310 | OPTI_TYPE_RAW_HASH;
8311 dgst_pos0 = 0;
8312 dgst_pos1 = 3;
8313 dgst_pos2 = 2;
8314 dgst_pos3 = 1;
8315 break;
8316
8317 case 1100: hash_type = HASH_TYPE_MD4;
8318 salt_type = SALT_TYPE_INTERN;
8319 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8320 opts_type = OPTS_TYPE_PT_GENERATE_LE
8321 | OPTS_TYPE_PT_ADD80
8322 | OPTS_TYPE_PT_ADDBITS14
8323 | OPTS_TYPE_PT_UNICODE
8324 | OPTS_TYPE_ST_ADD80
8325 | OPTS_TYPE_ST_UNICODE
8326 | OPTS_TYPE_ST_LOWER;
8327 kern_type = KERN_TYPE_MD44_PWUSLT;
8328 dgst_size = DGST_SIZE_4_4;
8329 parse_func = dcc_parse_hash;
8330 sort_by_digest = sort_by_digest_4_4;
8331 opti_type = OPTI_TYPE_ZERO_BYTE
8332 | OPTI_TYPE_PRECOMPUTE_INIT
8333 | OPTI_TYPE_PRECOMPUTE_MERKLE
8334 | OPTI_TYPE_EARLY_SKIP
8335 | OPTI_TYPE_NOT_ITERATED;
8336 dgst_pos0 = 0;
8337 dgst_pos1 = 3;
8338 dgst_pos2 = 2;
8339 dgst_pos3 = 1;
8340 break;
8341
8342 case 1400: hash_type = HASH_TYPE_SHA256;
8343 salt_type = SALT_TYPE_NONE;
8344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8345 opts_type = OPTS_TYPE_PT_GENERATE_BE
8346 | OPTS_TYPE_PT_ADD80
8347 | OPTS_TYPE_PT_ADDBITS15;
8348 kern_type = KERN_TYPE_SHA256;
8349 dgst_size = DGST_SIZE_4_8;
8350 parse_func = sha256_parse_hash;
8351 sort_by_digest = sort_by_digest_4_8;
8352 opti_type = OPTI_TYPE_ZERO_BYTE
8353 | OPTI_TYPE_PRECOMPUTE_INIT
8354 | OPTI_TYPE_PRECOMPUTE_MERKLE
8355 | OPTI_TYPE_EARLY_SKIP
8356 | OPTI_TYPE_NOT_ITERATED
8357 | OPTI_TYPE_NOT_SALTED
8358 | OPTI_TYPE_RAW_HASH;
8359 dgst_pos0 = 3;
8360 dgst_pos1 = 7;
8361 dgst_pos2 = 2;
8362 dgst_pos3 = 6;
8363 break;
8364
8365 case 1410: hash_type = HASH_TYPE_SHA256;
8366 salt_type = SALT_TYPE_INTERN;
8367 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8368 opts_type = OPTS_TYPE_PT_GENERATE_BE
8369 | OPTS_TYPE_ST_ADD80
8370 | OPTS_TYPE_ST_ADDBITS15;
8371 kern_type = KERN_TYPE_SHA256_PWSLT;
8372 dgst_size = DGST_SIZE_4_8;
8373 parse_func = sha256s_parse_hash;
8374 sort_by_digest = sort_by_digest_4_8;
8375 opti_type = OPTI_TYPE_ZERO_BYTE
8376 | OPTI_TYPE_PRECOMPUTE_INIT
8377 | OPTI_TYPE_PRECOMPUTE_MERKLE
8378 | OPTI_TYPE_EARLY_SKIP
8379 | OPTI_TYPE_NOT_ITERATED
8380 | OPTI_TYPE_APPENDED_SALT
8381 | OPTI_TYPE_RAW_HASH;
8382 dgst_pos0 = 3;
8383 dgst_pos1 = 7;
8384 dgst_pos2 = 2;
8385 dgst_pos3 = 6;
8386 break;
8387
8388 case 1420: hash_type = HASH_TYPE_SHA256;
8389 salt_type = SALT_TYPE_INTERN;
8390 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8391 opts_type = OPTS_TYPE_PT_GENERATE_BE
8392 | OPTS_TYPE_PT_ADD80
8393 | OPTS_TYPE_PT_ADDBITS15;
8394 kern_type = KERN_TYPE_SHA256_SLTPW;
8395 dgst_size = DGST_SIZE_4_8;
8396 parse_func = sha256s_parse_hash;
8397 sort_by_digest = sort_by_digest_4_8;
8398 opti_type = OPTI_TYPE_ZERO_BYTE
8399 | OPTI_TYPE_PRECOMPUTE_INIT
8400 | OPTI_TYPE_PRECOMPUTE_MERKLE
8401 | OPTI_TYPE_EARLY_SKIP
8402 | OPTI_TYPE_NOT_ITERATED
8403 | OPTI_TYPE_PREPENDED_SALT
8404 | OPTI_TYPE_RAW_HASH;
8405 dgst_pos0 = 3;
8406 dgst_pos1 = 7;
8407 dgst_pos2 = 2;
8408 dgst_pos3 = 6;
8409 break;
8410
8411 case 1421: hash_type = HASH_TYPE_SHA256;
8412 salt_type = SALT_TYPE_EMBEDDED;
8413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8414 opts_type = OPTS_TYPE_PT_GENERATE_BE
8415 | OPTS_TYPE_PT_ADD80
8416 | OPTS_TYPE_PT_ADDBITS15;
8417 kern_type = KERN_TYPE_SHA256_SLTPW;
8418 dgst_size = DGST_SIZE_4_8;
8419 parse_func = hmailserver_parse_hash;
8420 sort_by_digest = sort_by_digest_4_8;
8421 opti_type = OPTI_TYPE_ZERO_BYTE
8422 | OPTI_TYPE_PRECOMPUTE_INIT
8423 | OPTI_TYPE_PRECOMPUTE_MERKLE
8424 | OPTI_TYPE_EARLY_SKIP
8425 | OPTI_TYPE_NOT_ITERATED
8426 | OPTI_TYPE_PREPENDED_SALT
8427 | OPTI_TYPE_RAW_HASH;
8428 dgst_pos0 = 3;
8429 dgst_pos1 = 7;
8430 dgst_pos2 = 2;
8431 dgst_pos3 = 6;
8432 break;
8433
8434 case 1430: hash_type = HASH_TYPE_SHA256;
8435 salt_type = SALT_TYPE_INTERN;
8436 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8437 opts_type = OPTS_TYPE_PT_GENERATE_BE
8438 | OPTS_TYPE_PT_UNICODE
8439 | OPTS_TYPE_ST_ADD80
8440 | OPTS_TYPE_ST_ADDBITS15;
8441 kern_type = KERN_TYPE_SHA256_PWUSLT;
8442 dgst_size = DGST_SIZE_4_8;
8443 parse_func = sha256s_parse_hash;
8444 sort_by_digest = sort_by_digest_4_8;
8445 opti_type = OPTI_TYPE_ZERO_BYTE
8446 | OPTI_TYPE_PRECOMPUTE_INIT
8447 | OPTI_TYPE_PRECOMPUTE_MERKLE
8448 | OPTI_TYPE_EARLY_SKIP
8449 | OPTI_TYPE_NOT_ITERATED
8450 | OPTI_TYPE_APPENDED_SALT
8451 | OPTI_TYPE_RAW_HASH;
8452 dgst_pos0 = 3;
8453 dgst_pos1 = 7;
8454 dgst_pos2 = 2;
8455 dgst_pos3 = 6;
8456 break;
8457
8458 case 1440: hash_type = HASH_TYPE_SHA256;
8459 salt_type = SALT_TYPE_INTERN;
8460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8461 opts_type = OPTS_TYPE_PT_GENERATE_BE
8462 | OPTS_TYPE_PT_ADD80
8463 | OPTS_TYPE_PT_ADDBITS15
8464 | OPTS_TYPE_PT_UNICODE;
8465 kern_type = KERN_TYPE_SHA256_SLTPWU;
8466 dgst_size = DGST_SIZE_4_8;
8467 parse_func = sha256s_parse_hash;
8468 sort_by_digest = sort_by_digest_4_8;
8469 opti_type = OPTI_TYPE_ZERO_BYTE
8470 | OPTI_TYPE_PRECOMPUTE_INIT
8471 | OPTI_TYPE_PRECOMPUTE_MERKLE
8472 | OPTI_TYPE_EARLY_SKIP
8473 | OPTI_TYPE_NOT_ITERATED
8474 | OPTI_TYPE_PREPENDED_SALT
8475 | OPTI_TYPE_RAW_HASH;
8476 dgst_pos0 = 3;
8477 dgst_pos1 = 7;
8478 dgst_pos2 = 2;
8479 dgst_pos3 = 6;
8480 break;
8481
8482 case 1441: hash_type = HASH_TYPE_SHA256;
8483 salt_type = SALT_TYPE_EMBEDDED;
8484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8485 opts_type = OPTS_TYPE_PT_GENERATE_BE
8486 | OPTS_TYPE_PT_ADD80
8487 | OPTS_TYPE_PT_ADDBITS15
8488 | OPTS_TYPE_PT_UNICODE
8489 | OPTS_TYPE_ST_BASE64;
8490 kern_type = KERN_TYPE_SHA256_SLTPWU;
8491 dgst_size = DGST_SIZE_4_8;
8492 parse_func = episerver4_parse_hash;
8493 sort_by_digest = sort_by_digest_4_8;
8494 opti_type = OPTI_TYPE_ZERO_BYTE
8495 | OPTI_TYPE_PRECOMPUTE_INIT
8496 | OPTI_TYPE_PRECOMPUTE_MERKLE
8497 | OPTI_TYPE_EARLY_SKIP
8498 | OPTI_TYPE_NOT_ITERATED
8499 | OPTI_TYPE_PREPENDED_SALT
8500 | OPTI_TYPE_RAW_HASH;
8501 dgst_pos0 = 3;
8502 dgst_pos1 = 7;
8503 dgst_pos2 = 2;
8504 dgst_pos3 = 6;
8505 break;
8506
8507 case 1450: hash_type = HASH_TYPE_SHA256;
8508 salt_type = SALT_TYPE_INTERN;
8509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8510 opts_type = OPTS_TYPE_PT_GENERATE_BE
8511 | OPTS_TYPE_ST_ADD80;
8512 kern_type = KERN_TYPE_HMACSHA256_PW;
8513 dgst_size = DGST_SIZE_4_8;
8514 parse_func = hmacsha256_parse_hash;
8515 sort_by_digest = sort_by_digest_4_8;
8516 opti_type = OPTI_TYPE_ZERO_BYTE
8517 | OPTI_TYPE_NOT_ITERATED;
8518 dgst_pos0 = 3;
8519 dgst_pos1 = 7;
8520 dgst_pos2 = 2;
8521 dgst_pos3 = 6;
8522 break;
8523
8524 case 1460: hash_type = HASH_TYPE_SHA256;
8525 salt_type = SALT_TYPE_INTERN;
8526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8527 opts_type = OPTS_TYPE_PT_GENERATE_BE
8528 | OPTS_TYPE_PT_ADD80
8529 | OPTS_TYPE_PT_ADDBITS15;
8530 kern_type = KERN_TYPE_HMACSHA256_SLT;
8531 dgst_size = DGST_SIZE_4_8;
8532 parse_func = hmacsha256_parse_hash;
8533 sort_by_digest = sort_by_digest_4_8;
8534 opti_type = OPTI_TYPE_ZERO_BYTE
8535 | OPTI_TYPE_NOT_ITERATED;
8536 dgst_pos0 = 3;
8537 dgst_pos1 = 7;
8538 dgst_pos2 = 2;
8539 dgst_pos3 = 6;
8540 break;
8541
8542 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8543 salt_type = SALT_TYPE_EMBEDDED;
8544 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8545 opts_type = OPTS_TYPE_PT_GENERATE_LE
8546 | OPTS_TYPE_PT_BITSLICE;
8547 kern_type = KERN_TYPE_DESCRYPT;
8548 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8549 parse_func = descrypt_parse_hash;
8550 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8551 opti_type = OPTI_TYPE_ZERO_BYTE
8552 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8553 dgst_pos0 = 0;
8554 dgst_pos1 = 1;
8555 dgst_pos2 = 2;
8556 dgst_pos3 = 3;
8557 break;
8558
8559 case 1600: hash_type = HASH_TYPE_MD5;
8560 salt_type = SALT_TYPE_EMBEDDED;
8561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8562 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8563 kern_type = KERN_TYPE_APR1CRYPT;
8564 dgst_size = DGST_SIZE_4_4;
8565 parse_func = md5apr1_parse_hash;
8566 sort_by_digest = sort_by_digest_4_4;
8567 opti_type = OPTI_TYPE_ZERO_BYTE;
8568 dgst_pos0 = 0;
8569 dgst_pos1 = 1;
8570 dgst_pos2 = 2;
8571 dgst_pos3 = 3;
8572 break;
8573
8574 case 1700: hash_type = HASH_TYPE_SHA512;
8575 salt_type = SALT_TYPE_NONE;
8576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8577 opts_type = OPTS_TYPE_PT_GENERATE_BE
8578 | OPTS_TYPE_PT_ADD80
8579 | OPTS_TYPE_PT_ADDBITS15;
8580 kern_type = KERN_TYPE_SHA512;
8581 dgst_size = DGST_SIZE_8_8;
8582 parse_func = sha512_parse_hash;
8583 sort_by_digest = sort_by_digest_8_8;
8584 opti_type = OPTI_TYPE_ZERO_BYTE
8585 | OPTI_TYPE_PRECOMPUTE_INIT
8586 | OPTI_TYPE_PRECOMPUTE_MERKLE
8587 | OPTI_TYPE_EARLY_SKIP
8588 | OPTI_TYPE_NOT_ITERATED
8589 | OPTI_TYPE_NOT_SALTED
8590 | OPTI_TYPE_USES_BITS_64
8591 | OPTI_TYPE_RAW_HASH;
8592 dgst_pos0 = 14;
8593 dgst_pos1 = 15;
8594 dgst_pos2 = 6;
8595 dgst_pos3 = 7;
8596 break;
8597
8598 case 1710: hash_type = HASH_TYPE_SHA512;
8599 salt_type = SALT_TYPE_INTERN;
8600 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8601 opts_type = OPTS_TYPE_PT_GENERATE_BE
8602 | OPTS_TYPE_ST_ADD80
8603 | OPTS_TYPE_ST_ADDBITS15;
8604 kern_type = KERN_TYPE_SHA512_PWSLT;
8605 dgst_size = DGST_SIZE_8_8;
8606 parse_func = sha512s_parse_hash;
8607 sort_by_digest = sort_by_digest_8_8;
8608 opti_type = OPTI_TYPE_ZERO_BYTE
8609 | OPTI_TYPE_PRECOMPUTE_INIT
8610 | OPTI_TYPE_PRECOMPUTE_MERKLE
8611 | OPTI_TYPE_EARLY_SKIP
8612 | OPTI_TYPE_NOT_ITERATED
8613 | OPTI_TYPE_APPENDED_SALT
8614 | OPTI_TYPE_USES_BITS_64
8615 | OPTI_TYPE_RAW_HASH;
8616 dgst_pos0 = 14;
8617 dgst_pos1 = 15;
8618 dgst_pos2 = 6;
8619 dgst_pos3 = 7;
8620 break;
8621
8622 case 1711: hash_type = HASH_TYPE_SHA512;
8623 salt_type = SALT_TYPE_EMBEDDED;
8624 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8625 opts_type = OPTS_TYPE_PT_GENERATE_BE
8626 | OPTS_TYPE_ST_ADD80
8627 | OPTS_TYPE_ST_ADDBITS15;
8628 kern_type = KERN_TYPE_SHA512_PWSLT;
8629 dgst_size = DGST_SIZE_8_8;
8630 parse_func = sha512b64s_parse_hash;
8631 sort_by_digest = sort_by_digest_8_8;
8632 opti_type = OPTI_TYPE_ZERO_BYTE
8633 | OPTI_TYPE_PRECOMPUTE_INIT
8634 | OPTI_TYPE_PRECOMPUTE_MERKLE
8635 | OPTI_TYPE_EARLY_SKIP
8636 | OPTI_TYPE_NOT_ITERATED
8637 | OPTI_TYPE_APPENDED_SALT
8638 | OPTI_TYPE_USES_BITS_64
8639 | OPTI_TYPE_RAW_HASH;
8640 dgst_pos0 = 14;
8641 dgst_pos1 = 15;
8642 dgst_pos2 = 6;
8643 dgst_pos3 = 7;
8644 break;
8645
8646 case 1720: hash_type = HASH_TYPE_SHA512;
8647 salt_type = SALT_TYPE_INTERN;
8648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8649 opts_type = OPTS_TYPE_PT_GENERATE_BE
8650 | OPTS_TYPE_PT_ADD80
8651 | OPTS_TYPE_PT_ADDBITS15;
8652 kern_type = KERN_TYPE_SHA512_SLTPW;
8653 dgst_size = DGST_SIZE_8_8;
8654 parse_func = sha512s_parse_hash;
8655 sort_by_digest = sort_by_digest_8_8;
8656 opti_type = OPTI_TYPE_ZERO_BYTE
8657 | OPTI_TYPE_PRECOMPUTE_INIT
8658 | OPTI_TYPE_PRECOMPUTE_MERKLE
8659 | OPTI_TYPE_EARLY_SKIP
8660 | OPTI_TYPE_NOT_ITERATED
8661 | OPTI_TYPE_PREPENDED_SALT
8662 | OPTI_TYPE_USES_BITS_64
8663 | OPTI_TYPE_RAW_HASH;
8664 dgst_pos0 = 14;
8665 dgst_pos1 = 15;
8666 dgst_pos2 = 6;
8667 dgst_pos3 = 7;
8668 break;
8669
8670 case 1722: hash_type = HASH_TYPE_SHA512;
8671 salt_type = SALT_TYPE_EMBEDDED;
8672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8673 opts_type = OPTS_TYPE_PT_GENERATE_BE
8674 | OPTS_TYPE_PT_ADD80
8675 | OPTS_TYPE_PT_ADDBITS15
8676 | OPTS_TYPE_ST_HEX;
8677 kern_type = KERN_TYPE_SHA512_SLTPW;
8678 dgst_size = DGST_SIZE_8_8;
8679 parse_func = osx512_parse_hash;
8680 sort_by_digest = sort_by_digest_8_8;
8681 opti_type = OPTI_TYPE_ZERO_BYTE
8682 | OPTI_TYPE_PRECOMPUTE_INIT
8683 | OPTI_TYPE_PRECOMPUTE_MERKLE
8684 | OPTI_TYPE_EARLY_SKIP
8685 | OPTI_TYPE_NOT_ITERATED
8686 | OPTI_TYPE_PREPENDED_SALT
8687 | OPTI_TYPE_USES_BITS_64
8688 | OPTI_TYPE_RAW_HASH;
8689 dgst_pos0 = 14;
8690 dgst_pos1 = 15;
8691 dgst_pos2 = 6;
8692 dgst_pos3 = 7;
8693 break;
8694
8695 case 1730: hash_type = HASH_TYPE_SHA512;
8696 salt_type = SALT_TYPE_INTERN;
8697 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8698 opts_type = OPTS_TYPE_PT_GENERATE_BE
8699 | OPTS_TYPE_PT_UNICODE
8700 | OPTS_TYPE_ST_ADD80
8701 | OPTS_TYPE_ST_ADDBITS15;
8702 kern_type = KERN_TYPE_SHA512_PWSLTU;
8703 dgst_size = DGST_SIZE_8_8;
8704 parse_func = sha512s_parse_hash;
8705 sort_by_digest = sort_by_digest_8_8;
8706 opti_type = OPTI_TYPE_ZERO_BYTE
8707 | OPTI_TYPE_PRECOMPUTE_INIT
8708 | OPTI_TYPE_PRECOMPUTE_MERKLE
8709 | OPTI_TYPE_EARLY_SKIP
8710 | OPTI_TYPE_NOT_ITERATED
8711 | OPTI_TYPE_APPENDED_SALT
8712 | OPTI_TYPE_USES_BITS_64
8713 | OPTI_TYPE_RAW_HASH;
8714 dgst_pos0 = 14;
8715 dgst_pos1 = 15;
8716 dgst_pos2 = 6;
8717 dgst_pos3 = 7;
8718 break;
8719
8720 case 1731: hash_type = HASH_TYPE_SHA512;
8721 salt_type = SALT_TYPE_EMBEDDED;
8722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8723 opts_type = OPTS_TYPE_PT_GENERATE_BE
8724 | OPTS_TYPE_PT_UNICODE
8725 | OPTS_TYPE_ST_ADD80
8726 | OPTS_TYPE_ST_ADDBITS15
8727 | OPTS_TYPE_ST_HEX;
8728 kern_type = KERN_TYPE_SHA512_PWSLTU;
8729 dgst_size = DGST_SIZE_8_8;
8730 parse_func = mssql2012_parse_hash;
8731 sort_by_digest = sort_by_digest_8_8;
8732 opti_type = OPTI_TYPE_ZERO_BYTE
8733 | OPTI_TYPE_PRECOMPUTE_INIT
8734 | OPTI_TYPE_PRECOMPUTE_MERKLE
8735 | OPTI_TYPE_EARLY_SKIP
8736 | OPTI_TYPE_NOT_ITERATED
8737 | OPTI_TYPE_APPENDED_SALT
8738 | OPTI_TYPE_USES_BITS_64
8739 | OPTI_TYPE_RAW_HASH;
8740 dgst_pos0 = 14;
8741 dgst_pos1 = 15;
8742 dgst_pos2 = 6;
8743 dgst_pos3 = 7;
8744 break;
8745
8746 case 1740: hash_type = HASH_TYPE_SHA512;
8747 salt_type = SALT_TYPE_INTERN;
8748 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8749 opts_type = OPTS_TYPE_PT_GENERATE_BE
8750 | OPTS_TYPE_PT_ADD80
8751 | OPTS_TYPE_PT_ADDBITS15
8752 | OPTS_TYPE_PT_UNICODE;
8753 kern_type = KERN_TYPE_SHA512_SLTPWU;
8754 dgst_size = DGST_SIZE_8_8;
8755 parse_func = sha512s_parse_hash;
8756 sort_by_digest = sort_by_digest_8_8;
8757 opti_type = OPTI_TYPE_ZERO_BYTE
8758 | OPTI_TYPE_PRECOMPUTE_INIT
8759 | OPTI_TYPE_PRECOMPUTE_MERKLE
8760 | OPTI_TYPE_EARLY_SKIP
8761 | OPTI_TYPE_NOT_ITERATED
8762 | OPTI_TYPE_PREPENDED_SALT
8763 | OPTI_TYPE_USES_BITS_64
8764 | OPTI_TYPE_RAW_HASH;
8765 dgst_pos0 = 14;
8766 dgst_pos1 = 15;
8767 dgst_pos2 = 6;
8768 dgst_pos3 = 7;
8769 break;
8770
8771 case 1750: hash_type = HASH_TYPE_SHA512;
8772 salt_type = SALT_TYPE_INTERN;
8773 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8774 opts_type = OPTS_TYPE_PT_GENERATE_BE
8775 | OPTS_TYPE_ST_ADD80;
8776 kern_type = KERN_TYPE_HMACSHA512_PW;
8777 dgst_size = DGST_SIZE_8_8;
8778 parse_func = hmacsha512_parse_hash;
8779 sort_by_digest = sort_by_digest_8_8;
8780 opti_type = OPTI_TYPE_ZERO_BYTE
8781 | OPTI_TYPE_USES_BITS_64
8782 | OPTI_TYPE_NOT_ITERATED;
8783 dgst_pos0 = 14;
8784 dgst_pos1 = 15;
8785 dgst_pos2 = 6;
8786 dgst_pos3 = 7;
8787 break;
8788
8789 case 1760: hash_type = HASH_TYPE_SHA512;
8790 salt_type = SALT_TYPE_INTERN;
8791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8792 opts_type = OPTS_TYPE_PT_GENERATE_BE
8793 | OPTS_TYPE_PT_ADD80
8794 | OPTS_TYPE_PT_ADDBITS15;
8795 kern_type = KERN_TYPE_HMACSHA512_SLT;
8796 dgst_size = DGST_SIZE_8_8;
8797 parse_func = hmacsha512_parse_hash;
8798 sort_by_digest = sort_by_digest_8_8;
8799 opti_type = OPTI_TYPE_ZERO_BYTE
8800 | OPTI_TYPE_USES_BITS_64
8801 | OPTI_TYPE_NOT_ITERATED;
8802 dgst_pos0 = 14;
8803 dgst_pos1 = 15;
8804 dgst_pos2 = 6;
8805 dgst_pos3 = 7;
8806 break;
8807
8808 case 1800: hash_type = HASH_TYPE_SHA512;
8809 salt_type = SALT_TYPE_EMBEDDED;
8810 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8811 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8812 kern_type = KERN_TYPE_SHA512CRYPT;
8813 dgst_size = DGST_SIZE_8_8;
8814 parse_func = sha512crypt_parse_hash;
8815 sort_by_digest = sort_by_digest_8_8;
8816 opti_type = OPTI_TYPE_ZERO_BYTE
8817 | OPTI_TYPE_USES_BITS_64;
8818 dgst_pos0 = 0;
8819 dgst_pos1 = 1;
8820 dgst_pos2 = 2;
8821 dgst_pos3 = 3;
8822 break;
8823
8824 case 2000: hash_type = HASH_TYPE_STDOUT;
8825 salt_type = SALT_TYPE_NONE;
8826 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8827 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8828 kern_type = KERN_TYPE_STDOUT;
8829 dgst_size = DGST_SIZE_4_4;
8830 parse_func = NULL;
8831 sort_by_digest = NULL;
8832 opti_type = 0;
8833 dgst_pos0 = 0;
8834 dgst_pos1 = 0;
8835 dgst_pos2 = 0;
8836 dgst_pos3 = 0;
8837 break;
8838
8839 case 2100: hash_type = HASH_TYPE_DCC2;
8840 salt_type = SALT_TYPE_EMBEDDED;
8841 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8842 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8843 | OPTS_TYPE_ST_LOWER
8844 | OPTS_TYPE_ST_UNICODE;
8845 kern_type = KERN_TYPE_DCC2;
8846 dgst_size = DGST_SIZE_4_4;
8847 parse_func = dcc2_parse_hash;
8848 sort_by_digest = sort_by_digest_4_4;
8849 opti_type = OPTI_TYPE_ZERO_BYTE
8850 | OPTI_TYPE_SLOW_HASH_SIMD;
8851 dgst_pos0 = 0;
8852 dgst_pos1 = 1;
8853 dgst_pos2 = 2;
8854 dgst_pos3 = 3;
8855 break;
8856
8857 case 2400: hash_type = HASH_TYPE_MD5;
8858 salt_type = SALT_TYPE_NONE;
8859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8860 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8861 kern_type = KERN_TYPE_MD5PIX;
8862 dgst_size = DGST_SIZE_4_4;
8863 parse_func = md5pix_parse_hash;
8864 sort_by_digest = sort_by_digest_4_4;
8865 opti_type = OPTI_TYPE_ZERO_BYTE
8866 | OPTI_TYPE_PRECOMPUTE_INIT
8867 | OPTI_TYPE_PRECOMPUTE_MERKLE
8868 | OPTI_TYPE_EARLY_SKIP
8869 | OPTI_TYPE_NOT_ITERATED
8870 | OPTI_TYPE_NOT_SALTED;
8871 dgst_pos0 = 0;
8872 dgst_pos1 = 3;
8873 dgst_pos2 = 2;
8874 dgst_pos3 = 1;
8875 break;
8876
8877 case 2410: hash_type = HASH_TYPE_MD5;
8878 salt_type = SALT_TYPE_INTERN;
8879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8880 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8881 kern_type = KERN_TYPE_MD5ASA;
8882 dgst_size = DGST_SIZE_4_4;
8883 parse_func = md5asa_parse_hash;
8884 sort_by_digest = sort_by_digest_4_4;
8885 opti_type = OPTI_TYPE_ZERO_BYTE
8886 | OPTI_TYPE_PRECOMPUTE_INIT
8887 | OPTI_TYPE_PRECOMPUTE_MERKLE
8888 | OPTI_TYPE_EARLY_SKIP
8889 | OPTI_TYPE_NOT_ITERATED;
8890 dgst_pos0 = 0;
8891 dgst_pos1 = 3;
8892 dgst_pos2 = 2;
8893 dgst_pos3 = 1;
8894 break;
8895
8896 case 2500: hash_type = HASH_TYPE_WPA;
8897 salt_type = SALT_TYPE_EMBEDDED;
8898 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8899 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8900 kern_type = KERN_TYPE_WPA;
8901 dgst_size = DGST_SIZE_4_4;
8902 parse_func = wpa_parse_hash;
8903 sort_by_digest = sort_by_digest_4_4;
8904 opti_type = OPTI_TYPE_ZERO_BYTE
8905 | OPTI_TYPE_SLOW_HASH_SIMD;
8906 dgst_pos0 = 0;
8907 dgst_pos1 = 1;
8908 dgst_pos2 = 2;
8909 dgst_pos3 = 3;
8910 break;
8911
8912 case 2600: hash_type = HASH_TYPE_MD5;
8913 salt_type = SALT_TYPE_VIRTUAL;
8914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8915 opts_type = OPTS_TYPE_PT_GENERATE_LE
8916 | OPTS_TYPE_PT_ADD80
8917 | OPTS_TYPE_PT_ADDBITS14
8918 | OPTS_TYPE_ST_ADD80;
8919 kern_type = KERN_TYPE_MD55_PWSLT1;
8920 dgst_size = DGST_SIZE_4_4;
8921 parse_func = md5md5_parse_hash;
8922 sort_by_digest = sort_by_digest_4_4;
8923 opti_type = OPTI_TYPE_ZERO_BYTE
8924 | OPTI_TYPE_PRECOMPUTE_INIT
8925 | OPTI_TYPE_PRECOMPUTE_MERKLE
8926 | OPTI_TYPE_EARLY_SKIP;
8927 dgst_pos0 = 0;
8928 dgst_pos1 = 3;
8929 dgst_pos2 = 2;
8930 dgst_pos3 = 1;
8931 break;
8932
8933 case 2611: hash_type = HASH_TYPE_MD5;
8934 salt_type = SALT_TYPE_INTERN;
8935 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8936 opts_type = OPTS_TYPE_PT_GENERATE_LE
8937 | OPTS_TYPE_PT_ADD80
8938 | OPTS_TYPE_PT_ADDBITS14
8939 | OPTS_TYPE_ST_ADD80;
8940 kern_type = KERN_TYPE_MD55_PWSLT1;
8941 dgst_size = DGST_SIZE_4_4;
8942 parse_func = vb3_parse_hash;
8943 sort_by_digest = sort_by_digest_4_4;
8944 opti_type = OPTI_TYPE_ZERO_BYTE
8945 | OPTI_TYPE_PRECOMPUTE_INIT
8946 | OPTI_TYPE_PRECOMPUTE_MERKLE
8947 | OPTI_TYPE_EARLY_SKIP;
8948 dgst_pos0 = 0;
8949 dgst_pos1 = 3;
8950 dgst_pos2 = 2;
8951 dgst_pos3 = 1;
8952 break;
8953
8954 case 2612: hash_type = HASH_TYPE_MD5;
8955 salt_type = SALT_TYPE_EMBEDDED;
8956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8957 opts_type = OPTS_TYPE_PT_GENERATE_LE
8958 | OPTS_TYPE_PT_ADD80
8959 | OPTS_TYPE_PT_ADDBITS14
8960 | OPTS_TYPE_ST_ADD80
8961 | OPTS_TYPE_ST_HEX;
8962 kern_type = KERN_TYPE_MD55_PWSLT1;
8963 dgst_size = DGST_SIZE_4_4;
8964 parse_func = phps_parse_hash;
8965 sort_by_digest = sort_by_digest_4_4;
8966 opti_type = OPTI_TYPE_ZERO_BYTE
8967 | OPTI_TYPE_PRECOMPUTE_INIT
8968 | OPTI_TYPE_PRECOMPUTE_MERKLE
8969 | OPTI_TYPE_EARLY_SKIP;
8970 dgst_pos0 = 0;
8971 dgst_pos1 = 3;
8972 dgst_pos2 = 2;
8973 dgst_pos3 = 1;
8974 break;
8975
8976 case 2711: hash_type = HASH_TYPE_MD5;
8977 salt_type = SALT_TYPE_INTERN;
8978 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8979 opts_type = OPTS_TYPE_PT_GENERATE_LE
8980 | OPTS_TYPE_PT_ADD80
8981 | OPTS_TYPE_PT_ADDBITS14
8982 | OPTS_TYPE_ST_ADD80;
8983 kern_type = KERN_TYPE_MD55_PWSLT2;
8984 dgst_size = DGST_SIZE_4_4;
8985 parse_func = vb30_parse_hash;
8986 sort_by_digest = sort_by_digest_4_4;
8987 opti_type = OPTI_TYPE_ZERO_BYTE
8988 | OPTI_TYPE_PRECOMPUTE_INIT
8989 | OPTI_TYPE_EARLY_SKIP;
8990 dgst_pos0 = 0;
8991 dgst_pos1 = 3;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 1;
8994 break;
8995
8996 case 2811: hash_type = HASH_TYPE_MD5;
8997 salt_type = SALT_TYPE_INTERN;
8998 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE
9000 | OPTS_TYPE_PT_ADD80
9001 | OPTS_TYPE_PT_ADDBITS14;
9002 kern_type = KERN_TYPE_MD55_SLTPW;
9003 dgst_size = DGST_SIZE_4_4;
9004 parse_func = ipb2_parse_hash;
9005 sort_by_digest = sort_by_digest_4_4;
9006 opti_type = OPTI_TYPE_ZERO_BYTE
9007 | OPTI_TYPE_PRECOMPUTE_INIT
9008 | OPTI_TYPE_EARLY_SKIP;
9009 dgst_pos0 = 0;
9010 dgst_pos1 = 3;
9011 dgst_pos2 = 2;
9012 dgst_pos3 = 1;
9013 break;
9014
9015 case 3000: hash_type = HASH_TYPE_LM;
9016 salt_type = SALT_TYPE_NONE;
9017 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9018 opts_type = OPTS_TYPE_PT_GENERATE_LE
9019 | OPTS_TYPE_PT_UPPER
9020 | OPTS_TYPE_PT_BITSLICE;
9021 kern_type = KERN_TYPE_LM;
9022 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9023 parse_func = lm_parse_hash;
9024 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9025 opti_type = OPTI_TYPE_ZERO_BYTE
9026 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9027 dgst_pos0 = 0;
9028 dgst_pos1 = 1;
9029 dgst_pos2 = 2;
9030 dgst_pos3 = 3;
9031 break;
9032
9033 case 3100: hash_type = HASH_TYPE_ORACLEH;
9034 salt_type = SALT_TYPE_INTERN;
9035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9036 opts_type = OPTS_TYPE_PT_GENERATE_LE
9037 | OPTS_TYPE_PT_UPPER
9038 | OPTS_TYPE_ST_UPPER;
9039 kern_type = KERN_TYPE_ORACLEH;
9040 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9041 parse_func = oracleh_parse_hash;
9042 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9043 opti_type = OPTI_TYPE_ZERO_BYTE;
9044 dgst_pos0 = 0;
9045 dgst_pos1 = 1;
9046 dgst_pos2 = 2;
9047 dgst_pos3 = 3;
9048 break;
9049
9050 case 3200: hash_type = HASH_TYPE_BCRYPT;
9051 salt_type = SALT_TYPE_EMBEDDED;
9052 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9053 opts_type = OPTS_TYPE_PT_GENERATE_LE
9054 | OPTS_TYPE_ST_GENERATE_LE;
9055 kern_type = KERN_TYPE_BCRYPT;
9056 dgst_size = DGST_SIZE_4_6;
9057 parse_func = bcrypt_parse_hash;
9058 sort_by_digest = sort_by_digest_4_6;
9059 opti_type = OPTI_TYPE_ZERO_BYTE;
9060 dgst_pos0 = 0;
9061 dgst_pos1 = 1;
9062 dgst_pos2 = 2;
9063 dgst_pos3 = 3;
9064 break;
9065
9066 case 3710: hash_type = HASH_TYPE_MD5;
9067 salt_type = SALT_TYPE_INTERN;
9068 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9069 opts_type = OPTS_TYPE_PT_GENERATE_LE
9070 | OPTS_TYPE_PT_ADD80
9071 | OPTS_TYPE_PT_ADDBITS14;
9072 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9073 dgst_size = DGST_SIZE_4_4;
9074 parse_func = md5s_parse_hash;
9075 sort_by_digest = sort_by_digest_4_4;
9076 opti_type = OPTI_TYPE_ZERO_BYTE
9077 | OPTI_TYPE_PRECOMPUTE_INIT
9078 | OPTI_TYPE_PRECOMPUTE_MERKLE
9079 | OPTI_TYPE_EARLY_SKIP;
9080 dgst_pos0 = 0;
9081 dgst_pos1 = 3;
9082 dgst_pos2 = 2;
9083 dgst_pos3 = 1;
9084 break;
9085
9086 case 3711: hash_type = HASH_TYPE_MD5;
9087 salt_type = SALT_TYPE_EMBEDDED;
9088 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9089 opts_type = OPTS_TYPE_PT_GENERATE_LE
9090 | OPTS_TYPE_PT_ADD80
9091 | OPTS_TYPE_PT_ADDBITS14;
9092 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9093 dgst_size = DGST_SIZE_4_4;
9094 parse_func = mediawiki_b_parse_hash;
9095 sort_by_digest = sort_by_digest_4_4;
9096 opti_type = OPTI_TYPE_ZERO_BYTE
9097 | OPTI_TYPE_PRECOMPUTE_INIT
9098 | OPTI_TYPE_PRECOMPUTE_MERKLE
9099 | OPTI_TYPE_EARLY_SKIP;
9100 dgst_pos0 = 0;
9101 dgst_pos1 = 3;
9102 dgst_pos2 = 2;
9103 dgst_pos3 = 1;
9104 break;
9105
9106 case 3800: hash_type = HASH_TYPE_MD5;
9107 salt_type = SALT_TYPE_INTERN;
9108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9109 opts_type = OPTS_TYPE_PT_GENERATE_LE
9110 | OPTS_TYPE_ST_ADDBITS14;
9111 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9112 dgst_size = DGST_SIZE_4_4;
9113 parse_func = md5s_parse_hash;
9114 sort_by_digest = sort_by_digest_4_4;
9115 opti_type = OPTI_TYPE_ZERO_BYTE
9116 | OPTI_TYPE_PRECOMPUTE_INIT
9117 | OPTI_TYPE_PRECOMPUTE_MERKLE
9118 | OPTI_TYPE_EARLY_SKIP
9119 | OPTI_TYPE_NOT_ITERATED
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 4300: hash_type = HASH_TYPE_MD5;
9128 salt_type = SALT_TYPE_VIRTUAL;
9129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9130 opts_type = OPTS_TYPE_PT_GENERATE_LE
9131 | OPTS_TYPE_PT_ADD80
9132 | OPTS_TYPE_PT_ADDBITS14
9133 | OPTS_TYPE_ST_ADD80;
9134 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9135 dgst_size = DGST_SIZE_4_4;
9136 parse_func = md5md5_parse_hash;
9137 sort_by_digest = sort_by_digest_4_4;
9138 opti_type = OPTI_TYPE_ZERO_BYTE
9139 | OPTI_TYPE_PRECOMPUTE_INIT
9140 | OPTI_TYPE_PRECOMPUTE_MERKLE
9141 | OPTI_TYPE_EARLY_SKIP;
9142 dgst_pos0 = 0;
9143 dgst_pos1 = 3;
9144 dgst_pos2 = 2;
9145 dgst_pos3 = 1;
9146 break;
9147
9148
9149 case 4400: hash_type = HASH_TYPE_MD5;
9150 salt_type = SALT_TYPE_NONE;
9151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9152 opts_type = OPTS_TYPE_PT_GENERATE_BE
9153 | OPTS_TYPE_PT_ADD80
9154 | OPTS_TYPE_PT_ADDBITS15;
9155 kern_type = KERN_TYPE_MD5_SHA1;
9156 dgst_size = DGST_SIZE_4_4;
9157 parse_func = md5_parse_hash;
9158 sort_by_digest = sort_by_digest_4_4;
9159 opti_type = OPTI_TYPE_ZERO_BYTE
9160 | OPTI_TYPE_PRECOMPUTE_INIT
9161 | OPTI_TYPE_PRECOMPUTE_MERKLE
9162 | OPTI_TYPE_EARLY_SKIP
9163 | OPTI_TYPE_NOT_ITERATED
9164 | OPTI_TYPE_NOT_SALTED
9165 | OPTI_TYPE_RAW_HASH;
9166 dgst_pos0 = 0;
9167 dgst_pos1 = 3;
9168 dgst_pos2 = 2;
9169 dgst_pos3 = 1;
9170 break;
9171
9172 case 4500: hash_type = HASH_TYPE_SHA1;
9173 salt_type = SALT_TYPE_NONE;
9174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9175 opts_type = OPTS_TYPE_PT_GENERATE_BE
9176 | OPTS_TYPE_PT_ADD80
9177 | OPTS_TYPE_PT_ADDBITS15;
9178 kern_type = KERN_TYPE_SHA11;
9179 dgst_size = DGST_SIZE_4_5;
9180 parse_func = sha1_parse_hash;
9181 sort_by_digest = sort_by_digest_4_5;
9182 opti_type = OPTI_TYPE_ZERO_BYTE
9183 | OPTI_TYPE_PRECOMPUTE_INIT
9184 | OPTI_TYPE_PRECOMPUTE_MERKLE
9185 | OPTI_TYPE_EARLY_SKIP
9186 | OPTI_TYPE_NOT_SALTED;
9187 dgst_pos0 = 3;
9188 dgst_pos1 = 4;
9189 dgst_pos2 = 2;
9190 dgst_pos3 = 1;
9191 break;
9192
9193 case 4700: hash_type = HASH_TYPE_SHA1;
9194 salt_type = SALT_TYPE_NONE;
9195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9196 opts_type = OPTS_TYPE_PT_GENERATE_LE
9197 | OPTS_TYPE_PT_ADD80
9198 | OPTS_TYPE_PT_ADDBITS14;
9199 kern_type = KERN_TYPE_SHA1_MD5;
9200 dgst_size = DGST_SIZE_4_5;
9201 parse_func = sha1_parse_hash;
9202 sort_by_digest = sort_by_digest_4_5;
9203 opti_type = OPTI_TYPE_ZERO_BYTE
9204 | OPTI_TYPE_PRECOMPUTE_INIT
9205 | OPTI_TYPE_PRECOMPUTE_MERKLE
9206 | OPTI_TYPE_EARLY_SKIP
9207 | OPTI_TYPE_NOT_ITERATED
9208 | OPTI_TYPE_NOT_SALTED
9209 | OPTI_TYPE_RAW_HASH;
9210 dgst_pos0 = 3;
9211 dgst_pos1 = 4;
9212 dgst_pos2 = 2;
9213 dgst_pos3 = 1;
9214 break;
9215
9216 case 4800: hash_type = HASH_TYPE_MD5;
9217 salt_type = SALT_TYPE_EMBEDDED;
9218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9219 opts_type = OPTS_TYPE_PT_GENERATE_LE
9220 | OPTS_TYPE_PT_ADDBITS14;
9221 kern_type = KERN_TYPE_MD5_CHAP;
9222 dgst_size = DGST_SIZE_4_4;
9223 parse_func = chap_parse_hash;
9224 sort_by_digest = sort_by_digest_4_4;
9225 opti_type = OPTI_TYPE_ZERO_BYTE
9226 | OPTI_TYPE_PRECOMPUTE_INIT
9227 | OPTI_TYPE_PRECOMPUTE_MERKLE
9228 | OPTI_TYPE_MEET_IN_MIDDLE
9229 | OPTI_TYPE_EARLY_SKIP
9230 | OPTI_TYPE_NOT_ITERATED
9231 | OPTI_TYPE_RAW_HASH;
9232 dgst_pos0 = 0;
9233 dgst_pos1 = 3;
9234 dgst_pos2 = 2;
9235 dgst_pos3 = 1;
9236 break;
9237
9238 case 4900: hash_type = HASH_TYPE_SHA1;
9239 salt_type = SALT_TYPE_INTERN;
9240 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9241 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9242 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9243 dgst_size = DGST_SIZE_4_5;
9244 parse_func = sha1s_parse_hash;
9245 sort_by_digest = sort_by_digest_4_5;
9246 opti_type = OPTI_TYPE_ZERO_BYTE
9247 | OPTI_TYPE_PRECOMPUTE_INIT
9248 | OPTI_TYPE_PRECOMPUTE_MERKLE
9249 | OPTI_TYPE_EARLY_SKIP;
9250 dgst_pos0 = 3;
9251 dgst_pos1 = 4;
9252 dgst_pos2 = 2;
9253 dgst_pos3 = 1;
9254 break;
9255
9256 case 5000: hash_type = HASH_TYPE_KECCAK;
9257 salt_type = SALT_TYPE_EMBEDDED;
9258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9259 opts_type = OPTS_TYPE_PT_GENERATE_LE
9260 | OPTS_TYPE_PT_ADD01;
9261 kern_type = KERN_TYPE_KECCAK;
9262 dgst_size = DGST_SIZE_8_25;
9263 parse_func = keccak_parse_hash;
9264 sort_by_digest = sort_by_digest_8_25;
9265 opti_type = OPTI_TYPE_ZERO_BYTE
9266 | OPTI_TYPE_USES_BITS_64
9267 | OPTI_TYPE_RAW_HASH;
9268 dgst_pos0 = 2;
9269 dgst_pos1 = 3;
9270 dgst_pos2 = 4;
9271 dgst_pos3 = 5;
9272 break;
9273
9274 case 5100: hash_type = HASH_TYPE_MD5H;
9275 salt_type = SALT_TYPE_NONE;
9276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9277 opts_type = OPTS_TYPE_PT_GENERATE_LE
9278 | OPTS_TYPE_PT_ADD80
9279 | OPTS_TYPE_PT_ADDBITS14;
9280 kern_type = KERN_TYPE_MD5H;
9281 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9282 parse_func = md5half_parse_hash;
9283 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9284 opti_type = OPTI_TYPE_ZERO_BYTE
9285 | OPTI_TYPE_RAW_HASH;
9286 dgst_pos0 = 0;
9287 dgst_pos1 = 1;
9288 dgst_pos2 = 2;
9289 dgst_pos3 = 3;
9290 break;
9291
9292 case 5200: hash_type = HASH_TYPE_SHA256;
9293 salt_type = SALT_TYPE_EMBEDDED;
9294 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9295 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9296 kern_type = KERN_TYPE_PSAFE3;
9297 dgst_size = DGST_SIZE_4_8;
9298 parse_func = psafe3_parse_hash;
9299 sort_by_digest = sort_by_digest_4_8;
9300 opti_type = OPTI_TYPE_ZERO_BYTE;
9301 dgst_pos0 = 0;
9302 dgst_pos1 = 1;
9303 dgst_pos2 = 2;
9304 dgst_pos3 = 3;
9305 break;
9306
9307 case 5300: hash_type = HASH_TYPE_MD5;
9308 salt_type = SALT_TYPE_EMBEDDED;
9309 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9310 opts_type = OPTS_TYPE_PT_GENERATE_LE
9311 | OPTS_TYPE_ST_ADD80;
9312 kern_type = KERN_TYPE_IKEPSK_MD5;
9313 dgst_size = DGST_SIZE_4_4;
9314 parse_func = ikepsk_md5_parse_hash;
9315 sort_by_digest = sort_by_digest_4_4;
9316 opti_type = OPTI_TYPE_ZERO_BYTE;
9317 dgst_pos0 = 0;
9318 dgst_pos1 = 3;
9319 dgst_pos2 = 2;
9320 dgst_pos3 = 1;
9321 break;
9322
9323 case 5400: hash_type = HASH_TYPE_SHA1;
9324 salt_type = SALT_TYPE_EMBEDDED;
9325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9326 opts_type = OPTS_TYPE_PT_GENERATE_BE
9327 | OPTS_TYPE_ST_ADD80;
9328 kern_type = KERN_TYPE_IKEPSK_SHA1;
9329 dgst_size = DGST_SIZE_4_5;
9330 parse_func = ikepsk_sha1_parse_hash;
9331 sort_by_digest = sort_by_digest_4_5;
9332 opti_type = OPTI_TYPE_ZERO_BYTE;
9333 dgst_pos0 = 3;
9334 dgst_pos1 = 4;
9335 dgst_pos2 = 2;
9336 dgst_pos3 = 1;
9337 break;
9338
9339 case 5500: hash_type = HASH_TYPE_NETNTLM;
9340 salt_type = SALT_TYPE_EMBEDDED;
9341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9342 opts_type = OPTS_TYPE_PT_GENERATE_LE
9343 | OPTS_TYPE_PT_ADD80
9344 | OPTS_TYPE_PT_ADDBITS14
9345 | OPTS_TYPE_PT_UNICODE
9346 | OPTS_TYPE_ST_HEX;
9347 kern_type = KERN_TYPE_NETNTLMv1;
9348 dgst_size = DGST_SIZE_4_4;
9349 parse_func = netntlmv1_parse_hash;
9350 sort_by_digest = sort_by_digest_4_4;
9351 opti_type = OPTI_TYPE_ZERO_BYTE
9352 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9353 dgst_pos0 = 0;
9354 dgst_pos1 = 1;
9355 dgst_pos2 = 2;
9356 dgst_pos3 = 3;
9357 break;
9358
9359 case 5600: hash_type = HASH_TYPE_MD5;
9360 salt_type = SALT_TYPE_EMBEDDED;
9361 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9362 opts_type = OPTS_TYPE_PT_GENERATE_LE
9363 | OPTS_TYPE_PT_ADD80
9364 | OPTS_TYPE_PT_ADDBITS14
9365 | OPTS_TYPE_PT_UNICODE;
9366 kern_type = KERN_TYPE_NETNTLMv2;
9367 dgst_size = DGST_SIZE_4_4;
9368 parse_func = netntlmv2_parse_hash;
9369 sort_by_digest = sort_by_digest_4_4;
9370 opti_type = OPTI_TYPE_ZERO_BYTE;
9371 dgst_pos0 = 0;
9372 dgst_pos1 = 3;
9373 dgst_pos2 = 2;
9374 dgst_pos3 = 1;
9375 break;
9376
9377 case 5700: hash_type = HASH_TYPE_SHA256;
9378 salt_type = SALT_TYPE_NONE;
9379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9380 opts_type = OPTS_TYPE_PT_GENERATE_BE
9381 | OPTS_TYPE_PT_ADD80
9382 | OPTS_TYPE_PT_ADDBITS15;
9383 kern_type = KERN_TYPE_SHA256;
9384 dgst_size = DGST_SIZE_4_8;
9385 parse_func = cisco4_parse_hash;
9386 sort_by_digest = sort_by_digest_4_8;
9387 opti_type = OPTI_TYPE_ZERO_BYTE
9388 | OPTI_TYPE_PRECOMPUTE_INIT
9389 | OPTI_TYPE_PRECOMPUTE_MERKLE
9390 | OPTI_TYPE_EARLY_SKIP
9391 | OPTI_TYPE_NOT_ITERATED
9392 | OPTI_TYPE_NOT_SALTED
9393 | OPTI_TYPE_RAW_HASH;
9394 dgst_pos0 = 3;
9395 dgst_pos1 = 7;
9396 dgst_pos2 = 2;
9397 dgst_pos3 = 6;
9398 break;
9399
9400 case 5800: hash_type = HASH_TYPE_SHA1;
9401 salt_type = SALT_TYPE_INTERN;
9402 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9403 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9404 | OPTS_TYPE_ST_ADD80;
9405 kern_type = KERN_TYPE_ANDROIDPIN;
9406 dgst_size = DGST_SIZE_4_5;
9407 parse_func = androidpin_parse_hash;
9408 sort_by_digest = sort_by_digest_4_5;
9409 opti_type = OPTI_TYPE_ZERO_BYTE;
9410 dgst_pos0 = 0;
9411 dgst_pos1 = 1;
9412 dgst_pos2 = 2;
9413 dgst_pos3 = 3;
9414 break;
9415
9416 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9417 salt_type = SALT_TYPE_NONE;
9418 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9419 opts_type = OPTS_TYPE_PT_GENERATE_LE
9420 | OPTS_TYPE_PT_ADD80;
9421 kern_type = KERN_TYPE_RIPEMD160;
9422 dgst_size = DGST_SIZE_4_5;
9423 parse_func = ripemd160_parse_hash;
9424 sort_by_digest = sort_by_digest_4_5;
9425 opti_type = OPTI_TYPE_ZERO_BYTE;
9426 dgst_pos0 = 0;
9427 dgst_pos1 = 1;
9428 dgst_pos2 = 2;
9429 dgst_pos3 = 3;
9430 break;
9431
9432 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9433 salt_type = SALT_TYPE_NONE;
9434 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9435 opts_type = OPTS_TYPE_PT_GENERATE_BE
9436 | OPTS_TYPE_PT_ADD80;
9437 kern_type = KERN_TYPE_WHIRLPOOL;
9438 dgst_size = DGST_SIZE_4_16;
9439 parse_func = whirlpool_parse_hash;
9440 sort_by_digest = sort_by_digest_4_16;
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 6211: hash_type = HASH_TYPE_RIPEMD160;
9449 salt_type = SALT_TYPE_EMBEDDED;
9450 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9451 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9452 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9453 dgst_size = DGST_SIZE_4_5;
9454 parse_func = truecrypt_parse_hash_2k;
9455 sort_by_digest = sort_by_digest_4_5;
9456 opti_type = OPTI_TYPE_ZERO_BYTE;
9457 dgst_pos0 = 0;
9458 dgst_pos1 = 1;
9459 dgst_pos2 = 2;
9460 dgst_pos3 = 3;
9461 break;
9462
9463 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9464 salt_type = SALT_TYPE_EMBEDDED;
9465 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9466 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9467 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9468 dgst_size = DGST_SIZE_4_5;
9469 parse_func = truecrypt_parse_hash_2k;
9470 sort_by_digest = sort_by_digest_4_5;
9471 opti_type = OPTI_TYPE_ZERO_BYTE;
9472 dgst_pos0 = 0;
9473 dgst_pos1 = 1;
9474 dgst_pos2 = 2;
9475 dgst_pos3 = 3;
9476 break;
9477
9478 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9479 salt_type = SALT_TYPE_EMBEDDED;
9480 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9481 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9482 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9483 dgst_size = DGST_SIZE_4_5;
9484 parse_func = truecrypt_parse_hash_2k;
9485 sort_by_digest = sort_by_digest_4_5;
9486 opti_type = OPTI_TYPE_ZERO_BYTE;
9487 dgst_pos0 = 0;
9488 dgst_pos1 = 1;
9489 dgst_pos2 = 2;
9490 dgst_pos3 = 3;
9491 break;
9492
9493 case 6221: hash_type = HASH_TYPE_SHA512;
9494 salt_type = SALT_TYPE_EMBEDDED;
9495 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9496 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9497 kern_type = KERN_TYPE_TCSHA512_XTS512;
9498 dgst_size = DGST_SIZE_8_8;
9499 parse_func = truecrypt_parse_hash_1k;
9500 sort_by_digest = sort_by_digest_8_8;
9501 opti_type = OPTI_TYPE_ZERO_BYTE
9502 | OPTI_TYPE_USES_BITS_64;
9503 dgst_pos0 = 0;
9504 dgst_pos1 = 1;
9505 dgst_pos2 = 2;
9506 dgst_pos3 = 3;
9507 break;
9508
9509 case 6222: hash_type = HASH_TYPE_SHA512;
9510 salt_type = SALT_TYPE_EMBEDDED;
9511 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9512 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9513 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9514 dgst_size = DGST_SIZE_8_8;
9515 parse_func = truecrypt_parse_hash_1k;
9516 sort_by_digest = sort_by_digest_8_8;
9517 opti_type = OPTI_TYPE_ZERO_BYTE
9518 | OPTI_TYPE_USES_BITS_64;
9519 dgst_pos0 = 0;
9520 dgst_pos1 = 1;
9521 dgst_pos2 = 2;
9522 dgst_pos3 = 3;
9523 break;
9524
9525 case 6223: hash_type = HASH_TYPE_SHA512;
9526 salt_type = SALT_TYPE_EMBEDDED;
9527 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9528 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9529 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9530 dgst_size = DGST_SIZE_8_8;
9531 parse_func = truecrypt_parse_hash_1k;
9532 sort_by_digest = sort_by_digest_8_8;
9533 opti_type = OPTI_TYPE_ZERO_BYTE
9534 | OPTI_TYPE_USES_BITS_64;
9535 dgst_pos0 = 0;
9536 dgst_pos1 = 1;
9537 dgst_pos2 = 2;
9538 dgst_pos3 = 3;
9539 break;
9540
9541 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS512;
9546 dgst_size = DGST_SIZE_4_8;
9547 parse_func = truecrypt_parse_hash_1k;
9548 sort_by_digest = sort_by_digest_4_8;
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 6232: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1024;
9561 dgst_size = DGST_SIZE_4_8;
9562 parse_func = truecrypt_parse_hash_1k;
9563 sort_by_digest = sort_by_digest_4_8;
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 6233: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1536;
9576 dgst_size = DGST_SIZE_4_8;
9577 parse_func = truecrypt_parse_hash_1k;
9578 sort_by_digest = sort_by_digest_4_8;
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 6241: hash_type = HASH_TYPE_RIPEMD160;
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_TCRIPEMD160_XTS512;
9591 dgst_size = DGST_SIZE_4_5;
9592 parse_func = truecrypt_parse_hash_1k;
9593 sort_by_digest = sort_by_digest_4_5;
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 6242: hash_type = HASH_TYPE_RIPEMD160;
9602 salt_type = SALT_TYPE_EMBEDDED;
9603 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9604 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9605 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9606 dgst_size = DGST_SIZE_4_5;
9607 parse_func = truecrypt_parse_hash_1k;
9608 sort_by_digest = sort_by_digest_4_5;
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 6243: hash_type = HASH_TYPE_RIPEMD160;
9617 salt_type = SALT_TYPE_EMBEDDED;
9618 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9619 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9620 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9621 dgst_size = DGST_SIZE_4_5;
9622 parse_func = truecrypt_parse_hash_1k;
9623 sort_by_digest = sort_by_digest_4_5;
9624 opti_type = OPTI_TYPE_ZERO_BYTE;
9625 dgst_pos0 = 0;
9626 dgst_pos1 = 1;
9627 dgst_pos2 = 2;
9628 dgst_pos3 = 3;
9629 break;
9630
9631 case 6300: hash_type = HASH_TYPE_MD5;
9632 salt_type = SALT_TYPE_EMBEDDED;
9633 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9634 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9635 kern_type = KERN_TYPE_MD5AIX;
9636 dgst_size = DGST_SIZE_4_4;
9637 parse_func = md5aix_parse_hash;
9638 sort_by_digest = sort_by_digest_4_4;
9639 opti_type = OPTI_TYPE_ZERO_BYTE;
9640 dgst_pos0 = 0;
9641 dgst_pos1 = 1;
9642 dgst_pos2 = 2;
9643 dgst_pos3 = 3;
9644 break;
9645
9646 case 6400: hash_type = HASH_TYPE_SHA256;
9647 salt_type = SALT_TYPE_EMBEDDED;
9648 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9649 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9650 kern_type = KERN_TYPE_SHA256AIX;
9651 dgst_size = DGST_SIZE_4_8;
9652 parse_func = sha256aix_parse_hash;
9653 sort_by_digest = sort_by_digest_4_8;
9654 opti_type = OPTI_TYPE_ZERO_BYTE;
9655 dgst_pos0 = 0;
9656 dgst_pos1 = 1;
9657 dgst_pos2 = 2;
9658 dgst_pos3 = 3;
9659 break;
9660
9661 case 6500: hash_type = HASH_TYPE_SHA512;
9662 salt_type = SALT_TYPE_EMBEDDED;
9663 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9664 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9665 kern_type = KERN_TYPE_SHA512AIX;
9666 dgst_size = DGST_SIZE_8_8;
9667 parse_func = sha512aix_parse_hash;
9668 sort_by_digest = sort_by_digest_8_8;
9669 opti_type = OPTI_TYPE_ZERO_BYTE
9670 | OPTI_TYPE_USES_BITS_64;
9671 dgst_pos0 = 0;
9672 dgst_pos1 = 1;
9673 dgst_pos2 = 2;
9674 dgst_pos3 = 3;
9675 break;
9676
9677 case 6600: hash_type = HASH_TYPE_AES;
9678 salt_type = SALT_TYPE_EMBEDDED;
9679 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9680 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9681 kern_type = KERN_TYPE_AGILEKEY;
9682 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9683 parse_func = agilekey_parse_hash;
9684 sort_by_digest = sort_by_digest_4_5;
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 6700: hash_type = HASH_TYPE_SHA1;
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_SHA1AIX;
9697 dgst_size = DGST_SIZE_4_5;
9698 parse_func = sha1aix_parse_hash;
9699 sort_by_digest = sort_by_digest_4_5;
9700 opti_type = OPTI_TYPE_ZERO_BYTE;
9701 dgst_pos0 = 0;
9702 dgst_pos1 = 1;
9703 dgst_pos2 = 2;
9704 dgst_pos3 = 3;
9705 break;
9706
9707 case 6800: hash_type = HASH_TYPE_AES;
9708 salt_type = SALT_TYPE_EMBEDDED;
9709 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9710 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9711 kern_type = KERN_TYPE_LASTPASS;
9712 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9713 parse_func = lastpass_parse_hash;
9714 sort_by_digest = sort_by_digest_4_8;
9715 opti_type = OPTI_TYPE_ZERO_BYTE;
9716 dgst_pos0 = 0;
9717 dgst_pos1 = 1;
9718 dgst_pos2 = 2;
9719 dgst_pos3 = 3;
9720 break;
9721
9722 case 6900: hash_type = HASH_TYPE_GOST;
9723 salt_type = SALT_TYPE_NONE;
9724 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9725 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9726 kern_type = KERN_TYPE_GOST;
9727 dgst_size = DGST_SIZE_4_8;
9728 parse_func = gost_parse_hash;
9729 sort_by_digest = sort_by_digest_4_8;
9730 opti_type = OPTI_TYPE_ZERO_BYTE;
9731 dgst_pos0 = 0;
9732 dgst_pos1 = 1;
9733 dgst_pos2 = 2;
9734 dgst_pos3 = 3;
9735 break;
9736
9737 case 7100: hash_type = HASH_TYPE_SHA512;
9738 salt_type = SALT_TYPE_EMBEDDED;
9739 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9740 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9741 kern_type = KERN_TYPE_PBKDF2_SHA512;
9742 dgst_size = DGST_SIZE_8_16;
9743 parse_func = sha512osx_parse_hash;
9744 sort_by_digest = sort_by_digest_8_16;
9745 opti_type = OPTI_TYPE_ZERO_BYTE
9746 | OPTI_TYPE_USES_BITS_64
9747 | OPTI_TYPE_SLOW_HASH_SIMD;
9748 dgst_pos0 = 0;
9749 dgst_pos1 = 1;
9750 dgst_pos2 = 2;
9751 dgst_pos3 = 3;
9752 break;
9753
9754 case 7200: hash_type = HASH_TYPE_SHA512;
9755 salt_type = SALT_TYPE_EMBEDDED;
9756 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9757 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9758 kern_type = KERN_TYPE_PBKDF2_SHA512;
9759 dgst_size = DGST_SIZE_8_16;
9760 parse_func = sha512grub_parse_hash;
9761 sort_by_digest = sort_by_digest_8_16;
9762 opti_type = OPTI_TYPE_ZERO_BYTE
9763 | OPTI_TYPE_USES_BITS_64
9764 | OPTI_TYPE_SLOW_HASH_SIMD;
9765 dgst_pos0 = 0;
9766 dgst_pos1 = 1;
9767 dgst_pos2 = 2;
9768 dgst_pos3 = 3;
9769 break;
9770
9771 case 7300: hash_type = HASH_TYPE_SHA1;
9772 salt_type = SALT_TYPE_EMBEDDED;
9773 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9774 opts_type = OPTS_TYPE_PT_GENERATE_BE
9775 | OPTS_TYPE_ST_ADD80
9776 | OPTS_TYPE_ST_ADDBITS15;
9777 kern_type = KERN_TYPE_RAKP;
9778 dgst_size = DGST_SIZE_4_5;
9779 parse_func = rakp_parse_hash;
9780 sort_by_digest = sort_by_digest_4_5;
9781 opti_type = OPTI_TYPE_ZERO_BYTE
9782 | OPTI_TYPE_NOT_ITERATED;
9783 dgst_pos0 = 3;
9784 dgst_pos1 = 4;
9785 dgst_pos2 = 2;
9786 dgst_pos3 = 1;
9787 break;
9788
9789 case 7400: hash_type = HASH_TYPE_SHA256;
9790 salt_type = SALT_TYPE_EMBEDDED;
9791 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9792 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9793 kern_type = KERN_TYPE_SHA256CRYPT;
9794 dgst_size = DGST_SIZE_4_8;
9795 parse_func = sha256crypt_parse_hash;
9796 sort_by_digest = sort_by_digest_4_8;
9797 opti_type = OPTI_TYPE_ZERO_BYTE;
9798 dgst_pos0 = 0;
9799 dgst_pos1 = 1;
9800 dgst_pos2 = 2;
9801 dgst_pos3 = 3;
9802 break;
9803
9804 case 7500: hash_type = HASH_TYPE_KRB5PA;
9805 salt_type = SALT_TYPE_EMBEDDED;
9806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9807 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9808 kern_type = KERN_TYPE_KRB5PA;
9809 dgst_size = DGST_SIZE_4_4;
9810 parse_func = krb5pa_parse_hash;
9811 sort_by_digest = sort_by_digest_4_4;
9812 opti_type = OPTI_TYPE_ZERO_BYTE
9813 | OPTI_TYPE_NOT_ITERATED;
9814 dgst_pos0 = 0;
9815 dgst_pos1 = 1;
9816 dgst_pos2 = 2;
9817 dgst_pos3 = 3;
9818 break;
9819
9820 case 7600: hash_type = HASH_TYPE_SHA1;
9821 salt_type = SALT_TYPE_INTERN;
9822 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9823 opts_type = OPTS_TYPE_PT_GENERATE_BE
9824 | OPTS_TYPE_PT_ADD80
9825 | OPTS_TYPE_PT_ADDBITS15;
9826 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9827 dgst_size = DGST_SIZE_4_5;
9828 parse_func = redmine_parse_hash;
9829 sort_by_digest = sort_by_digest_4_5;
9830 opti_type = OPTI_TYPE_ZERO_BYTE
9831 | OPTI_TYPE_PRECOMPUTE_INIT
9832 | OPTI_TYPE_EARLY_SKIP
9833 | OPTI_TYPE_NOT_ITERATED
9834 | OPTI_TYPE_PREPENDED_SALT;
9835 dgst_pos0 = 3;
9836 dgst_pos1 = 4;
9837 dgst_pos2 = 2;
9838 dgst_pos3 = 1;
9839 break;
9840
9841 case 7700: hash_type = HASH_TYPE_SAPB;
9842 salt_type = SALT_TYPE_EMBEDDED;
9843 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9844 opts_type = OPTS_TYPE_PT_GENERATE_LE
9845 | OPTS_TYPE_PT_UPPER
9846 | OPTS_TYPE_ST_UPPER;
9847 kern_type = KERN_TYPE_SAPB;
9848 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9849 parse_func = sapb_parse_hash;
9850 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9851 opti_type = OPTI_TYPE_ZERO_BYTE
9852 | OPTI_TYPE_PRECOMPUTE_INIT
9853 | OPTI_TYPE_NOT_ITERATED;
9854 dgst_pos0 = 0;
9855 dgst_pos1 = 1;
9856 dgst_pos2 = 2;
9857 dgst_pos3 = 3;
9858 break;
9859
9860 case 7800: hash_type = HASH_TYPE_SAPG;
9861 salt_type = SALT_TYPE_EMBEDDED;
9862 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9863 opts_type = OPTS_TYPE_PT_GENERATE_BE
9864 | OPTS_TYPE_ST_ADD80
9865 | OPTS_TYPE_ST_UPPER;
9866 kern_type = KERN_TYPE_SAPG;
9867 dgst_size = DGST_SIZE_4_5;
9868 parse_func = sapg_parse_hash;
9869 sort_by_digest = sort_by_digest_4_5;
9870 opti_type = OPTI_TYPE_ZERO_BYTE
9871 | OPTI_TYPE_PRECOMPUTE_INIT
9872 | OPTI_TYPE_NOT_ITERATED;
9873 dgst_pos0 = 3;
9874 dgst_pos1 = 4;
9875 dgst_pos2 = 2;
9876 dgst_pos3 = 1;
9877 break;
9878
9879 case 7900: hash_type = HASH_TYPE_SHA512;
9880 salt_type = SALT_TYPE_EMBEDDED;
9881 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9882 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9883 kern_type = KERN_TYPE_DRUPAL7;
9884 dgst_size = DGST_SIZE_8_8;
9885 parse_func = drupal7_parse_hash;
9886 sort_by_digest = sort_by_digest_8_8;
9887 opti_type = OPTI_TYPE_ZERO_BYTE
9888 | OPTI_TYPE_USES_BITS_64;
9889 dgst_pos0 = 0;
9890 dgst_pos1 = 1;
9891 dgst_pos2 = 2;
9892 dgst_pos3 = 3;
9893 break;
9894
9895 case 8000: hash_type = HASH_TYPE_SHA256;
9896 salt_type = SALT_TYPE_EMBEDDED;
9897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9898 opts_type = OPTS_TYPE_PT_GENERATE_BE
9899 | OPTS_TYPE_PT_UNICODE
9900 | OPTS_TYPE_ST_ADD80
9901 | OPTS_TYPE_ST_HEX;
9902 kern_type = KERN_TYPE_SYBASEASE;
9903 dgst_size = DGST_SIZE_4_8;
9904 parse_func = sybasease_parse_hash;
9905 sort_by_digest = sort_by_digest_4_8;
9906 opti_type = OPTI_TYPE_ZERO_BYTE
9907 | OPTI_TYPE_PRECOMPUTE_INIT
9908 | OPTI_TYPE_EARLY_SKIP
9909 | OPTI_TYPE_NOT_ITERATED
9910 | OPTI_TYPE_RAW_HASH;
9911 dgst_pos0 = 3;
9912 dgst_pos1 = 7;
9913 dgst_pos2 = 2;
9914 dgst_pos3 = 6;
9915 break;
9916
9917 case 8100: hash_type = HASH_TYPE_SHA1;
9918 salt_type = SALT_TYPE_EMBEDDED;
9919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9920 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9921 kern_type = KERN_TYPE_NETSCALER;
9922 dgst_size = DGST_SIZE_4_5;
9923 parse_func = netscaler_parse_hash;
9924 sort_by_digest = sort_by_digest_4_5;
9925 opti_type = OPTI_TYPE_ZERO_BYTE
9926 | OPTI_TYPE_PRECOMPUTE_INIT
9927 | OPTI_TYPE_PRECOMPUTE_MERKLE
9928 | OPTI_TYPE_EARLY_SKIP
9929 | OPTI_TYPE_NOT_ITERATED
9930 | OPTI_TYPE_PREPENDED_SALT
9931 | OPTI_TYPE_RAW_HASH;
9932 dgst_pos0 = 3;
9933 dgst_pos1 = 4;
9934 dgst_pos2 = 2;
9935 dgst_pos3 = 1;
9936 break;
9937
9938 case 8200: hash_type = HASH_TYPE_SHA256;
9939 salt_type = SALT_TYPE_EMBEDDED;
9940 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9941 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9942 kern_type = KERN_TYPE_CLOUDKEY;
9943 dgst_size = DGST_SIZE_4_8;
9944 parse_func = cloudkey_parse_hash;
9945 sort_by_digest = sort_by_digest_4_8;
9946 opti_type = OPTI_TYPE_ZERO_BYTE;
9947 dgst_pos0 = 0;
9948 dgst_pos1 = 1;
9949 dgst_pos2 = 2;
9950 dgst_pos3 = 3;
9951 break;
9952
9953 case 8300: hash_type = HASH_TYPE_SHA1;
9954 salt_type = SALT_TYPE_EMBEDDED;
9955 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9956 opts_type = OPTS_TYPE_PT_GENERATE_BE
9957 | OPTS_TYPE_ST_HEX
9958 | OPTS_TYPE_ST_ADD80;
9959 kern_type = KERN_TYPE_NSEC3;
9960 dgst_size = DGST_SIZE_4_5;
9961 parse_func = nsec3_parse_hash;
9962 sort_by_digest = sort_by_digest_4_5;
9963 opti_type = OPTI_TYPE_ZERO_BYTE;
9964 dgst_pos0 = 3;
9965 dgst_pos1 = 4;
9966 dgst_pos2 = 2;
9967 dgst_pos3 = 1;
9968 break;
9969
9970 case 8400: hash_type = HASH_TYPE_SHA1;
9971 salt_type = SALT_TYPE_INTERN;
9972 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9973 opts_type = OPTS_TYPE_PT_GENERATE_BE
9974 | OPTS_TYPE_PT_ADD80
9975 | OPTS_TYPE_PT_ADDBITS15;
9976 kern_type = KERN_TYPE_WBB3;
9977 dgst_size = DGST_SIZE_4_5;
9978 parse_func = wbb3_parse_hash;
9979 sort_by_digest = sort_by_digest_4_5;
9980 opti_type = OPTI_TYPE_ZERO_BYTE
9981 | OPTI_TYPE_PRECOMPUTE_INIT
9982 | OPTI_TYPE_NOT_ITERATED;
9983 dgst_pos0 = 3;
9984 dgst_pos1 = 4;
9985 dgst_pos2 = 2;
9986 dgst_pos3 = 1;
9987 break;
9988
9989 case 8500: hash_type = HASH_TYPE_DESRACF;
9990 salt_type = SALT_TYPE_EMBEDDED;
9991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9992 opts_type = OPTS_TYPE_PT_GENERATE_LE
9993 | OPTS_TYPE_ST_UPPER;
9994 kern_type = KERN_TYPE_RACF;
9995 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9996 parse_func = racf_parse_hash;
9997 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9998 opti_type = OPTI_TYPE_ZERO_BYTE
9999 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10000 dgst_pos0 = 0;
10001 dgst_pos1 = 1;
10002 dgst_pos2 = 2;
10003 dgst_pos3 = 3;
10004 break;
10005
10006 case 8600: hash_type = HASH_TYPE_LOTUS5;
10007 salt_type = SALT_TYPE_NONE;
10008 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10009 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10010 kern_type = KERN_TYPE_LOTUS5;
10011 dgst_size = DGST_SIZE_4_4;
10012 parse_func = lotus5_parse_hash;
10013 sort_by_digest = sort_by_digest_4_4;
10014 opti_type = OPTI_TYPE_EARLY_SKIP
10015 | OPTI_TYPE_NOT_ITERATED
10016 | OPTI_TYPE_NOT_SALTED
10017 | OPTI_TYPE_RAW_HASH;
10018 dgst_pos0 = 0;
10019 dgst_pos1 = 1;
10020 dgst_pos2 = 2;
10021 dgst_pos3 = 3;
10022 break;
10023
10024 case 8700: hash_type = HASH_TYPE_LOTUS6;
10025 salt_type = SALT_TYPE_EMBEDDED;
10026 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10027 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10028 kern_type = KERN_TYPE_LOTUS6;
10029 dgst_size = DGST_SIZE_4_4;
10030 parse_func = lotus6_parse_hash;
10031 sort_by_digest = sort_by_digest_4_4;
10032 opti_type = OPTI_TYPE_EARLY_SKIP
10033 | OPTI_TYPE_NOT_ITERATED
10034 | OPTI_TYPE_RAW_HASH;
10035 dgst_pos0 = 0;
10036 dgst_pos1 = 1;
10037 dgst_pos2 = 2;
10038 dgst_pos3 = 3;
10039 break;
10040
10041 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
10042 salt_type = SALT_TYPE_EMBEDDED;
10043 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10044 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10045 kern_type = KERN_TYPE_ANDROIDFDE;
10046 dgst_size = DGST_SIZE_4_4;
10047 parse_func = androidfde_parse_hash;
10048 sort_by_digest = sort_by_digest_4_4;
10049 opti_type = OPTI_TYPE_ZERO_BYTE;
10050 dgst_pos0 = 0;
10051 dgst_pos1 = 1;
10052 dgst_pos2 = 2;
10053 dgst_pos3 = 3;
10054 break;
10055
10056 case 8900: hash_type = HASH_TYPE_SCRYPT;
10057 salt_type = SALT_TYPE_EMBEDDED;
10058 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10059 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10060 kern_type = KERN_TYPE_SCRYPT;
10061 dgst_size = DGST_SIZE_4_8;
10062 parse_func = scrypt_parse_hash;
10063 sort_by_digest = sort_by_digest_4_8;
10064 opti_type = OPTI_TYPE_ZERO_BYTE;
10065 dgst_pos0 = 0;
10066 dgst_pos1 = 1;
10067 dgst_pos2 = 2;
10068 dgst_pos3 = 3;
10069 break;
10070
10071 case 9000: hash_type = HASH_TYPE_SHA1;
10072 salt_type = SALT_TYPE_EMBEDDED;
10073 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10074 opts_type = OPTS_TYPE_PT_GENERATE_LE
10075 | OPTS_TYPE_ST_GENERATE_LE;
10076 kern_type = KERN_TYPE_PSAFE2;
10077 dgst_size = DGST_SIZE_4_5;
10078 parse_func = psafe2_parse_hash;
10079 sort_by_digest = sort_by_digest_4_5;
10080 opti_type = OPTI_TYPE_ZERO_BYTE;
10081 dgst_pos0 = 0;
10082 dgst_pos1 = 1;
10083 dgst_pos2 = 2;
10084 dgst_pos3 = 3;
10085 break;
10086
10087 case 9100: hash_type = HASH_TYPE_LOTUS8;
10088 salt_type = SALT_TYPE_EMBEDDED;
10089 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10090 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10091 kern_type = KERN_TYPE_LOTUS8;
10092 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10093 parse_func = lotus8_parse_hash;
10094 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10095 opti_type = OPTI_TYPE_ZERO_BYTE;
10096 dgst_pos0 = 0;
10097 dgst_pos1 = 1;
10098 dgst_pos2 = 2;
10099 dgst_pos3 = 3;
10100 break;
10101
10102 case 9200: hash_type = HASH_TYPE_SHA256;
10103 salt_type = SALT_TYPE_EMBEDDED;
10104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10105 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10106 kern_type = KERN_TYPE_PBKDF2_SHA256;
10107 dgst_size = DGST_SIZE_4_32;
10108 parse_func = cisco8_parse_hash;
10109 sort_by_digest = sort_by_digest_4_32;
10110 opti_type = OPTI_TYPE_ZERO_BYTE
10111 | OPTI_TYPE_SLOW_HASH_SIMD;
10112 dgst_pos0 = 0;
10113 dgst_pos1 = 1;
10114 dgst_pos2 = 2;
10115 dgst_pos3 = 3;
10116 break;
10117
10118 case 9300: hash_type = HASH_TYPE_SCRYPT;
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_SCRYPT;
10123 dgst_size = DGST_SIZE_4_8;
10124 parse_func = cisco9_parse_hash;
10125 sort_by_digest = sort_by_digest_4_8;
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 9400: hash_type = HASH_TYPE_OFFICE2007;
10134 salt_type = SALT_TYPE_EMBEDDED;
10135 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10136 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10137 kern_type = KERN_TYPE_OFFICE2007;
10138 dgst_size = DGST_SIZE_4_4;
10139 parse_func = office2007_parse_hash;
10140 sort_by_digest = sort_by_digest_4_4;
10141 opti_type = OPTI_TYPE_ZERO_BYTE;
10142 dgst_pos0 = 0;
10143 dgst_pos1 = 1;
10144 dgst_pos2 = 2;
10145 dgst_pos3 = 3;
10146 break;
10147
10148 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10149 salt_type = SALT_TYPE_EMBEDDED;
10150 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10151 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10152 kern_type = KERN_TYPE_OFFICE2010;
10153 dgst_size = DGST_SIZE_4_4;
10154 parse_func = office2010_parse_hash;
10155 sort_by_digest = sort_by_digest_4_4;
10156 opti_type = OPTI_TYPE_ZERO_BYTE;
10157 dgst_pos0 = 0;
10158 dgst_pos1 = 1;
10159 dgst_pos2 = 2;
10160 dgst_pos3 = 3;
10161 break;
10162
10163 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10164 salt_type = SALT_TYPE_EMBEDDED;
10165 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10166 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10167 kern_type = KERN_TYPE_OFFICE2013;
10168 dgst_size = DGST_SIZE_4_4;
10169 parse_func = office2013_parse_hash;
10170 sort_by_digest = sort_by_digest_4_4;
10171 opti_type = OPTI_TYPE_ZERO_BYTE;
10172 dgst_pos0 = 0;
10173 dgst_pos1 = 1;
10174 dgst_pos2 = 2;
10175 dgst_pos3 = 3;
10176 break;
10177
10178 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10179 salt_type = SALT_TYPE_EMBEDDED;
10180 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10181 opts_type = OPTS_TYPE_PT_GENERATE_LE
10182 | OPTS_TYPE_PT_ADD80
10183 | OPTS_TYPE_PT_UNICODE;
10184 kern_type = KERN_TYPE_OLDOFFICE01;
10185 dgst_size = DGST_SIZE_4_4;
10186 parse_func = oldoffice01_parse_hash;
10187 sort_by_digest = sort_by_digest_4_4;
10188 opti_type = OPTI_TYPE_ZERO_BYTE
10189 | OPTI_TYPE_PRECOMPUTE_INIT
10190 | OPTI_TYPE_NOT_ITERATED;
10191 dgst_pos0 = 0;
10192 dgst_pos1 = 1;
10193 dgst_pos2 = 2;
10194 dgst_pos3 = 3;
10195 break;
10196
10197 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10198 salt_type = SALT_TYPE_EMBEDDED;
10199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10200 opts_type = OPTS_TYPE_PT_GENERATE_LE
10201 | OPTS_TYPE_PT_ADD80;
10202 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10203 dgst_size = DGST_SIZE_4_4;
10204 parse_func = oldoffice01cm1_parse_hash;
10205 sort_by_digest = sort_by_digest_4_4;
10206 opti_type = OPTI_TYPE_ZERO_BYTE
10207 | OPTI_TYPE_PRECOMPUTE_INIT
10208 | OPTI_TYPE_NOT_ITERATED;
10209 dgst_pos0 = 0;
10210 dgst_pos1 = 1;
10211 dgst_pos2 = 2;
10212 dgst_pos3 = 3;
10213 break;
10214
10215 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10216 salt_type = SALT_TYPE_EMBEDDED;
10217 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10218 opts_type = OPTS_TYPE_PT_GENERATE_LE
10219 | OPTS_TYPE_PT_ADD80
10220 | OPTS_TYPE_PT_UNICODE
10221 | OPTS_TYPE_PT_NEVERCRACK;
10222 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10223 dgst_size = DGST_SIZE_4_4;
10224 parse_func = oldoffice01cm2_parse_hash;
10225 sort_by_digest = sort_by_digest_4_4;
10226 opti_type = OPTI_TYPE_ZERO_BYTE
10227 | OPTI_TYPE_PRECOMPUTE_INIT
10228 | OPTI_TYPE_NOT_ITERATED;
10229 dgst_pos0 = 0;
10230 dgst_pos1 = 1;
10231 dgst_pos2 = 2;
10232 dgst_pos3 = 3;
10233 break;
10234
10235 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10236 salt_type = SALT_TYPE_EMBEDDED;
10237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10238 opts_type = OPTS_TYPE_PT_GENERATE_BE
10239 | OPTS_TYPE_PT_ADD80
10240 | OPTS_TYPE_PT_UNICODE;
10241 kern_type = KERN_TYPE_OLDOFFICE34;
10242 dgst_size = DGST_SIZE_4_4;
10243 parse_func = oldoffice34_parse_hash;
10244 sort_by_digest = sort_by_digest_4_4;
10245 opti_type = OPTI_TYPE_ZERO_BYTE
10246 | OPTI_TYPE_PRECOMPUTE_INIT
10247 | OPTI_TYPE_NOT_ITERATED;
10248 dgst_pos0 = 0;
10249 dgst_pos1 = 1;
10250 dgst_pos2 = 2;
10251 dgst_pos3 = 3;
10252 break;
10253
10254 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10255 salt_type = SALT_TYPE_EMBEDDED;
10256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10257 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10258 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10259 dgst_size = DGST_SIZE_4_4;
10260 parse_func = oldoffice34cm1_parse_hash;
10261 sort_by_digest = sort_by_digest_4_4;
10262 opti_type = OPTI_TYPE_ZERO_BYTE
10263 | OPTI_TYPE_PRECOMPUTE_INIT
10264 | OPTI_TYPE_NOT_ITERATED;
10265 dgst_pos0 = 0;
10266 dgst_pos1 = 1;
10267 dgst_pos2 = 2;
10268 dgst_pos3 = 3;
10269 break;
10270
10271 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10272 salt_type = SALT_TYPE_EMBEDDED;
10273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10274 opts_type = OPTS_TYPE_PT_GENERATE_BE
10275 | OPTS_TYPE_PT_ADD80
10276 | OPTS_TYPE_PT_UNICODE
10277 | OPTS_TYPE_PT_NEVERCRACK;
10278 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10279 dgst_size = DGST_SIZE_4_4;
10280 parse_func = oldoffice34cm2_parse_hash;
10281 sort_by_digest = sort_by_digest_4_4;
10282 opti_type = OPTI_TYPE_ZERO_BYTE
10283 | OPTI_TYPE_PRECOMPUTE_INIT
10284 | OPTI_TYPE_NOT_ITERATED;
10285 dgst_pos0 = 0;
10286 dgst_pos1 = 1;
10287 dgst_pos2 = 2;
10288 dgst_pos3 = 3;
10289 break;
10290
10291 case 9900: hash_type = HASH_TYPE_MD5;
10292 salt_type = SALT_TYPE_NONE;
10293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10294 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10295 kern_type = KERN_TYPE_RADMIN2;
10296 dgst_size = DGST_SIZE_4_4;
10297 parse_func = radmin2_parse_hash;
10298 sort_by_digest = sort_by_digest_4_4;
10299 opti_type = OPTI_TYPE_ZERO_BYTE
10300 | OPTI_TYPE_PRECOMPUTE_INIT
10301 | OPTI_TYPE_EARLY_SKIP
10302 | OPTI_TYPE_NOT_ITERATED
10303 | OPTI_TYPE_NOT_SALTED;
10304 dgst_pos0 = 0;
10305 dgst_pos1 = 3;
10306 dgst_pos2 = 2;
10307 dgst_pos3 = 1;
10308 break;
10309
10310 case 10000: hash_type = HASH_TYPE_SHA256;
10311 salt_type = SALT_TYPE_EMBEDDED;
10312 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10313 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10314 kern_type = KERN_TYPE_PBKDF2_SHA256;
10315 dgst_size = DGST_SIZE_4_32;
10316 parse_func = djangopbkdf2_parse_hash;
10317 sort_by_digest = sort_by_digest_4_32;
10318 opti_type = OPTI_TYPE_ZERO_BYTE
10319 | OPTI_TYPE_SLOW_HASH_SIMD;
10320 dgst_pos0 = 0;
10321 dgst_pos1 = 1;
10322 dgst_pos2 = 2;
10323 dgst_pos3 = 3;
10324 break;
10325
10326 case 10100: hash_type = HASH_TYPE_SIPHASH;
10327 salt_type = SALT_TYPE_EMBEDDED;
10328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10329 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10330 kern_type = KERN_TYPE_SIPHASH;
10331 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10332 parse_func = siphash_parse_hash;
10333 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10334 opti_type = OPTI_TYPE_ZERO_BYTE
10335 | OPTI_TYPE_NOT_ITERATED
10336 | OPTI_TYPE_RAW_HASH;
10337 dgst_pos0 = 0;
10338 dgst_pos1 = 1;
10339 dgst_pos2 = 2;
10340 dgst_pos3 = 3;
10341 break;
10342
10343 case 10200: hash_type = HASH_TYPE_MD5;
10344 salt_type = SALT_TYPE_EMBEDDED;
10345 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10346 opts_type = OPTS_TYPE_PT_GENERATE_LE
10347 | OPTS_TYPE_ST_ADD80
10348 | OPTS_TYPE_ST_ADDBITS14;
10349 kern_type = KERN_TYPE_HMACMD5_PW;
10350 dgst_size = DGST_SIZE_4_4;
10351 parse_func = crammd5_parse_hash;
10352 sort_by_digest = sort_by_digest_4_4;
10353 opti_type = OPTI_TYPE_ZERO_BYTE
10354 | OPTI_TYPE_NOT_ITERATED;
10355 dgst_pos0 = 0;
10356 dgst_pos1 = 3;
10357 dgst_pos2 = 2;
10358 dgst_pos3 = 1;
10359 break;
10360
10361 case 10300: hash_type = HASH_TYPE_SHA1;
10362 salt_type = SALT_TYPE_EMBEDDED;
10363 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10364 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10365 kern_type = KERN_TYPE_SAPH_SHA1;
10366 dgst_size = DGST_SIZE_4_5;
10367 parse_func = saph_sha1_parse_hash;
10368 sort_by_digest = sort_by_digest_4_5;
10369 opti_type = OPTI_TYPE_ZERO_BYTE;
10370 dgst_pos0 = 0;
10371 dgst_pos1 = 1;
10372 dgst_pos2 = 2;
10373 dgst_pos3 = 3;
10374 break;
10375
10376 case 10400: hash_type = HASH_TYPE_PDFU16;
10377 salt_type = SALT_TYPE_EMBEDDED;
10378 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10379 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10380 kern_type = KERN_TYPE_PDF11;
10381 dgst_size = DGST_SIZE_4_4;
10382 parse_func = pdf11_parse_hash;
10383 sort_by_digest = sort_by_digest_4_4;
10384 opti_type = OPTI_TYPE_ZERO_BYTE
10385 | OPTI_TYPE_NOT_ITERATED;
10386 dgst_pos0 = 0;
10387 dgst_pos1 = 1;
10388 dgst_pos2 = 2;
10389 dgst_pos3 = 3;
10390 break;
10391
10392 case 10410: hash_type = HASH_TYPE_PDFU16;
10393 salt_type = SALT_TYPE_EMBEDDED;
10394 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10395 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10396 kern_type = KERN_TYPE_PDF11CM1;
10397 dgst_size = DGST_SIZE_4_4;
10398 parse_func = pdf11cm1_parse_hash;
10399 sort_by_digest = sort_by_digest_4_4;
10400 opti_type = OPTI_TYPE_ZERO_BYTE
10401 | OPTI_TYPE_NOT_ITERATED;
10402 dgst_pos0 = 0;
10403 dgst_pos1 = 1;
10404 dgst_pos2 = 2;
10405 dgst_pos3 = 3;
10406 break;
10407
10408 case 10420: hash_type = HASH_TYPE_PDFU16;
10409 salt_type = SALT_TYPE_EMBEDDED;
10410 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10411 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10412 kern_type = KERN_TYPE_PDF11CM2;
10413 dgst_size = DGST_SIZE_4_4;
10414 parse_func = pdf11cm2_parse_hash;
10415 sort_by_digest = sort_by_digest_4_4;
10416 opti_type = OPTI_TYPE_ZERO_BYTE
10417 | OPTI_TYPE_NOT_ITERATED;
10418 dgst_pos0 = 0;
10419 dgst_pos1 = 1;
10420 dgst_pos2 = 2;
10421 dgst_pos3 = 3;
10422 break;
10423
10424 case 10500: hash_type = HASH_TYPE_PDFU16;
10425 salt_type = SALT_TYPE_EMBEDDED;
10426 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10427 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10428 kern_type = KERN_TYPE_PDF14;
10429 dgst_size = DGST_SIZE_4_4;
10430 parse_func = pdf14_parse_hash;
10431 sort_by_digest = sort_by_digest_4_4;
10432 opti_type = OPTI_TYPE_ZERO_BYTE
10433 | OPTI_TYPE_NOT_ITERATED;
10434 dgst_pos0 = 0;
10435 dgst_pos1 = 1;
10436 dgst_pos2 = 2;
10437 dgst_pos3 = 3;
10438 break;
10439
10440 case 10600: hash_type = HASH_TYPE_SHA256;
10441 salt_type = SALT_TYPE_EMBEDDED;
10442 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10443 opts_type = OPTS_TYPE_PT_GENERATE_BE
10444 | OPTS_TYPE_ST_ADD80
10445 | OPTS_TYPE_ST_ADDBITS15
10446 | OPTS_TYPE_HASH_COPY;
10447 kern_type = KERN_TYPE_SHA256_PWSLT;
10448 dgst_size = DGST_SIZE_4_8;
10449 parse_func = pdf17l3_parse_hash;
10450 sort_by_digest = sort_by_digest_4_8;
10451 opti_type = OPTI_TYPE_ZERO_BYTE
10452 | OPTI_TYPE_PRECOMPUTE_INIT
10453 | OPTI_TYPE_PRECOMPUTE_MERKLE
10454 | OPTI_TYPE_EARLY_SKIP
10455 | OPTI_TYPE_NOT_ITERATED
10456 | OPTI_TYPE_APPENDED_SALT
10457 | OPTI_TYPE_RAW_HASH;
10458 dgst_pos0 = 3;
10459 dgst_pos1 = 7;
10460 dgst_pos2 = 2;
10461 dgst_pos3 = 6;
10462 break;
10463
10464 case 10700: hash_type = HASH_TYPE_PDFU32;
10465 salt_type = SALT_TYPE_EMBEDDED;
10466 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10467 opts_type = OPTS_TYPE_PT_GENERATE_LE
10468 | OPTS_TYPE_HASH_COPY;
10469 kern_type = KERN_TYPE_PDF17L8;
10470 dgst_size = DGST_SIZE_4_8;
10471 parse_func = pdf17l8_parse_hash;
10472 sort_by_digest = sort_by_digest_4_8;
10473 opti_type = OPTI_TYPE_ZERO_BYTE
10474 | OPTI_TYPE_NOT_ITERATED;
10475 dgst_pos0 = 0;
10476 dgst_pos1 = 1;
10477 dgst_pos2 = 2;
10478 dgst_pos3 = 3;
10479 break;
10480
10481 case 10800: hash_type = HASH_TYPE_SHA384;
10482 salt_type = SALT_TYPE_NONE;
10483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10484 opts_type = OPTS_TYPE_PT_GENERATE_BE
10485 | OPTS_TYPE_PT_ADD80
10486 | OPTS_TYPE_PT_ADDBITS15;
10487 kern_type = KERN_TYPE_SHA384;
10488 dgst_size = DGST_SIZE_8_8;
10489 parse_func = sha384_parse_hash;
10490 sort_by_digest = sort_by_digest_8_8;
10491 opti_type = OPTI_TYPE_ZERO_BYTE
10492 | OPTI_TYPE_PRECOMPUTE_INIT
10493 | OPTI_TYPE_PRECOMPUTE_MERKLE
10494 | OPTI_TYPE_EARLY_SKIP
10495 | OPTI_TYPE_NOT_ITERATED
10496 | OPTI_TYPE_NOT_SALTED
10497 | OPTI_TYPE_USES_BITS_64
10498 | OPTI_TYPE_RAW_HASH;
10499 dgst_pos0 = 6;
10500 dgst_pos1 = 7;
10501 dgst_pos2 = 4;
10502 dgst_pos3 = 5;
10503 break;
10504
10505 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10506 salt_type = SALT_TYPE_EMBEDDED;
10507 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10508 opts_type = OPTS_TYPE_PT_GENERATE_LE
10509 | OPTS_TYPE_ST_BASE64
10510 | OPTS_TYPE_HASH_COPY;
10511 kern_type = KERN_TYPE_PBKDF2_SHA256;
10512 dgst_size = DGST_SIZE_4_32;
10513 parse_func = pbkdf2_sha256_parse_hash;
10514 sort_by_digest = sort_by_digest_4_32;
10515 opti_type = OPTI_TYPE_ZERO_BYTE
10516 | OPTI_TYPE_SLOW_HASH_SIMD;
10517 dgst_pos0 = 0;
10518 dgst_pos1 = 1;
10519 dgst_pos2 = 2;
10520 dgst_pos3 = 3;
10521 break;
10522
10523 case 11000: hash_type = HASH_TYPE_MD5;
10524 salt_type = SALT_TYPE_INTERN;
10525 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10526 opts_type = OPTS_TYPE_PT_GENERATE_LE
10527 | OPTS_TYPE_PT_ADD80;
10528 kern_type = KERN_TYPE_PRESTASHOP;
10529 dgst_size = DGST_SIZE_4_4;
10530 parse_func = prestashop_parse_hash;
10531 sort_by_digest = sort_by_digest_4_4;
10532 opti_type = OPTI_TYPE_ZERO_BYTE
10533 | OPTI_TYPE_PRECOMPUTE_INIT
10534 | OPTI_TYPE_NOT_ITERATED
10535 | OPTI_TYPE_PREPENDED_SALT;
10536 dgst_pos0 = 0;
10537 dgst_pos1 = 3;
10538 dgst_pos2 = 2;
10539 dgst_pos3 = 1;
10540 break;
10541
10542 case 11100: hash_type = HASH_TYPE_MD5;
10543 salt_type = SALT_TYPE_EMBEDDED;
10544 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10545 opts_type = OPTS_TYPE_PT_GENERATE_LE
10546 | OPTS_TYPE_ST_ADD80;
10547 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10548 dgst_size = DGST_SIZE_4_4;
10549 parse_func = postgresql_auth_parse_hash;
10550 sort_by_digest = sort_by_digest_4_4;
10551 opti_type = OPTI_TYPE_ZERO_BYTE
10552 | OPTI_TYPE_PRECOMPUTE_INIT
10553 | OPTI_TYPE_PRECOMPUTE_MERKLE
10554 | OPTI_TYPE_EARLY_SKIP;
10555 dgst_pos0 = 0;
10556 dgst_pos1 = 3;
10557 dgst_pos2 = 2;
10558 dgst_pos3 = 1;
10559 break;
10560
10561 case 11200: hash_type = HASH_TYPE_SHA1;
10562 salt_type = SALT_TYPE_EMBEDDED;
10563 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10564 opts_type = OPTS_TYPE_PT_GENERATE_BE
10565 | OPTS_TYPE_PT_ADD80
10566 | OPTS_TYPE_ST_HEX;
10567 kern_type = KERN_TYPE_MYSQL_AUTH;
10568 dgst_size = DGST_SIZE_4_5;
10569 parse_func = mysql_auth_parse_hash;
10570 sort_by_digest = sort_by_digest_4_5;
10571 opti_type = OPTI_TYPE_ZERO_BYTE
10572 | OPTI_TYPE_EARLY_SKIP;
10573 dgst_pos0 = 3;
10574 dgst_pos1 = 4;
10575 dgst_pos2 = 2;
10576 dgst_pos3 = 1;
10577 break;
10578
10579 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10580 salt_type = SALT_TYPE_EMBEDDED;
10581 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10582 opts_type = OPTS_TYPE_PT_GENERATE_LE
10583 | OPTS_TYPE_ST_HEX
10584 | OPTS_TYPE_ST_ADD80;
10585 kern_type = KERN_TYPE_BITCOIN_WALLET;
10586 dgst_size = DGST_SIZE_4_4;
10587 parse_func = bitcoin_wallet_parse_hash;
10588 sort_by_digest = sort_by_digest_4_4;
10589 opti_type = OPTI_TYPE_ZERO_BYTE;
10590 dgst_pos0 = 0;
10591 dgst_pos1 = 1;
10592 dgst_pos2 = 2;
10593 dgst_pos3 = 3;
10594 break;
10595
10596 case 11400: hash_type = HASH_TYPE_MD5;
10597 salt_type = SALT_TYPE_EMBEDDED;
10598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10599 opts_type = OPTS_TYPE_PT_GENERATE_LE
10600 | OPTS_TYPE_PT_ADD80
10601 | OPTS_TYPE_HASH_COPY;
10602 kern_type = KERN_TYPE_SIP_AUTH;
10603 dgst_size = DGST_SIZE_4_4;
10604 parse_func = sip_auth_parse_hash;
10605 sort_by_digest = sort_by_digest_4_4;
10606 opti_type = OPTI_TYPE_ZERO_BYTE;
10607 dgst_pos0 = 0;
10608 dgst_pos1 = 3;
10609 dgst_pos2 = 2;
10610 dgst_pos3 = 1;
10611 break;
10612
10613 case 11500: hash_type = HASH_TYPE_CRC32;
10614 salt_type = SALT_TYPE_INTERN;
10615 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10616 opts_type = OPTS_TYPE_PT_GENERATE_LE
10617 | OPTS_TYPE_ST_GENERATE_LE
10618 | OPTS_TYPE_ST_HEX;
10619 kern_type = KERN_TYPE_CRC32;
10620 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10621 parse_func = crc32_parse_hash;
10622 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10623 opti_type = OPTI_TYPE_ZERO_BYTE;
10624 dgst_pos0 = 0;
10625 dgst_pos1 = 1;
10626 dgst_pos2 = 2;
10627 dgst_pos3 = 3;
10628 break;
10629
10630 case 11600: hash_type = HASH_TYPE_AES;
10631 salt_type = SALT_TYPE_EMBEDDED;
10632 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10633 opts_type = OPTS_TYPE_PT_GENERATE_LE
10634 | OPTS_TYPE_PT_NEVERCRACK;
10635 kern_type = KERN_TYPE_SEVEN_ZIP;
10636 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10637 parse_func = seven_zip_parse_hash;
10638 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10639 opti_type = OPTI_TYPE_ZERO_BYTE;
10640 dgst_pos0 = 0;
10641 dgst_pos1 = 1;
10642 dgst_pos2 = 2;
10643 dgst_pos3 = 3;
10644 break;
10645
10646 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10647 salt_type = SALT_TYPE_NONE;
10648 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10649 opts_type = OPTS_TYPE_PT_GENERATE_LE
10650 | OPTS_TYPE_PT_ADD01;
10651 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10652 dgst_size = DGST_SIZE_4_8;
10653 parse_func = gost2012sbog_256_parse_hash;
10654 sort_by_digest = sort_by_digest_4_8;
10655 opti_type = OPTI_TYPE_ZERO_BYTE;
10656 dgst_pos0 = 0;
10657 dgst_pos1 = 1;
10658 dgst_pos2 = 2;
10659 dgst_pos3 = 3;
10660 break;
10661
10662 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10663 salt_type = SALT_TYPE_NONE;
10664 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10665 opts_type = OPTS_TYPE_PT_GENERATE_LE
10666 | OPTS_TYPE_PT_ADD01;
10667 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10668 dgst_size = DGST_SIZE_4_16;
10669 parse_func = gost2012sbog_512_parse_hash;
10670 sort_by_digest = sort_by_digest_4_16;
10671 opti_type = OPTI_TYPE_ZERO_BYTE;
10672 dgst_pos0 = 0;
10673 dgst_pos1 = 1;
10674 dgst_pos2 = 2;
10675 dgst_pos3 = 3;
10676 break;
10677
10678 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10679 salt_type = SALT_TYPE_EMBEDDED;
10680 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10681 opts_type = OPTS_TYPE_PT_GENERATE_LE
10682 | OPTS_TYPE_ST_BASE64
10683 | OPTS_TYPE_HASH_COPY;
10684 kern_type = KERN_TYPE_PBKDF2_MD5;
10685 dgst_size = DGST_SIZE_4_32;
10686 parse_func = pbkdf2_md5_parse_hash;
10687 sort_by_digest = sort_by_digest_4_32;
10688 opti_type = OPTI_TYPE_ZERO_BYTE
10689 | OPTI_TYPE_SLOW_HASH_SIMD;
10690 dgst_pos0 = 0;
10691 dgst_pos1 = 1;
10692 dgst_pos2 = 2;
10693 dgst_pos3 = 3;
10694 break;
10695
10696 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10697 salt_type = SALT_TYPE_EMBEDDED;
10698 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10699 opts_type = OPTS_TYPE_PT_GENERATE_LE
10700 | OPTS_TYPE_ST_BASE64
10701 | OPTS_TYPE_HASH_COPY;
10702 kern_type = KERN_TYPE_PBKDF2_SHA1;
10703 dgst_size = DGST_SIZE_4_32;
10704 parse_func = pbkdf2_sha1_parse_hash;
10705 sort_by_digest = sort_by_digest_4_32;
10706 opti_type = OPTI_TYPE_ZERO_BYTE
10707 | OPTI_TYPE_SLOW_HASH_SIMD;
10708 dgst_pos0 = 0;
10709 dgst_pos1 = 1;
10710 dgst_pos2 = 2;
10711 dgst_pos3 = 3;
10712 break;
10713
10714 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10715 salt_type = SALT_TYPE_EMBEDDED;
10716 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10717 opts_type = OPTS_TYPE_PT_GENERATE_LE
10718 | OPTS_TYPE_ST_BASE64
10719 | OPTS_TYPE_HASH_COPY;
10720 kern_type = KERN_TYPE_PBKDF2_SHA512;
10721 dgst_size = DGST_SIZE_8_16;
10722 parse_func = pbkdf2_sha512_parse_hash;
10723 sort_by_digest = sort_by_digest_8_16;
10724 opti_type = OPTI_TYPE_ZERO_BYTE
10725 | OPTI_TYPE_USES_BITS_64
10726 | OPTI_TYPE_SLOW_HASH_SIMD;
10727 dgst_pos0 = 0;
10728 dgst_pos1 = 1;
10729 dgst_pos2 = 2;
10730 dgst_pos3 = 3;
10731 break;
10732
10733 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10734 salt_type = SALT_TYPE_EMBEDDED;
10735 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10736 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10737 kern_type = KERN_TYPE_ECRYPTFS;
10738 dgst_size = DGST_SIZE_8_8;
10739 parse_func = ecryptfs_parse_hash;
10740 sort_by_digest = sort_by_digest_8_8;
10741 opti_type = OPTI_TYPE_ZERO_BYTE
10742 | OPTI_TYPE_USES_BITS_64;
10743 dgst_pos0 = 0;
10744 dgst_pos1 = 1;
10745 dgst_pos2 = 2;
10746 dgst_pos3 = 3;
10747 break;
10748
10749 case 12300: hash_type = HASH_TYPE_ORACLET;
10750 salt_type = SALT_TYPE_EMBEDDED;
10751 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10752 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10753 kern_type = KERN_TYPE_ORACLET;
10754 dgst_size = DGST_SIZE_8_16;
10755 parse_func = oraclet_parse_hash;
10756 sort_by_digest = sort_by_digest_8_16;
10757 opti_type = OPTI_TYPE_ZERO_BYTE
10758 | OPTI_TYPE_USES_BITS_64;
10759 dgst_pos0 = 0;
10760 dgst_pos1 = 1;
10761 dgst_pos2 = 2;
10762 dgst_pos3 = 3;
10763 break;
10764
10765 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10766 salt_type = SALT_TYPE_EMBEDDED;
10767 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10768 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10769 kern_type = KERN_TYPE_BSDICRYPT;
10770 dgst_size = DGST_SIZE_4_4;
10771 parse_func = bsdicrypt_parse_hash;
10772 sort_by_digest = sort_by_digest_4_4;
10773 opti_type = OPTI_TYPE_ZERO_BYTE
10774 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10775 dgst_pos0 = 0;
10776 dgst_pos1 = 1;
10777 dgst_pos2 = 2;
10778 dgst_pos3 = 3;
10779 break;
10780
10781 case 12500: hash_type = HASH_TYPE_RAR3HP;
10782 salt_type = SALT_TYPE_EMBEDDED;
10783 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10784 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10785 kern_type = KERN_TYPE_RAR3;
10786 dgst_size = DGST_SIZE_4_4;
10787 parse_func = rar3hp_parse_hash;
10788 sort_by_digest = sort_by_digest_4_4;
10789 opti_type = OPTI_TYPE_ZERO_BYTE;
10790 dgst_pos0 = 0;
10791 dgst_pos1 = 1;
10792 dgst_pos2 = 2;
10793 dgst_pos3 = 3;
10794 break;
10795
10796 case 12600: hash_type = HASH_TYPE_SHA256;
10797 salt_type = SALT_TYPE_INTERN;
10798 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10799 opts_type = OPTS_TYPE_PT_GENERATE_BE
10800 | OPTS_TYPE_PT_ADD80;
10801 kern_type = KERN_TYPE_CF10;
10802 dgst_size = DGST_SIZE_4_8;
10803 parse_func = cf10_parse_hash;
10804 sort_by_digest = sort_by_digest_4_8;
10805 opti_type = OPTI_TYPE_ZERO_BYTE
10806 | OPTI_TYPE_PRECOMPUTE_INIT
10807 | OPTI_TYPE_EARLY_SKIP
10808 | OPTI_TYPE_NOT_ITERATED;
10809 dgst_pos0 = 3;
10810 dgst_pos1 = 7;
10811 dgst_pos2 = 2;
10812 dgst_pos3 = 6;
10813 break;
10814
10815 case 12700: hash_type = HASH_TYPE_AES;
10816 salt_type = SALT_TYPE_EMBEDDED;
10817 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10818 opts_type = OPTS_TYPE_PT_GENERATE_LE
10819 | OPTS_TYPE_HASH_COPY;
10820 kern_type = KERN_TYPE_MYWALLET;
10821 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10822 parse_func = mywallet_parse_hash;
10823 sort_by_digest = sort_by_digest_4_5;
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 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10832 salt_type = SALT_TYPE_EMBEDDED;
10833 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10834 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10835 kern_type = KERN_TYPE_MS_DRSR;
10836 dgst_size = DGST_SIZE_4_8;
10837 parse_func = ms_drsr_parse_hash;
10838 sort_by_digest = sort_by_digest_4_8;
10839 opti_type = OPTI_TYPE_ZERO_BYTE;
10840 dgst_pos0 = 0;
10841 dgst_pos1 = 1;
10842 dgst_pos2 = 2;
10843 dgst_pos3 = 3;
10844 break;
10845
10846 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10847 salt_type = SALT_TYPE_EMBEDDED;
10848 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10849 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10850 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10851 dgst_size = DGST_SIZE_4_8;
10852 parse_func = androidfde_samsung_parse_hash;
10853 sort_by_digest = sort_by_digest_4_8;
10854 opti_type = OPTI_TYPE_ZERO_BYTE;
10855 dgst_pos0 = 0;
10856 dgst_pos1 = 1;
10857 dgst_pos2 = 2;
10858 dgst_pos3 = 3;
10859 break;
10860
10861 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10862 salt_type = SALT_TYPE_EMBEDDED;
10863 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10864 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10865 kern_type = KERN_TYPE_RAR5;
10866 dgst_size = DGST_SIZE_4_4;
10867 parse_func = rar5_parse_hash;
10868 sort_by_digest = sort_by_digest_4_4;
10869 opti_type = OPTI_TYPE_ZERO_BYTE;
10870 dgst_pos0 = 0;
10871 dgst_pos1 = 1;
10872 dgst_pos2 = 2;
10873 dgst_pos3 = 3;
10874 break;
10875
10876 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10877 salt_type = SALT_TYPE_EMBEDDED;
10878 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10879 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10880 kern_type = KERN_TYPE_KRB5TGS;
10881 dgst_size = DGST_SIZE_4_4;
10882 parse_func = krb5tgs_parse_hash;
10883 sort_by_digest = sort_by_digest_4_4;
10884 opti_type = OPTI_TYPE_ZERO_BYTE
10885 | OPTI_TYPE_NOT_ITERATED;
10886 dgst_pos0 = 0;
10887 dgst_pos1 = 1;
10888 dgst_pos2 = 2;
10889 dgst_pos3 = 3;
10890 break;
10891
10892 case 13200: hash_type = HASH_TYPE_AES;
10893 salt_type = SALT_TYPE_EMBEDDED;
10894 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10895 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10896 kern_type = KERN_TYPE_AXCRYPT;
10897 dgst_size = DGST_SIZE_4_4;
10898 parse_func = axcrypt_parse_hash;
10899 sort_by_digest = sort_by_digest_4_4;
10900 opti_type = OPTI_TYPE_ZERO_BYTE;
10901 dgst_pos0 = 0;
10902 dgst_pos1 = 1;
10903 dgst_pos2 = 2;
10904 dgst_pos3 = 3;
10905 break;
10906
10907 case 13300: hash_type = HASH_TYPE_SHA1;
10908 salt_type = SALT_TYPE_NONE;
10909 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10910 opts_type = OPTS_TYPE_PT_GENERATE_BE
10911 | OPTS_TYPE_PT_ADD80
10912 | OPTS_TYPE_PT_ADDBITS15;
10913 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10914 dgst_size = DGST_SIZE_4_5;
10915 parse_func = sha1axcrypt_parse_hash;
10916 sort_by_digest = sort_by_digest_4_5;
10917 opti_type = OPTI_TYPE_ZERO_BYTE
10918 | OPTI_TYPE_PRECOMPUTE_INIT
10919 | OPTI_TYPE_EARLY_SKIP
10920 | OPTI_TYPE_NOT_ITERATED
10921 | OPTI_TYPE_NOT_SALTED;
10922 dgst_pos0 = 0;
10923 dgst_pos1 = 4;
10924 dgst_pos2 = 3;
10925 dgst_pos3 = 2;
10926 break;
10927
10928 case 13400: hash_type = HASH_TYPE_AES;
10929 salt_type = SALT_TYPE_EMBEDDED;
10930 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10931 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10932 kern_type = KERN_TYPE_KEEPASS;
10933 dgst_size = DGST_SIZE_4_4;
10934 parse_func = keepass_parse_hash;
10935 sort_by_digest = sort_by_digest_4_4;
10936 opti_type = OPTI_TYPE_ZERO_BYTE;
10937 dgst_pos0 = 0;
10938 dgst_pos1 = 1;
10939 dgst_pos2 = 2;
10940 dgst_pos3 = 3;
10941 break;
10942
10943 case 13500: hash_type = HASH_TYPE_SHA1;
10944 salt_type = SALT_TYPE_EMBEDDED;
10945 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10946 opts_type = OPTS_TYPE_PT_GENERATE_BE
10947 | OPTS_TYPE_PT_UNICODE
10948 | OPTS_TYPE_PT_ADD80;
10949 kern_type = KERN_TYPE_PSTOKEN;
10950 dgst_size = DGST_SIZE_4_5;
10951 parse_func = pstoken_parse_hash;
10952 sort_by_digest = sort_by_digest_4_5;
10953 opti_type = OPTI_TYPE_ZERO_BYTE
10954 | OPTI_TYPE_PRECOMPUTE_INIT
10955 | OPTI_TYPE_EARLY_SKIP
10956 | OPTI_TYPE_NOT_ITERATED
10957 | OPTI_TYPE_PREPENDED_SALT
10958 | OPTI_TYPE_RAW_HASH;
10959 dgst_pos0 = 3;
10960 dgst_pos1 = 4;
10961 dgst_pos2 = 2;
10962 dgst_pos3 = 1;
10963 break;
10964
10965 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
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_ZIP2;
10970 dgst_size = DGST_SIZE_4_4;
10971 parse_func = zip2_parse_hash;
10972 sort_by_digest = sort_by_digest_4_4;
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 13711: hash_type = HASH_TYPE_RIPEMD160;
10981 salt_type = SALT_TYPE_EMBEDDED;
10982 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10983 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10984 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10985 dgst_size = DGST_SIZE_4_5;
10986 parse_func = veracrypt_parse_hash_655331;
10987 sort_by_digest = sort_by_digest_4_5;
10988 opti_type = OPTI_TYPE_ZERO_BYTE;
10989 dgst_pos0 = 0;
10990 dgst_pos1 = 1;
10991 dgst_pos2 = 2;
10992 dgst_pos3 = 3;
10993 break;
10994
10995 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10996 salt_type = SALT_TYPE_EMBEDDED;
10997 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10998 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10999 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11000 dgst_size = DGST_SIZE_4_5;
11001 parse_func = veracrypt_parse_hash_655331;
11002 sort_by_digest = sort_by_digest_4_5;
11003 opti_type = OPTI_TYPE_ZERO_BYTE;
11004 dgst_pos0 = 0;
11005 dgst_pos1 = 1;
11006 dgst_pos2 = 2;
11007 dgst_pos3 = 3;
11008 break;
11009
11010 case 13713: hash_type = HASH_TYPE_RIPEMD160;
11011 salt_type = SALT_TYPE_EMBEDDED;
11012 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11013 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11014 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11015 dgst_size = DGST_SIZE_4_5;
11016 parse_func = veracrypt_parse_hash_655331;
11017 sort_by_digest = sort_by_digest_4_5;
11018 opti_type = OPTI_TYPE_ZERO_BYTE;
11019 dgst_pos0 = 0;
11020 dgst_pos1 = 1;
11021 dgst_pos2 = 2;
11022 dgst_pos3 = 3;
11023 break;
11024
11025 case 13721: hash_type = HASH_TYPE_SHA512;
11026 salt_type = SALT_TYPE_EMBEDDED;
11027 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11028 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11029 kern_type = KERN_TYPE_TCSHA512_XTS512;
11030 dgst_size = DGST_SIZE_8_8;
11031 parse_func = veracrypt_parse_hash_500000;
11032 sort_by_digest = sort_by_digest_8_8;
11033 opti_type = OPTI_TYPE_ZERO_BYTE
11034 | OPTI_TYPE_USES_BITS_64;
11035 dgst_pos0 = 0;
11036 dgst_pos1 = 1;
11037 dgst_pos2 = 2;
11038 dgst_pos3 = 3;
11039 break;
11040
11041 case 13722: hash_type = HASH_TYPE_SHA512;
11042 salt_type = SALT_TYPE_EMBEDDED;
11043 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11044 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11045 kern_type = KERN_TYPE_TCSHA512_XTS1024;
11046 dgst_size = DGST_SIZE_8_8;
11047 parse_func = veracrypt_parse_hash_500000;
11048 sort_by_digest = sort_by_digest_8_8;
11049 opti_type = OPTI_TYPE_ZERO_BYTE
11050 | OPTI_TYPE_USES_BITS_64;
11051 dgst_pos0 = 0;
11052 dgst_pos1 = 1;
11053 dgst_pos2 = 2;
11054 dgst_pos3 = 3;
11055 break;
11056
11057 case 13723: hash_type = HASH_TYPE_SHA512;
11058 salt_type = SALT_TYPE_EMBEDDED;
11059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11060 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11061 kern_type = KERN_TYPE_TCSHA512_XTS1536;
11062 dgst_size = DGST_SIZE_8_8;
11063 parse_func = veracrypt_parse_hash_500000;
11064 sort_by_digest = sort_by_digest_8_8;
11065 opti_type = OPTI_TYPE_ZERO_BYTE
11066 | OPTI_TYPE_USES_BITS_64;
11067 dgst_pos0 = 0;
11068 dgst_pos1 = 1;
11069 dgst_pos2 = 2;
11070 dgst_pos3 = 3;
11071 break;
11072
11073 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS512;
11078 dgst_size = DGST_SIZE_4_8;
11079 parse_func = veracrypt_parse_hash_500000;
11080 sort_by_digest = sort_by_digest_4_8;
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 13732: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1024;
11093 dgst_size = DGST_SIZE_4_8;
11094 parse_func = veracrypt_parse_hash_500000;
11095 sort_by_digest = sort_by_digest_4_8;
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 13733: hash_type = HASH_TYPE_WHIRLPOOL;
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_TCWHIRLPOOL_XTS1536;
11108 dgst_size = DGST_SIZE_4_8;
11109 parse_func = veracrypt_parse_hash_500000;
11110 sort_by_digest = sort_by_digest_4_8;
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 13741: hash_type = HASH_TYPE_RIPEMD160;
11119 salt_type = SALT_TYPE_EMBEDDED;
11120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11121 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11122 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11123 dgst_size = DGST_SIZE_4_5;
11124 parse_func = veracrypt_parse_hash_327661;
11125 sort_by_digest = sort_by_digest_4_5;
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 13742: hash_type = HASH_TYPE_RIPEMD160;
11134 salt_type = SALT_TYPE_EMBEDDED;
11135 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11136 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11137 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11138 dgst_size = DGST_SIZE_4_5;
11139 parse_func = veracrypt_parse_hash_327661;
11140 sort_by_digest = sort_by_digest_4_5;
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 13743: hash_type = HASH_TYPE_RIPEMD160;
11149 salt_type = SALT_TYPE_EMBEDDED;
11150 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11151 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11152 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11153 dgst_size = DGST_SIZE_4_5;
11154 parse_func = veracrypt_parse_hash_327661;
11155 sort_by_digest = sort_by_digest_4_5;
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 13751: 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_500000;
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 13752: 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_500000;
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 13753: 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_500000;
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 13761: hash_type = HASH_TYPE_SHA256;
11209 salt_type = SALT_TYPE_EMBEDDED;
11210 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11211 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11212 kern_type = KERN_TYPE_VCSHA256_XTS512;
11213 dgst_size = DGST_SIZE_4_8;
11214 parse_func = veracrypt_parse_hash_200000;
11215 sort_by_digest = sort_by_digest_4_8;
11216 opti_type = OPTI_TYPE_ZERO_BYTE;
11217 dgst_pos0 = 0;
11218 dgst_pos1 = 1;
11219 dgst_pos2 = 2;
11220 dgst_pos3 = 3;
11221 break;
11222
11223 case 13762: hash_type = HASH_TYPE_SHA256;
11224 salt_type = SALT_TYPE_EMBEDDED;
11225 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11226 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11227 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11228 dgst_size = DGST_SIZE_4_8;
11229 parse_func = veracrypt_parse_hash_200000;
11230 sort_by_digest = sort_by_digest_4_8;
11231 opti_type = OPTI_TYPE_ZERO_BYTE;
11232 dgst_pos0 = 0;
11233 dgst_pos1 = 1;
11234 dgst_pos2 = 2;
11235 dgst_pos3 = 3;
11236 break;
11237
11238 case 13763: hash_type = HASH_TYPE_SHA256;
11239 salt_type = SALT_TYPE_EMBEDDED;
11240 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11241 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11242 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11243 dgst_size = DGST_SIZE_4_8;
11244 parse_func = veracrypt_parse_hash_200000;
11245 sort_by_digest = sort_by_digest_4_8;
11246 opti_type = OPTI_TYPE_ZERO_BYTE;
11247 dgst_pos0 = 0;
11248 dgst_pos1 = 1;
11249 dgst_pos2 = 2;
11250 dgst_pos3 = 3;
11251 break;
11252
11253 case 13800: hash_type = HASH_TYPE_SHA256;
11254 salt_type = SALT_TYPE_EMBEDDED;
11255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11256 opts_type = OPTS_TYPE_PT_GENERATE_BE
11257 | OPTS_TYPE_PT_UNICODE;
11258 kern_type = KERN_TYPE_WIN8PHONE;
11259 dgst_size = DGST_SIZE_4_8;
11260 parse_func = win8phone_parse_hash;
11261 sort_by_digest = sort_by_digest_4_8;
11262 opti_type = OPTI_TYPE_ZERO_BYTE
11263 | OPTI_TYPE_PRECOMPUTE_INIT
11264 | OPTI_TYPE_EARLY_SKIP
11265 | OPTI_TYPE_NOT_ITERATED
11266 | OPTI_TYPE_RAW_HASH;
11267 dgst_pos0 = 3;
11268 dgst_pos1 = 7;
11269 dgst_pos2 = 2;
11270 dgst_pos3 = 6;
11271 break;
11272
11273 default: usage_mini_print (PROGNAME); return (-1);
11274 }
11275
11276 /**
11277 * parser
11278 */
11279
11280 data.parse_func = parse_func;
11281
11282 /**
11283 * misc stuff
11284 */
11285
11286 if (hex_salt)
11287 {
11288 if (salt_type == SALT_TYPE_INTERN)
11289 {
11290 opts_type |= OPTS_TYPE_ST_HEX;
11291 }
11292 else
11293 {
11294 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11295
11296 return (-1);
11297 }
11298 }
11299
11300 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11301 | (salt_type == SALT_TYPE_EXTERN)
11302 | (salt_type == SALT_TYPE_EMBEDDED)
11303 | (salt_type == SALT_TYPE_VIRTUAL));
11304
11305 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11306
11307 data.hash_type = hash_type;
11308 data.attack_mode = attack_mode;
11309 data.attack_kern = attack_kern;
11310 data.attack_exec = attack_exec;
11311 data.kern_type = kern_type;
11312 data.opts_type = opts_type;
11313 data.dgst_size = dgst_size;
11314 data.salt_type = salt_type;
11315 data.isSalted = isSalted;
11316 data.sort_by_digest = sort_by_digest;
11317 data.dgst_pos0 = dgst_pos0;
11318 data.dgst_pos1 = dgst_pos1;
11319 data.dgst_pos2 = dgst_pos2;
11320 data.dgst_pos3 = dgst_pos3;
11321
11322 esalt_size = 0;
11323
11324 switch (hash_mode)
11325 {
11326 case 2500: esalt_size = sizeof (wpa_t); break;
11327 case 5300: esalt_size = sizeof (ikepsk_t); break;
11328 case 5400: esalt_size = sizeof (ikepsk_t); break;
11329 case 5500: esalt_size = sizeof (netntlm_t); break;
11330 case 5600: esalt_size = sizeof (netntlm_t); break;
11331 case 6211: esalt_size = sizeof (tc_t); break;
11332 case 6212: esalt_size = sizeof (tc_t); break;
11333 case 6213: esalt_size = sizeof (tc_t); break;
11334 case 6221: esalt_size = sizeof (tc_t); break;
11335 case 6222: esalt_size = sizeof (tc_t); break;
11336 case 6223: esalt_size = sizeof (tc_t); break;
11337 case 6231: esalt_size = sizeof (tc_t); break;
11338 case 6232: esalt_size = sizeof (tc_t); break;
11339 case 6233: esalt_size = sizeof (tc_t); break;
11340 case 6241: esalt_size = sizeof (tc_t); break;
11341 case 6242: esalt_size = sizeof (tc_t); break;
11342 case 6243: esalt_size = sizeof (tc_t); break;
11343 case 6600: esalt_size = sizeof (agilekey_t); break;
11344 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11345 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11346 case 7300: esalt_size = sizeof (rakp_t); break;
11347 case 7500: esalt_size = sizeof (krb5pa_t); break;
11348 case 8200: esalt_size = sizeof (cloudkey_t); break;
11349 case 8800: esalt_size = sizeof (androidfde_t); break;
11350 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11351 case 9400: esalt_size = sizeof (office2007_t); break;
11352 case 9500: esalt_size = sizeof (office2010_t); break;
11353 case 9600: esalt_size = sizeof (office2013_t); break;
11354 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11355 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11356 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11357 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11358 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11359 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11360 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11361 case 10200: esalt_size = sizeof (cram_md5_t); break;
11362 case 10400: esalt_size = sizeof (pdf_t); break;
11363 case 10410: esalt_size = sizeof (pdf_t); break;
11364 case 10420: esalt_size = sizeof (pdf_t); break;
11365 case 10500: esalt_size = sizeof (pdf_t); break;
11366 case 10600: esalt_size = sizeof (pdf_t); break;
11367 case 10700: esalt_size = sizeof (pdf_t); break;
11368 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11369 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11370 case 11400: esalt_size = sizeof (sip_t); break;
11371 case 11600: esalt_size = sizeof (seven_zip_t); break;
11372 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11373 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11374 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11375 case 13000: esalt_size = sizeof (rar5_t); break;
11376 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11377 case 13400: esalt_size = sizeof (keepass_t); break;
11378 case 13500: esalt_size = sizeof (pstoken_t); break;
11379 case 13600: esalt_size = sizeof (zip2_t); break;
11380 case 13711: esalt_size = sizeof (tc_t); break;
11381 case 13712: esalt_size = sizeof (tc_t); break;
11382 case 13713: esalt_size = sizeof (tc_t); break;
11383 case 13721: esalt_size = sizeof (tc_t); break;
11384 case 13722: esalt_size = sizeof (tc_t); break;
11385 case 13723: esalt_size = sizeof (tc_t); break;
11386 case 13731: esalt_size = sizeof (tc_t); break;
11387 case 13732: esalt_size = sizeof (tc_t); break;
11388 case 13733: esalt_size = sizeof (tc_t); break;
11389 case 13741: esalt_size = sizeof (tc_t); break;
11390 case 13742: esalt_size = sizeof (tc_t); break;
11391 case 13743: esalt_size = sizeof (tc_t); break;
11392 case 13751: esalt_size = sizeof (tc_t); break;
11393 case 13752: esalt_size = sizeof (tc_t); break;
11394 case 13753: esalt_size = sizeof (tc_t); break;
11395 case 13761: esalt_size = sizeof (tc_t); break;
11396 case 13762: esalt_size = sizeof (tc_t); break;
11397 case 13763: esalt_size = sizeof (tc_t); break;
11398 case 13800: esalt_size = sizeof (win8phone_t); break;
11399 }
11400
11401 data.esalt_size = esalt_size;
11402
11403 /**
11404 * choose dictionary parser
11405 */
11406
11407 if (hash_type == HASH_TYPE_LM)
11408 {
11409 get_next_word_func = get_next_word_lm;
11410 }
11411 else if (opts_type & OPTS_TYPE_PT_UPPER)
11412 {
11413 get_next_word_func = get_next_word_uc;
11414 }
11415 else
11416 {
11417 get_next_word_func = get_next_word_std;
11418 }
11419
11420 /**
11421 * dictstat
11422 */
11423
11424 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11425
11426 #ifdef _POSIX
11427 size_t dictstat_nmemb = 0;
11428 #endif
11429
11430 #ifdef _WIN
11431 uint dictstat_nmemb = 0;
11432 #endif
11433
11434 char dictstat[256] = { 0 };
11435
11436 FILE *dictstat_fp = NULL;
11437
11438 if (keyspace == 0)
11439 {
11440 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11441
11442 dictstat_fp = fopen (dictstat, "rb");
11443
11444 if (dictstat_fp)
11445 {
11446 #ifdef _POSIX
11447 struct stat tmpstat;
11448
11449 fstat (fileno (dictstat_fp), &tmpstat);
11450 #endif
11451
11452 #ifdef _WIN
11453 struct stat64 tmpstat;
11454
11455 _fstat64 (fileno (dictstat_fp), &tmpstat);
11456 #endif
11457
11458 if (tmpstat.st_mtime < COMPTIME)
11459 {
11460 /* with v0.15 the format changed so we have to ensure user is using a good version
11461 since there is no version-header in the dictstat file */
11462
11463 fclose (dictstat_fp);
11464
11465 unlink (dictstat);
11466 }
11467 else
11468 {
11469 while (!feof (dictstat_fp))
11470 {
11471 dictstat_t d;
11472
11473 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11474
11475 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11476
11477 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11478 {
11479 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11480
11481 return -1;
11482 }
11483 }
11484
11485 fclose (dictstat_fp);
11486 }
11487 }
11488 }
11489
11490 /**
11491 * potfile
11492 */
11493
11494 char potfile[256] = { 0 };
11495
11496 if (potfile_path == NULL)
11497 {
11498 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11499 }
11500 else
11501 {
11502 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11503 }
11504
11505 data.pot_fp = NULL;
11506
11507 FILE *out_fp = NULL;
11508 FILE *pot_fp = NULL;
11509
11510 if (show == 1 || left == 1)
11511 {
11512 pot_fp = fopen (potfile, "rb");
11513
11514 if (pot_fp == NULL)
11515 {
11516 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11517
11518 return (-1);
11519 }
11520
11521 if (outfile != NULL)
11522 {
11523 if ((out_fp = fopen (outfile, "ab")) == NULL)
11524 {
11525 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11526
11527 fclose (pot_fp);
11528
11529 return (-1);
11530 }
11531 }
11532 else
11533 {
11534 out_fp = stdout;
11535 }
11536 }
11537 else
11538 {
11539 if (potfile_disable == 0)
11540 {
11541 pot_fp = fopen (potfile, "ab");
11542
11543 if (pot_fp == NULL)
11544 {
11545 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11546
11547 return (-1);
11548 }
11549
11550 data.pot_fp = pot_fp;
11551 }
11552 }
11553
11554 pot_t *pot = NULL;
11555
11556 uint pot_cnt = 0;
11557 uint pot_avail = 0;
11558
11559 if (show == 1 || left == 1)
11560 {
11561 SUPPRESS_OUTPUT = 1;
11562
11563 pot_avail = count_lines (pot_fp);
11564
11565 rewind (pot_fp);
11566
11567 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11568
11569 uint pot_hashes_avail = 0;
11570
11571 uint line_num = 0;
11572
11573 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11574
11575 while (!feof (pot_fp))
11576 {
11577 line_num++;
11578
11579 int line_len = fgetl (pot_fp, line_buf);
11580
11581 if (line_len == 0) continue;
11582
11583 char *plain_buf = line_buf + line_len;
11584
11585 pot_t *pot_ptr = &pot[pot_cnt];
11586
11587 hash_t *hashes_buf = &pot_ptr->hash;
11588
11589 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11590 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11591
11592 if (pot_cnt == pot_hashes_avail)
11593 {
11594 uint pos = 0;
11595
11596 for (pos = 0; pos < INCR_POT; pos++)
11597 {
11598 if ((pot_cnt + pos) >= pot_avail) break;
11599
11600 pot_t *tmp_pot = &pot[pot_cnt + pos];
11601
11602 hash_t *tmp_hash = &tmp_pot->hash;
11603
11604 tmp_hash->digest = mymalloc (dgst_size);
11605
11606 if (isSalted)
11607 {
11608 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11609 }
11610
11611 if (esalt_size)
11612 {
11613 tmp_hash->esalt = mymalloc (esalt_size);
11614 }
11615
11616 pot_hashes_avail++;
11617 }
11618 }
11619
11620 int plain_len = 0;
11621
11622 int parser_status;
11623
11624 int iter = MAX_CUT_TRIES;
11625
11626 do
11627 {
11628 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11629 {
11630 if (line_buf[i] == ':')
11631 {
11632 line_len--;
11633
11634 break;
11635 }
11636 }
11637
11638 if (data.hash_mode != 2500)
11639 {
11640 parser_status = parse_func (line_buf, line_len, hashes_buf);
11641 }
11642 else
11643 {
11644 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11645
11646 if (line_len > max_salt_size)
11647 {
11648 parser_status = PARSER_GLOBAL_LENGTH;
11649 }
11650 else
11651 {
11652 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11653
11654 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11655
11656 hashes_buf->salt->salt_len = line_len;
11657
11658 parser_status = PARSER_OK;
11659 }
11660 }
11661
11662 // if NOT parsed without error, we add the ":" to the plain
11663
11664 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11665 {
11666 plain_len++;
11667 plain_buf--;
11668 }
11669
11670 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11671
11672 if (parser_status < PARSER_GLOBAL_ZERO)
11673 {
11674 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11675
11676 continue;
11677 }
11678
11679 if (plain_len >= 255) continue;
11680
11681 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11682
11683 pot_ptr->plain_len = plain_len;
11684
11685 pot_cnt++;
11686 }
11687
11688 myfree (line_buf);
11689
11690 fclose (pot_fp);
11691
11692 SUPPRESS_OUTPUT = 0;
11693
11694 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11695 }
11696
11697 /**
11698 * word len
11699 */
11700
11701 uint pw_min = PW_MIN;
11702 uint pw_max = PW_MAX;
11703
11704 switch (hash_mode)
11705 {
11706 case 125: if (pw_max > 32) pw_max = 32;
11707 break;
11708 case 400: if (pw_max > 40) pw_max = 40;
11709 break;
11710 case 500: if (pw_max > 16) pw_max = 16;
11711 break;
11712 case 1500: if (pw_max > 8) pw_max = 8;
11713 break;
11714 case 1600: if (pw_max > 16) pw_max = 16;
11715 break;
11716 case 1800: if (pw_max > 16) pw_max = 16;
11717 break;
11718 case 2100: if (pw_max > 16) pw_max = 16;
11719 break;
11720 case 2500: if (pw_min < 8) pw_min = 8;
11721 break;
11722 case 3000: if (pw_max > 7) pw_max = 7;
11723 break;
11724 case 5200: if (pw_max > 24) pw_max = 24;
11725 break;
11726 case 5800: if (pw_max > 16) pw_max = 16;
11727 break;
11728 case 6300: if (pw_max > 16) pw_max = 16;
11729 break;
11730 case 7400: if (pw_max > 16) pw_max = 16;
11731 break;
11732 case 7700: if (pw_max > 8) pw_max = 8;
11733 break;
11734 case 7900: if (pw_max > 48) pw_max = 48;
11735 break;
11736 case 8500: if (pw_max > 8) pw_max = 8;
11737 break;
11738 case 8600: if (pw_max > 16) pw_max = 16;
11739 break;
11740 case 9710: pw_min = 5;
11741 pw_max = 5;
11742 break;
11743 case 9810: pw_min = 5;
11744 pw_max = 5;
11745 break;
11746 case 10410: pw_min = 5;
11747 pw_max = 5;
11748 break;
11749 case 10300: if (pw_max < 3) pw_min = 3;
11750 if (pw_max > 40) pw_max = 40;
11751 break;
11752 case 10500: if (pw_max < 3) pw_min = 3;
11753 if (pw_max > 40) pw_max = 40;
11754 break;
11755 case 10700: if (pw_max > 16) pw_max = 16;
11756 break;
11757 case 11300: if (pw_max > 40) pw_max = 40;
11758 break;
11759 case 11600: if (pw_max > 32) pw_max = 32;
11760 break;
11761 case 12500: if (pw_max > 20) pw_max = 20;
11762 break;
11763 case 12800: if (pw_max > 24) pw_max = 24;
11764 break;
11765 }
11766
11767 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11768 {
11769 switch (attack_kern)
11770 {
11771 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11772 break;
11773 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11774 break;
11775 }
11776 }
11777
11778 /**
11779 * charsets : keep them together for more easy maintainnce
11780 */
11781
11782 cs_t mp_sys[6] = { { { 0 }, 0 } };
11783 cs_t mp_usr[4] = { { { 0 }, 0 } };
11784
11785 mp_setup_sys (mp_sys);
11786
11787 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11788 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11789 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11790 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11791
11792 /**
11793 * load hashes, part I: find input mode, count hashes
11794 */
11795
11796 uint hashlist_mode = 0;
11797 uint hashlist_format = HLFMT_HASHCAT;
11798
11799 uint hashes_avail = 0;
11800
11801 if ((benchmark == 0) && (stdout_flag == 0))
11802 {
11803 struct stat f;
11804
11805 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11806
11807 if ((hash_mode == 2500) ||
11808 (hash_mode == 5200) ||
11809 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11810 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11811 (hash_mode == 9000))
11812 {
11813 hashlist_mode = HL_MODE_ARG;
11814
11815 char *hashfile = myargv[optind];
11816
11817 data.hashfile = hashfile;
11818
11819 logfile_top_var_string ("target", hashfile);
11820 }
11821
11822 if (hashlist_mode == HL_MODE_ARG)
11823 {
11824 if (hash_mode == 2500)
11825 {
11826 struct stat st;
11827
11828 if (stat (data.hashfile, &st) == -1)
11829 {
11830 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11831
11832 return (-1);
11833 }
11834
11835 hashes_avail = st.st_size / sizeof (hccap_t);
11836 }
11837 else
11838 {
11839 hashes_avail = 1;
11840 }
11841 }
11842 else if (hashlist_mode == HL_MODE_FILE)
11843 {
11844 char *hashfile = myargv[optind];
11845
11846 data.hashfile = hashfile;
11847
11848 logfile_top_var_string ("target", hashfile);
11849
11850 FILE *fp = NULL;
11851
11852 if ((fp = fopen (hashfile, "rb")) == NULL)
11853 {
11854 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11855
11856 return (-1);
11857 }
11858
11859 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11860
11861 hashes_avail = count_lines (fp);
11862
11863 rewind (fp);
11864
11865 if (hashes_avail == 0)
11866 {
11867 log_error ("ERROR: hashfile is empty or corrupt");
11868
11869 fclose (fp);
11870
11871 return (-1);
11872 }
11873
11874 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11875
11876 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11877 {
11878 log_error ("ERROR: remove not supported in native hashfile-format mode");
11879
11880 fclose (fp);
11881
11882 return (-1);
11883 }
11884
11885 fclose (fp);
11886 }
11887 }
11888 else
11889 {
11890 hashlist_mode = HL_MODE_ARG;
11891
11892 hashes_avail = 1;
11893 }
11894
11895 if (hash_mode == 3000) hashes_avail *= 2;
11896
11897 data.hashlist_mode = hashlist_mode;
11898 data.hashlist_format = hashlist_format;
11899
11900 logfile_top_uint (hashlist_mode);
11901 logfile_top_uint (hashlist_format);
11902
11903 /**
11904 * load hashes, part II: allocate required memory, set pointers
11905 */
11906
11907 hash_t *hashes_buf = NULL;
11908 void *digests_buf = NULL;
11909 salt_t *salts_buf = NULL;
11910 void *esalts_buf = NULL;
11911
11912 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11913
11914 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11915
11916 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11917 {
11918 u32 hash_pos;
11919
11920 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11921 {
11922 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11923
11924 hashes_buf[hash_pos].hash_info = hash_info;
11925
11926 if (username && (remove || show || left))
11927 {
11928 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11929 }
11930
11931 if (benchmark)
11932 {
11933 hash_info->orighash = (char *) mymalloc (256);
11934 }
11935 }
11936 }
11937
11938 if (isSalted)
11939 {
11940 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11941
11942 if (esalt_size)
11943 {
11944 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11945 }
11946 }
11947 else
11948 {
11949 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11950 }
11951
11952 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11953 {
11954 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11955
11956 if (isSalted)
11957 {
11958 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11959
11960 if (esalt_size)
11961 {
11962 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11963 }
11964 }
11965 else
11966 {
11967 hashes_buf[hash_pos].salt = &salts_buf[0];
11968 }
11969 }
11970
11971 /**
11972 * load hashes, part III: parse hashes or generate them if benchmark
11973 */
11974
11975 uint hashes_cnt = 0;
11976
11977 if (benchmark == 0)
11978 {
11979 if (keyspace == 1)
11980 {
11981 // useless to read hash file for keyspace, cheat a little bit w/ optind
11982 }
11983 else if (stdout_flag == 1)
11984 {
11985 // useless to read hash file for stdout, cheat a little bit w/ optind
11986 }
11987 else if (hashes_avail == 0)
11988 {
11989 }
11990 else if (hashlist_mode == HL_MODE_ARG)
11991 {
11992 char *input_buf = myargv[optind];
11993
11994 uint input_len = strlen (input_buf);
11995
11996 logfile_top_var_string ("target", input_buf);
11997
11998 char *hash_buf = NULL;
11999 int hash_len = 0;
12000
12001 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
12002
12003 bool hash_fmt_error = 0;
12004
12005 if (hash_len < 1) hash_fmt_error = 1;
12006 if (hash_buf == NULL) hash_fmt_error = 1;
12007
12008 if (hash_fmt_error)
12009 {
12010 log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12011 }
12012 else
12013 {
12014 if (opts_type & OPTS_TYPE_HASH_COPY)
12015 {
12016 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12017
12018 hash_info_tmp->orighash = mystrdup (hash_buf);
12019 }
12020
12021 if (isSalted)
12022 {
12023 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
12024 }
12025
12026 int parser_status = PARSER_OK;
12027
12028 if (hash_mode == 2500)
12029 {
12030 if (hash_len == 0)
12031 {
12032 log_error ("ERROR: hccap file not specified");
12033
12034 return (-1);
12035 }
12036
12037 hashlist_mode = HL_MODE_FILE;
12038
12039 data.hashlist_mode = hashlist_mode;
12040
12041 FILE *fp = fopen (hash_buf, "rb");
12042
12043 if (fp == NULL)
12044 {
12045 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
12046
12047 return (-1);
12048 }
12049
12050 if (hashes_avail < 1)
12051 {
12052 log_error ("ERROR: hccap file is empty or corrupt");
12053
12054 fclose (fp);
12055
12056 return (-1);
12057 }
12058
12059 uint hccap_size = sizeof (hccap_t);
12060
12061 char *in = (char *) mymalloc (hccap_size);
12062
12063 while (!feof (fp))
12064 {
12065 int n = fread (in, hccap_size, 1, fp);
12066
12067 if (n != 1)
12068 {
12069 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
12070
12071 break;
12072 }
12073
12074 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12075
12076 if (parser_status != PARSER_OK)
12077 {
12078 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12079
12080 continue;
12081 }
12082
12083 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12084
12085 if ((show == 1) || (left == 1))
12086 {
12087 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12088
12089 char *salt_ptr = (char *) tmp_salt->salt_buf;
12090
12091 int cur_pos = tmp_salt->salt_len;
12092 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12093
12094 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12095
12096 // do the appending task
12097
12098 snprintf (salt_ptr + cur_pos,
12099 rem_len,
12100 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12101 wpa->orig_mac1[0],
12102 wpa->orig_mac1[1],
12103 wpa->orig_mac1[2],
12104 wpa->orig_mac1[3],
12105 wpa->orig_mac1[4],
12106 wpa->orig_mac1[5],
12107 wpa->orig_mac2[0],
12108 wpa->orig_mac2[1],
12109 wpa->orig_mac2[2],
12110 wpa->orig_mac2[3],
12111 wpa->orig_mac2[4],
12112 wpa->orig_mac2[5]);
12113
12114 // memset () the remaining part of the salt
12115
12116 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12117 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12118
12119 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12120
12121 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12122 }
12123
12124 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);
12125 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);
12126
12127 hashes_cnt++;
12128 }
12129
12130 fclose (fp);
12131
12132 myfree (in);
12133 }
12134 else if (hash_mode == 3000)
12135 {
12136 if (hash_len == 32)
12137 {
12138 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12139
12140 hash_t *lm_hash_left = NULL;
12141
12142 if (parser_status == PARSER_OK)
12143 {
12144 lm_hash_left = &hashes_buf[hashes_cnt];
12145
12146 hashes_cnt++;
12147 }
12148 else
12149 {
12150 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12151 }
12152
12153 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12154
12155 hash_t *lm_hash_right = NULL;
12156
12157 if (parser_status == PARSER_OK)
12158 {
12159 lm_hash_right = &hashes_buf[hashes_cnt];
12160
12161 hashes_cnt++;
12162 }
12163 else
12164 {
12165 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12166 }
12167
12168 // show / left
12169
12170 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12171 {
12172 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);
12173 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);
12174 }
12175 }
12176 else
12177 {
12178 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12179
12180 if (parser_status == PARSER_OK)
12181 {
12182 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12183 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12184 }
12185
12186 if (parser_status == PARSER_OK)
12187 {
12188 hashes_cnt++;
12189 }
12190 else
12191 {
12192 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12193 }
12194 }
12195 }
12196 else
12197 {
12198 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12199
12200 if (parser_status == PARSER_OK)
12201 {
12202 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12203 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12204 }
12205
12206 if (parser_status == PARSER_OK)
12207 {
12208 hashes_cnt++;
12209 }
12210 else
12211 {
12212 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12213 }
12214 }
12215 }
12216 }
12217 else if (hashlist_mode == HL_MODE_FILE)
12218 {
12219 char *hashfile = data.hashfile;
12220
12221 FILE *fp;
12222
12223 if ((fp = fopen (hashfile, "rb")) == NULL)
12224 {
12225 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12226
12227 return (-1);
12228 }
12229
12230 uint line_num = 0;
12231
12232 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12233
12234 while (!feof (fp))
12235 {
12236 line_num++;
12237
12238 int line_len = fgetl (fp, line_buf);
12239
12240 if (line_len == 0) continue;
12241
12242 char *hash_buf = NULL;
12243 int hash_len = 0;
12244
12245 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12246
12247 bool hash_fmt_error = 0;
12248
12249 if (hash_len < 1) hash_fmt_error = 1;
12250 if (hash_buf == NULL) hash_fmt_error = 1;
12251
12252 if (hash_fmt_error)
12253 {
12254 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12255
12256 continue;
12257 }
12258
12259 if (username)
12260 {
12261 char *user_buf = NULL;
12262 int user_len = 0;
12263
12264 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12265
12266 if (remove || show)
12267 {
12268 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12269
12270 *user = (user_t *) mymalloc (sizeof (user_t));
12271
12272 user_t *user_ptr = *user;
12273
12274 if (user_buf != NULL)
12275 {
12276 user_ptr->user_name = mystrdup (user_buf);
12277 }
12278 else
12279 {
12280 user_ptr->user_name = mystrdup ("");
12281 }
12282
12283 user_ptr->user_len = user_len;
12284 }
12285 }
12286
12287 if (opts_type & OPTS_TYPE_HASH_COPY)
12288 {
12289 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12290
12291 hash_info_tmp->orighash = mystrdup (hash_buf);
12292 }
12293
12294 if (isSalted)
12295 {
12296 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12297 }
12298
12299 if (hash_mode == 3000)
12300 {
12301 if (hash_len == 32)
12302 {
12303 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12304
12305 if (parser_status < PARSER_GLOBAL_ZERO)
12306 {
12307 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12308
12309 continue;
12310 }
12311
12312 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12313
12314 hashes_cnt++;
12315
12316 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12317
12318 if (parser_status < PARSER_GLOBAL_ZERO)
12319 {
12320 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12321
12322 continue;
12323 }
12324
12325 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12326
12327 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);
12328
12329 hashes_cnt++;
12330
12331 // show / left
12332
12333 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);
12334 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);
12335 }
12336 else
12337 {
12338 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12339
12340 if (parser_status < PARSER_GLOBAL_ZERO)
12341 {
12342 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12343
12344 continue;
12345 }
12346
12347 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);
12348
12349 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12350 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12351
12352 hashes_cnt++;
12353 }
12354 }
12355 else
12356 {
12357 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12358
12359 if (parser_status < PARSER_GLOBAL_ZERO)
12360 {
12361 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12362
12363 continue;
12364 }
12365
12366 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);
12367
12368 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12369 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12370
12371 hashes_cnt++;
12372 }
12373 }
12374
12375 myfree (line_buf);
12376
12377 fclose (fp);
12378
12379 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12380
12381 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12382 }
12383 }
12384 else
12385 {
12386 if (isSalted)
12387 {
12388 hashes_buf[0].salt->salt_len = 8;
12389
12390 // special salt handling
12391
12392 switch (hash_mode)
12393 {
12394 case 1500: hashes_buf[0].salt->salt_len = 2;
12395 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12396 break;
12397 case 1731: hashes_buf[0].salt->salt_len = 4;
12398 break;
12399 case 2410: hashes_buf[0].salt->salt_len = 4;
12400 break;
12401 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12402 break;
12403 case 3100: hashes_buf[0].salt->salt_len = 1;
12404 break;
12405 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12406 break;
12407 case 5800: hashes_buf[0].salt->salt_len = 16;
12408 break;
12409 case 6800: hashes_buf[0].salt->salt_len = 32;
12410 break;
12411 case 8400: hashes_buf[0].salt->salt_len = 40;
12412 break;
12413 case 8800: hashes_buf[0].salt->salt_len = 16;
12414 break;
12415 case 8900: hashes_buf[0].salt->salt_len = 16;
12416 hashes_buf[0].salt->scrypt_N = 1024;
12417 hashes_buf[0].salt->scrypt_r = 1;
12418 hashes_buf[0].salt->scrypt_p = 1;
12419 break;
12420 case 9100: hashes_buf[0].salt->salt_len = 16;
12421 break;
12422 case 9300: hashes_buf[0].salt->salt_len = 14;
12423 hashes_buf[0].salt->scrypt_N = 16384;
12424 hashes_buf[0].salt->scrypt_r = 1;
12425 hashes_buf[0].salt->scrypt_p = 1;
12426 break;
12427 case 9400: hashes_buf[0].salt->salt_len = 16;
12428 break;
12429 case 9500: hashes_buf[0].salt->salt_len = 16;
12430 break;
12431 case 9600: hashes_buf[0].salt->salt_len = 16;
12432 break;
12433 case 9700: hashes_buf[0].salt->salt_len = 16;
12434 break;
12435 case 9710: hashes_buf[0].salt->salt_len = 16;
12436 break;
12437 case 9720: hashes_buf[0].salt->salt_len = 16;
12438 break;
12439 case 9800: hashes_buf[0].salt->salt_len = 16;
12440 break;
12441 case 9810: hashes_buf[0].salt->salt_len = 16;
12442 break;
12443 case 9820: hashes_buf[0].salt->salt_len = 16;
12444 break;
12445 case 10300: hashes_buf[0].salt->salt_len = 12;
12446 break;
12447 case 11500: hashes_buf[0].salt->salt_len = 4;
12448 break;
12449 case 11600: hashes_buf[0].salt->salt_len = 4;
12450 break;
12451 case 12400: hashes_buf[0].salt->salt_len = 4;
12452 break;
12453 case 12500: hashes_buf[0].salt->salt_len = 8;
12454 break;
12455 case 12600: hashes_buf[0].salt->salt_len = 64;
12456 break;
12457 }
12458
12459 // special esalt handling
12460
12461 switch (hash_mode)
12462 {
12463 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12464 break;
12465 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12466 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12467 break;
12468 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12469 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12470 break;
12471 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12472 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12473 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12474 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12475 break;
12476 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12477 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12478 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12479 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12480 break;
12481 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12482 break;
12483 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12484 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12485 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12486 break;
12487 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12488 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12489 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12490 break;
12491 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12492 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12493 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12494 break;
12495 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12496 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12497 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12498 break;
12499 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12500 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12501 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12502 break;
12503 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12504 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12505 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12506 break;
12507 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12508 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12509 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12510 break;
12511 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12512 break;
12513 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12514 break;
12515 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12516 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12517 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12518 break;
12519 }
12520 }
12521
12522 // set hashfile
12523
12524 switch (hash_mode)
12525 {
12526 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12527 break;
12528 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12529 break;
12530 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12531 break;
12532 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12533 break;
12534 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12535 break;
12536 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12537 break;
12538 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12539 break;
12540 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12541 break;
12542 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12543 break;
12544 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12545 break;
12546 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12547 break;
12548 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12549 break;
12550 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12551 break;
12552 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12553 break;
12554 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12555 break;
12556 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12557 break;
12558 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12559 break;
12560 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12561 break;
12562 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12563 break;
12564 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12565 break;
12566 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12567 break;
12568 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12569 break;
12570 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12571 break;
12572 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12573 break;
12574 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12575 break;
12576 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12577 break;
12578 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12579 break;
12580 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12581 break;
12582 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12583 break;
12584 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12585 break;
12586 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12587 break;
12588 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12589 break;
12590 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12591 break;
12592 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12593 break;
12594 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12595 break;
12596 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12597 break;
12598 }
12599
12600 // set default iterations
12601
12602 switch (hash_mode)
12603 {
12604 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12605 break;
12606 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12607 break;
12608 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12609 break;
12610 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12611 break;
12612 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12613 break;
12614 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12615 break;
12616 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12617 break;
12618 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12619 break;
12620 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12621 break;
12622 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12623 break;
12624 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12625 break;
12626 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12627 break;
12628 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12629 break;
12630 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12631 break;
12632 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12633 break;
12634 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12635 break;
12636 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12637 break;
12638 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12639 break;
12640 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12641 break;
12642 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12643 break;
12644 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12645 break;
12646 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12647 break;
12648 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12649 break;
12650 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12651 break;
12652 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12653 break;
12654 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12655 break;
12656 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12657 break;
12658 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12659 break;
12660 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12661 break;
12662 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12663 break;
12664 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12665 break;
12666 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12667 break;
12668 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12669 break;
12670 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12671 break;
12672 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12673 break;
12674 case 8900: hashes_buf[0].salt->salt_iter = 1;
12675 break;
12676 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12677 break;
12678 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12679 break;
12680 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12681 break;
12682 case 9300: hashes_buf[0].salt->salt_iter = 1;
12683 break;
12684 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12685 break;
12686 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12687 break;
12688 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12689 break;
12690 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12691 break;
12692 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12693 break;
12694 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12695 break;
12696 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12697 break;
12698 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12699 break;
12700 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12701 break;
12702 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12703 break;
12704 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12705 break;
12706 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12707 break;
12708 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12709 break;
12710 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12711 break;
12712 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12713 break;
12714 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12715 break;
12716 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12717 break;
12718 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12719 break;
12720 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12721 break;
12722 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12723 break;
12724 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12725 break;
12726 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12727 break;
12728 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12729 break;
12730 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12731 break;
12732 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12733 break;
12734 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12735 break;
12736 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12737 break;
12738 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12739 break;
12740 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12741 break;
12742 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12743 break;
12744 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12745 break;
12746 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12747 break;
12748 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12749 break;
12750 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12751 break;
12752 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12753 break;
12754 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12755 break;
12756 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12757 break;
12758 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12759 break;
12760 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12761 break;
12762 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12763 break;
12764 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12765 break;
12766 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12767 break;
12768 }
12769
12770 hashes_cnt = 1;
12771 }
12772
12773 if (show == 1 || left == 1)
12774 {
12775 for (uint i = 0; i < pot_cnt; i++)
12776 {
12777 pot_t *pot_ptr = &pot[i];
12778
12779 hash_t *hashes_buf = &pot_ptr->hash;
12780
12781 local_free (hashes_buf->digest);
12782
12783 if (isSalted)
12784 {
12785 local_free (hashes_buf->salt);
12786 }
12787 }
12788
12789 local_free (pot);
12790
12791 if (data.quiet == 0) log_info_nn ("");
12792
12793 return (0);
12794 }
12795
12796 if ((keyspace == 0) && (stdout_flag == 0))
12797 {
12798 if (hashes_cnt == 0)
12799 {
12800 log_error ("ERROR: No hashes loaded");
12801
12802 return (-1);
12803 }
12804 }
12805
12806 /**
12807 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12808 */
12809
12810 if (data.outfile != NULL)
12811 {
12812 if (data.hashfile != NULL)
12813 {
12814 #ifdef _POSIX
12815 struct stat tmpstat_outfile;
12816 struct stat tmpstat_hashfile;
12817 #endif
12818
12819 #ifdef _WIN
12820 struct stat64 tmpstat_outfile;
12821 struct stat64 tmpstat_hashfile;
12822 #endif
12823
12824 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12825
12826 if (tmp_outfile_fp)
12827 {
12828 #ifdef _POSIX
12829 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12830 #endif
12831
12832 #ifdef _WIN
12833 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12834 #endif
12835
12836 fclose (tmp_outfile_fp);
12837 }
12838
12839 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12840
12841 if (tmp_hashfile_fp)
12842 {
12843 #ifdef _POSIX
12844 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12845 #endif
12846
12847 #ifdef _WIN
12848 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12849 #endif
12850
12851 fclose (tmp_hashfile_fp);
12852 }
12853
12854 if (tmp_outfile_fp && tmp_outfile_fp)
12855 {
12856 tmpstat_outfile.st_mode = 0;
12857 tmpstat_outfile.st_nlink = 0;
12858 tmpstat_outfile.st_uid = 0;
12859 tmpstat_outfile.st_gid = 0;
12860 tmpstat_outfile.st_rdev = 0;
12861 tmpstat_outfile.st_atime = 0;
12862
12863 tmpstat_hashfile.st_mode = 0;
12864 tmpstat_hashfile.st_nlink = 0;
12865 tmpstat_hashfile.st_uid = 0;
12866 tmpstat_hashfile.st_gid = 0;
12867 tmpstat_hashfile.st_rdev = 0;
12868 tmpstat_hashfile.st_atime = 0;
12869
12870 #ifdef _POSIX
12871 tmpstat_outfile.st_blksize = 0;
12872 tmpstat_outfile.st_blocks = 0;
12873
12874 tmpstat_hashfile.st_blksize = 0;
12875 tmpstat_hashfile.st_blocks = 0;
12876 #endif
12877
12878 #ifdef _POSIX
12879 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12880 {
12881 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12882
12883 return (-1);
12884 }
12885 #endif
12886
12887 #ifdef _WIN
12888 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12889 {
12890 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12891
12892 return (-1);
12893 }
12894 #endif
12895 }
12896 }
12897 }
12898
12899 /**
12900 * Remove duplicates
12901 */
12902
12903 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12904
12905 if (isSalted)
12906 {
12907 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12908 }
12909 else
12910 {
12911 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12912 }
12913
12914 uint hashes_cnt_orig = hashes_cnt;
12915
12916 hashes_cnt = 1;
12917
12918 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12919 {
12920 if (isSalted)
12921 {
12922 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12923 {
12924 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12925 }
12926 }
12927 else
12928 {
12929 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12930 }
12931
12932 if (hashes_pos > hashes_cnt)
12933 {
12934 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12935 }
12936
12937 hashes_cnt++;
12938 }
12939
12940 /**
12941 * Potfile removes
12942 */
12943
12944 uint potfile_remove_cracks = 0;
12945
12946 if (potfile_disable == 0)
12947 {
12948 hash_t hash_buf;
12949
12950 hash_buf.digest = mymalloc (dgst_size);
12951 hash_buf.salt = NULL;
12952 hash_buf.esalt = NULL;
12953 hash_buf.hash_info = NULL;
12954 hash_buf.cracked = 0;
12955
12956 if (isSalted)
12957 {
12958 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12959 }
12960
12961 if (esalt_size)
12962 {
12963 hash_buf.esalt = mymalloc (esalt_size);
12964 }
12965
12966 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12967
12968 // no solution for these special hash types (for instane because they use hashfile in output etc)
12969 if ((hash_mode != 5200) &&
12970 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12971 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12972 (hash_mode != 9000))
12973 {
12974 FILE *fp = fopen (potfile, "rb");
12975
12976 if (fp != NULL)
12977 {
12978 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12979
12980 // to be safe work with a copy (because of line_len loop, i etc)
12981 // moved up here because it's easier to handle continue case
12982 // it's just 64kb
12983
12984 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12985
12986 while (!feof (fp))
12987 {
12988 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12989
12990 if (ptr == NULL) break;
12991
12992 int line_len = strlen (line_buf);
12993
12994 if (line_len == 0) continue;
12995
12996 int iter = MAX_CUT_TRIES;
12997
12998 for (int i = line_len - 1; i && iter; i--, line_len--)
12999 {
13000 if (line_buf[i] != ':') continue;
13001
13002 if (isSalted)
13003 {
13004 memset (hash_buf.salt, 0, sizeof (salt_t));
13005 }
13006
13007 hash_t *found = NULL;
13008
13009 if (hash_mode == 6800)
13010 {
13011 if (i < 64) // 64 = 16 * uint in salt_buf[]
13012 {
13013 // manipulate salt_buf
13014 memcpy (hash_buf.salt->salt_buf, line_buf, i);
13015
13016 hash_buf.salt->salt_len = i;
13017
13018 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
13019 }
13020 }
13021 else if (hash_mode == 2500)
13022 {
13023 if (i < 64) // 64 = 16 * uint in salt_buf[]
13024 {
13025 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
13026 // manipulate salt_buf
13027
13028 memset (line_buf_cpy, 0, HCBUFSIZ);
13029 memcpy (line_buf_cpy, line_buf, i);
13030
13031 char *mac2_pos = strrchr (line_buf_cpy, ':');
13032
13033 if (mac2_pos == NULL) continue;
13034
13035 mac2_pos[0] = 0;
13036 mac2_pos++;
13037
13038 if (strlen (mac2_pos) != 12) continue;
13039
13040 char *mac1_pos = strrchr (line_buf_cpy, ':');
13041
13042 if (mac1_pos == NULL) continue;
13043
13044 mac1_pos[0] = 0;
13045 mac1_pos++;
13046
13047 if (strlen (mac1_pos) != 12) continue;
13048
13049 uint essid_length = mac1_pos - line_buf_cpy - 1;
13050
13051 // here we need the ESSID
13052 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
13053
13054 hash_buf.salt->salt_len = essid_length;
13055
13056 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
13057
13058 if (found)
13059 {
13060 wpa_t *wpa = (wpa_t *) found->esalt;
13061
13062 // compare hex string(s) vs binary MAC address(es)
13063
13064 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13065 {
13066 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
13067 {
13068 found = NULL;
13069
13070 break;
13071 }
13072 }
13073
13074 // early skip ;)
13075 if (!found) continue;
13076
13077 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13078 {
13079 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13080 {
13081 found = NULL;
13082
13083 break;
13084 }
13085 }
13086 }
13087 }
13088 }
13089 else
13090 {
13091 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13092
13093 if (parser_status == PARSER_OK)
13094 {
13095 if (isSalted)
13096 {
13097 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13098 }
13099 else
13100 {
13101 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13102 }
13103 }
13104 }
13105
13106 if (found == NULL) continue;
13107
13108 if (!found->cracked) potfile_remove_cracks++;
13109
13110 found->cracked = 1;
13111
13112 if (found) break;
13113
13114 iter--;
13115 }
13116 }
13117
13118 myfree (line_buf_cpy);
13119
13120 myfree (line_buf);
13121
13122 fclose (fp);
13123 }
13124 }
13125
13126 if (esalt_size)
13127 {
13128 local_free (hash_buf.esalt);
13129 }
13130
13131 if (isSalted)
13132 {
13133 local_free (hash_buf.salt);
13134 }
13135
13136 local_free (hash_buf.digest);
13137 }
13138
13139 /**
13140 * Now generate all the buffers required for later
13141 */
13142
13143 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13144
13145 salt_t *salts_buf_new = NULL;
13146 void *esalts_buf_new = NULL;
13147
13148 if (isSalted)
13149 {
13150 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13151
13152 if (esalt_size)
13153 {
13154 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13155 }
13156 }
13157 else
13158 {
13159 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13160 }
13161
13162 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13163
13164 uint digests_cnt = hashes_cnt;
13165 uint digests_done = 0;
13166
13167 size_t size_digests = digests_cnt * dgst_size;
13168 size_t size_shown = digests_cnt * sizeof (uint);
13169
13170 uint *digests_shown = (uint *) mymalloc (size_shown);
13171 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13172
13173 uint salts_cnt = 0;
13174 uint salts_done = 0;
13175
13176 hashinfo_t **hash_info = NULL;
13177
13178 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13179 {
13180 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13181
13182 if (username && (remove || show))
13183 {
13184 uint user_pos;
13185
13186 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13187 {
13188 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13189
13190 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13191 }
13192 }
13193 }
13194
13195 uint *salts_shown = (uint *) mymalloc (size_shown);
13196
13197 salt_t *salt_buf;
13198
13199 {
13200 // copied from inner loop
13201
13202 salt_buf = &salts_buf_new[salts_cnt];
13203
13204 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13205
13206 if (esalt_size)
13207 {
13208 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13209 }
13210
13211 salt_buf->digests_cnt = 0;
13212 salt_buf->digests_done = 0;
13213 salt_buf->digests_offset = 0;
13214
13215 salts_cnt++;
13216 }
13217
13218 if (hashes_buf[0].cracked == 1)
13219 {
13220 digests_shown[0] = 1;
13221
13222 digests_done++;
13223
13224 salt_buf->digests_done++;
13225 }
13226
13227 salt_buf->digests_cnt++;
13228
13229 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13230
13231 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13232 {
13233 hash_info[0] = hashes_buf[0].hash_info;
13234 }
13235
13236 // copy from inner loop
13237
13238 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13239 {
13240 if (isSalted)
13241 {
13242 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13243 {
13244 salt_buf = &salts_buf_new[salts_cnt];
13245
13246 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13247
13248 if (esalt_size)
13249 {
13250 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13251 }
13252
13253 salt_buf->digests_cnt = 0;
13254 salt_buf->digests_done = 0;
13255 salt_buf->digests_offset = hashes_pos;
13256
13257 salts_cnt++;
13258 }
13259 }
13260
13261 if (hashes_buf[hashes_pos].cracked == 1)
13262 {
13263 digests_shown[hashes_pos] = 1;
13264
13265 digests_done++;
13266
13267 salt_buf->digests_done++;
13268 }
13269
13270 salt_buf->digests_cnt++;
13271
13272 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13273
13274 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13275 {
13276 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13277 }
13278 }
13279
13280 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13281 {
13282 salt_t *salt_buf = &salts_buf_new[salt_pos];
13283
13284 if (salt_buf->digests_done == salt_buf->digests_cnt)
13285 {
13286 salts_shown[salt_pos] = 1;
13287
13288 salts_done++;
13289 }
13290
13291 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13292 }
13293
13294 local_free (digests_buf);
13295 local_free (salts_buf);
13296 local_free (esalts_buf);
13297
13298 digests_buf = digests_buf_new;
13299 salts_buf = salts_buf_new;
13300 esalts_buf = esalts_buf_new;
13301
13302 local_free (hashes_buf);
13303
13304 /**
13305 * special modification not set from parser
13306 */
13307
13308 switch (hash_mode)
13309 {
13310 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13311 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13312 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13313 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13314 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13315 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13316 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13317 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13318 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13319 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13320 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13321 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13322 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13323 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13324 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13325 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13326 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13327 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13328 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13329 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13330 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13331 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13332 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13333 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13334 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13335 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13336 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13337 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13338 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13339 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13340 }
13341
13342 if (truecrypt_keyfiles)
13343 {
13344 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13345
13346 char *keyfiles = strdup (truecrypt_keyfiles);
13347
13348 char *keyfile = strtok (keyfiles, ",");
13349
13350 do
13351 {
13352 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13353
13354 } while ((keyfile = strtok (NULL, ",")) != NULL);
13355
13356 free (keyfiles);
13357 }
13358
13359 if (veracrypt_keyfiles)
13360 {
13361 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13362
13363 char *keyfiles = strdup (veracrypt_keyfiles);
13364
13365 char *keyfile = strtok (keyfiles, ",");
13366
13367 do
13368 {
13369 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13370
13371 } while ((keyfile = strtok (NULL, ",")) != NULL);
13372
13373 free (keyfiles);
13374 }
13375
13376 data.digests_cnt = digests_cnt;
13377 data.digests_done = digests_done;
13378 data.digests_buf = digests_buf;
13379 data.digests_shown = digests_shown;
13380 data.digests_shown_tmp = digests_shown_tmp;
13381
13382 data.salts_cnt = salts_cnt;
13383 data.salts_done = salts_done;
13384 data.salts_buf = salts_buf;
13385 data.salts_shown = salts_shown;
13386
13387 data.esalts_buf = esalts_buf;
13388 data.hash_info = hash_info;
13389
13390 /**
13391 * Automatic Optimizers
13392 */
13393
13394 if (salts_cnt == 1)
13395 opti_type |= OPTI_TYPE_SINGLE_SALT;
13396
13397 if (digests_cnt == 1)
13398 opti_type |= OPTI_TYPE_SINGLE_HASH;
13399
13400 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13401 opti_type |= OPTI_TYPE_NOT_ITERATED;
13402
13403 if (attack_mode == ATTACK_MODE_BF)
13404 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13405
13406 data.opti_type = opti_type;
13407
13408 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13409 {
13410 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13411 {
13412 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13413 {
13414 if (opts_type & OPTS_TYPE_ST_ADD80)
13415 {
13416 opts_type &= ~OPTS_TYPE_ST_ADD80;
13417 opts_type |= OPTS_TYPE_PT_ADD80;
13418 }
13419
13420 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13421 {
13422 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13423 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13424 }
13425
13426 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13427 {
13428 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13429 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13430 }
13431 }
13432 }
13433 }
13434
13435 /**
13436 * Some algorithm, like descrypt, can benefit from JIT compilation
13437 */
13438
13439 int force_jit_compilation = -1;
13440
13441 if (hash_mode == 8900)
13442 {
13443 force_jit_compilation = 8900;
13444 }
13445 else if (hash_mode == 9300)
13446 {
13447 force_jit_compilation = 8900;
13448 }
13449 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13450 {
13451 force_jit_compilation = 1500;
13452 }
13453
13454 /**
13455 * generate bitmap tables
13456 */
13457
13458 const uint bitmap_shift1 = 5;
13459 const uint bitmap_shift2 = 13;
13460
13461 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13462
13463 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13464 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13465 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13466 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13467 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13468 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13469 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13470 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13471
13472 uint bitmap_bits;
13473 uint bitmap_nums;
13474 uint bitmap_mask;
13475 uint bitmap_size;
13476
13477 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13478 {
13479 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13480
13481 bitmap_nums = 1 << bitmap_bits;
13482
13483 bitmap_mask = bitmap_nums - 1;
13484
13485 bitmap_size = bitmap_nums * sizeof (uint);
13486
13487 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13488
13489 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;
13490 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;
13491
13492 break;
13493 }
13494
13495 bitmap_nums = 1 << bitmap_bits;
13496
13497 bitmap_mask = bitmap_nums - 1;
13498
13499 bitmap_size = bitmap_nums * sizeof (uint);
13500
13501 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);
13502 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);
13503
13504 /**
13505 * prepare quick rule
13506 */
13507
13508 data.rule_buf_l = rule_buf_l;
13509 data.rule_buf_r = rule_buf_r;
13510
13511 int rule_len_l = (int) strlen (rule_buf_l);
13512 int rule_len_r = (int) strlen (rule_buf_r);
13513
13514 data.rule_len_l = rule_len_l;
13515 data.rule_len_r = rule_len_r;
13516
13517 /**
13518 * load rules
13519 */
13520
13521 uint *all_kernel_rules_cnt = NULL;
13522
13523 kernel_rule_t **all_kernel_rules_buf = NULL;
13524
13525 if (rp_files_cnt)
13526 {
13527 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13528
13529 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13530 }
13531
13532 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13533
13534 int rule_len = 0;
13535
13536 for (uint i = 0; i < rp_files_cnt; i++)
13537 {
13538 uint kernel_rules_avail = 0;
13539
13540 uint kernel_rules_cnt = 0;
13541
13542 kernel_rule_t *kernel_rules_buf = NULL;
13543
13544 char *rp_file = rp_files[i];
13545
13546 char in[BLOCK_SIZE] = { 0 };
13547 char out[BLOCK_SIZE] = { 0 };
13548
13549 FILE *fp = NULL;
13550
13551 uint rule_line = 0;
13552
13553 if ((fp = fopen (rp_file, "rb")) == NULL)
13554 {
13555 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13556
13557 return (-1);
13558 }
13559
13560 while (!feof (fp))
13561 {
13562 memset (rule_buf, 0, HCBUFSIZ);
13563
13564 rule_len = fgetl (fp, rule_buf);
13565
13566 rule_line++;
13567
13568 if (rule_len == 0) continue;
13569
13570 if (rule_buf[0] == '#') continue;
13571
13572 if (kernel_rules_avail == kernel_rules_cnt)
13573 {
13574 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13575
13576 kernel_rules_avail += INCR_RULES;
13577 }
13578
13579 memset (in, 0, BLOCK_SIZE);
13580 memset (out, 0, BLOCK_SIZE);
13581
13582 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13583
13584 if (result == -1)
13585 {
13586 log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13587
13588 continue;
13589 }
13590
13591 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13592 {
13593 log_info ("WARNING: Cannot convert rule for use on OpenCL device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13594
13595 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13596
13597 continue;
13598 }
13599
13600 /* its so slow
13601 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13602 {
13603 log_info ("Duplicate rule for use on OpenCL device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13604
13605 continue;
13606 }
13607 */
13608
13609 kernel_rules_cnt++;
13610 }
13611
13612 fclose (fp);
13613
13614 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13615
13616 all_kernel_rules_buf[i] = kernel_rules_buf;
13617 }
13618
13619 /**
13620 * merge rules or automatic rule generator
13621 */
13622
13623 uint kernel_rules_cnt = 0;
13624
13625 kernel_rule_t *kernel_rules_buf = NULL;
13626
13627 if (attack_mode == ATTACK_MODE_STRAIGHT)
13628 {
13629 if (rp_files_cnt)
13630 {
13631 kernel_rules_cnt = 1;
13632
13633 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13634
13635 repeats[0] = kernel_rules_cnt;
13636
13637 for (uint i = 0; i < rp_files_cnt; i++)
13638 {
13639 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13640
13641 repeats[i + 1] = kernel_rules_cnt;
13642 }
13643
13644 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13645
13646 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13647
13648 for (uint i = 0; i < kernel_rules_cnt; i++)
13649 {
13650 uint out_pos = 0;
13651
13652 kernel_rule_t *out = &kernel_rules_buf[i];
13653
13654 for (uint j = 0; j < rp_files_cnt; j++)
13655 {
13656 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13657 uint in_pos;
13658
13659 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13660
13661 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13662 {
13663 if (out_pos == RULES_MAX - 1)
13664 {
13665 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13666
13667 break;
13668 }
13669
13670 out->cmds[out_pos] = in->cmds[in_pos];
13671 }
13672 }
13673 }
13674
13675 local_free (repeats);
13676 }
13677 else if (rp_gen)
13678 {
13679 uint kernel_rules_avail = 0;
13680
13681 while (kernel_rules_cnt < rp_gen)
13682 {
13683 if (kernel_rules_avail == kernel_rules_cnt)
13684 {
13685 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13686
13687 kernel_rules_avail += INCR_RULES;
13688 }
13689
13690 memset (rule_buf, 0, HCBUFSIZ);
13691
13692 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13693
13694 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13695
13696 kernel_rules_cnt++;
13697 }
13698 }
13699 }
13700
13701 myfree (rule_buf);
13702
13703 /**
13704 * generate NOP rules
13705 */
13706
13707 if ((rp_files_cnt == 0) && (rp_gen == 0))
13708 {
13709 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13710
13711 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13712
13713 kernel_rules_cnt++;
13714 }
13715
13716 data.kernel_rules_cnt = kernel_rules_cnt;
13717 data.kernel_rules_buf = kernel_rules_buf;
13718
13719 if (kernel_rules_cnt == 0)
13720 {
13721 log_error ("ERROR: No valid rules left");
13722
13723 return (-1);
13724 }
13725
13726 /**
13727 * OpenCL platforms: detect
13728 */
13729
13730 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13731 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13732
13733 cl_uint platforms_cnt = 0;
13734 cl_uint platform_devices_cnt = 0;
13735
13736 if (keyspace == 0)
13737 {
13738 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13739
13740 if (platforms_cnt == 0)
13741 {
13742 log_info ("");
13743 log_info ("ATTENTION! No OpenCL compatible platform found");
13744 log_info ("");
13745 log_info ("You're probably missing the OpenCL runtime installation");
13746 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13747 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13748 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13749 log_info ("");
13750
13751 return (-1);
13752 }
13753
13754 if (opencl_platforms_filter != (uint) -1)
13755 {
13756 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13757
13758 if (opencl_platforms_filter > platform_cnt_mask)
13759 {
13760 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13761
13762 return (-1);
13763 }
13764 }
13765 }
13766
13767 if (opencl_device_types == NULL)
13768 {
13769 /**
13770 * OpenCL device types:
13771 * 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.
13772 */
13773
13774 cl_device_type device_types_all = 0;
13775
13776 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13777 {
13778 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13779
13780 cl_platform_id platform = platforms[platform_id];
13781
13782 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13783
13784 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13785 {
13786 cl_device_id device = platform_devices[platform_devices_id];
13787
13788 cl_device_type device_type;
13789
13790 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13791
13792 device_types_all |= device_type;
13793 }
13794 }
13795
13796 // In such a case, automatically enable CPU device type support, since it's disabled by default.
13797
13798 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13799 {
13800 device_types_filter |= CL_DEVICE_TYPE_CPU;
13801 }
13802
13803 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
13804 // If we have a CPU device, force it to be used
13805
13806 if (stdout_flag == 1)
13807 {
13808 if (device_types_all & CL_DEVICE_TYPE_CPU)
13809 {
13810 device_types_filter = CL_DEVICE_TYPE_CPU;
13811 }
13812 }
13813 }
13814
13815 /**
13816 * OpenCL devices: simply push all devices from all platforms into the same device array
13817 */
13818
13819 int need_adl = 0;
13820 int need_nvapi = 0;
13821 int need_nvml = 0;
13822 int need_xnvctrl = 0;
13823
13824 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13825
13826 data.devices_param = devices_param;
13827
13828 uint devices_cnt = 0;
13829
13830 uint devices_active = 0;
13831
13832 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13833 {
13834 cl_platform_id platform = platforms[platform_id];
13835
13836 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13837
13838 char platform_vendor[INFOSZ] = { 0 };
13839
13840 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13841
13842 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13843 // this causes trouble with vendor id based macros
13844 // we'll assign generic to those without special optimization available
13845
13846 cl_uint platform_vendor_id = 0;
13847
13848 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13849 {
13850 platform_vendor_id = VENDOR_ID_AMD;
13851 }
13852 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13853 {
13854 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13855 }
13856 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13857 {
13858 platform_vendor_id = VENDOR_ID_APPLE;
13859 }
13860 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13861 {
13862 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13863 }
13864 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13865 {
13866 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13867 }
13868 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13869 {
13870 platform_vendor_id = VENDOR_ID_MESA;
13871 }
13872 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13873 {
13874 platform_vendor_id = VENDOR_ID_NV;
13875 }
13876 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13877 {
13878 platform_vendor_id = VENDOR_ID_POCL;
13879 }
13880 else
13881 {
13882 platform_vendor_id = VENDOR_ID_GENERIC;
13883 }
13884
13885 const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
13886
13887 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13888 {
13889 if (machine_readable == 0)
13890 {
13891 if (platform_skipped == 0)
13892 {
13893 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
13894
13895 char line[256] = { 0 };
13896
13897 for (int i = 0; i < len; i++) line[i] = '=';
13898
13899 log_info (line);
13900 }
13901 else
13902 {
13903 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
13904 log_info ("");
13905 }
13906 }
13907 }
13908
13909 if (platform_skipped == 1) continue;
13910
13911 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13912 {
13913 size_t param_value_size = 0;
13914
13915 const uint device_id = devices_cnt;
13916
13917 hc_device_param_t *device_param = &data.devices_param[device_id];
13918
13919 device_param->platform_vendor_id = platform_vendor_id;
13920
13921 device_param->device = platform_devices[platform_devices_id];
13922
13923 device_param->device_id = device_id;
13924
13925 device_param->platform_devices_id = platform_devices_id;
13926
13927 device_param->platform = platform;
13928
13929 // device_type
13930
13931 cl_device_type device_type;
13932
13933 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13934
13935 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13936
13937 device_param->device_type = device_type;
13938
13939 // device_name
13940
13941 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13942
13943 char *device_name = (char *) mymalloc (param_value_size);
13944
13945 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13946
13947 device_param->device_name = device_name;
13948
13949 // device_vendor
13950
13951 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13952
13953 char *device_vendor = (char *) mymalloc (param_value_size);
13954
13955 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13956
13957 device_param->device_vendor = device_vendor;
13958
13959 cl_uint device_vendor_id = 0;
13960
13961 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13962 {
13963 device_vendor_id = VENDOR_ID_AMD;
13964 }
13965 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13966 {
13967 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13968 }
13969 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13970 {
13971 device_vendor_id = VENDOR_ID_APPLE;
13972 }
13973 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13974 {
13975 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13976 }
13977 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13978 {
13979 device_vendor_id = VENDOR_ID_INTEL_SDK;
13980 }
13981 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13982 {
13983 device_vendor_id = VENDOR_ID_MESA;
13984 }
13985 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13986 {
13987 device_vendor_id = VENDOR_ID_NV;
13988 }
13989 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13990 {
13991 device_vendor_id = VENDOR_ID_POCL;
13992 }
13993 else
13994 {
13995 device_vendor_id = VENDOR_ID_GENERIC;
13996 }
13997
13998 device_param->device_vendor_id = device_vendor_id;
13999
14000 // tuning db
14001
14002 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14003
14004 // device_version
14005
14006 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
14007
14008 char *device_version = (char *) mymalloc (param_value_size);
14009
14010 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
14011
14012 device_param->device_version = device_version;
14013
14014 // device_opencl_version
14015
14016 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
14017
14018 char *device_opencl_version = (char *) mymalloc (param_value_size);
14019
14020 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
14021
14022 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
14023
14024 myfree (device_opencl_version);
14025
14026 // vector_width
14027
14028 cl_uint vector_width;
14029
14030 if (opencl_vector_width_chgd == 0)
14031 {
14032 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
14033 {
14034 if (opti_type & OPTI_TYPE_USES_BITS_64)
14035 {
14036 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
14037 }
14038 else
14039 {
14040 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
14041 }
14042 }
14043 else
14044 {
14045 vector_width = (cl_uint) tuningdb_entry->vector_width;
14046 }
14047 }
14048 else
14049 {
14050 vector_width = opencl_vector_width;
14051 }
14052
14053 if (vector_width > 16) vector_width = 16;
14054
14055 device_param->vector_width = vector_width;
14056
14057 // max_compute_units
14058
14059 cl_uint device_processors;
14060
14061 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
14062
14063 device_param->device_processors = device_processors;
14064
14065 // device_maxmem_alloc
14066 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
14067
14068 cl_ulong device_maxmem_alloc;
14069
14070 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
14071
14072 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
14073
14074 // device_global_mem
14075
14076 cl_ulong device_global_mem;
14077
14078 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14079
14080 device_param->device_global_mem = device_global_mem;
14081
14082 // max_work_group_size
14083
14084 size_t device_maxworkgroup_size;
14085
14086 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14087
14088 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14089
14090 // max_clock_frequency
14091
14092 cl_uint device_maxclock_frequency;
14093
14094 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14095
14096 device_param->device_maxclock_frequency = device_maxclock_frequency;
14097
14098 // device_endian_little
14099
14100 cl_bool device_endian_little;
14101
14102 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14103
14104 if (device_endian_little == CL_FALSE)
14105 {
14106 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14107
14108 device_param->skipped = 1;
14109 }
14110
14111 // device_available
14112
14113 cl_bool device_available;
14114
14115 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14116
14117 if (device_available == CL_FALSE)
14118 {
14119 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14120
14121 device_param->skipped = 1;
14122 }
14123
14124 // device_compiler_available
14125
14126 cl_bool device_compiler_available;
14127
14128 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14129
14130 if (device_compiler_available == CL_FALSE)
14131 {
14132 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14133
14134 device_param->skipped = 1;
14135 }
14136
14137 // device_execution_capabilities
14138
14139 cl_device_exec_capabilities device_execution_capabilities;
14140
14141 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14142
14143 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14144 {
14145 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14146
14147 device_param->skipped = 1;
14148 }
14149
14150 // device_extensions
14151
14152 size_t device_extensions_size;
14153
14154 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14155
14156 char *device_extensions = mymalloc (device_extensions_size + 1);
14157
14158 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14159
14160 if (strstr (device_extensions, "base_atomics") == 0)
14161 {
14162 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14163
14164 device_param->skipped = 1;
14165 }
14166
14167 if (strstr (device_extensions, "byte_addressable_store") == 0)
14168 {
14169 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14170
14171 device_param->skipped = 1;
14172 }
14173
14174 myfree (device_extensions);
14175
14176 // device_local_mem_size
14177
14178 cl_ulong device_local_mem_size;
14179
14180 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14181
14182 if (device_local_mem_size < 32768)
14183 {
14184 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14185
14186 device_param->skipped = 1;
14187 }
14188
14189 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14190 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14191 // This results in both utilizing it for 50%
14192 // However, Intel has much better SIMD control over their own hardware
14193 // It makes sense to give them full control over their own hardware
14194
14195 if (device_type & CL_DEVICE_TYPE_CPU)
14196 {
14197 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14198 {
14199 if (data.force == 0)
14200 {
14201 if (algorithm_pos == 0)
14202 {
14203 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14204 log_info (" You can use --force to override this but do not post error reports if you do so");
14205 }
14206
14207 device_param->skipped = 1;
14208 }
14209 }
14210 }
14211
14212 // skipped
14213
14214 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14215 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14216
14217 // driver_version
14218
14219 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14220
14221 char *driver_version = (char *) mymalloc (param_value_size);
14222
14223 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14224
14225 device_param->driver_version = driver_version;
14226
14227 // device_name_chksum
14228
14229 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14230
14231 #if __x86_64__
14232 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);
14233 #else
14234 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);
14235 #endif
14236
14237 uint device_name_digest[4] = { 0 };
14238
14239 md5_64 ((uint *) device_name_chksum, device_name_digest);
14240
14241 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14242
14243 device_param->device_name_chksum = device_name_chksum;
14244
14245 // vendor specific
14246
14247 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14248 {
14249 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14250 {
14251 need_adl = 1;
14252 }
14253
14254 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14255 {
14256 need_nvml = 1;
14257
14258 #ifdef LINUX
14259 need_xnvctrl = 1;
14260 #endif
14261
14262 #ifdef WIN
14263 need_nvapi = 1;
14264 #endif
14265 }
14266 }
14267
14268 if (device_type & CL_DEVICE_TYPE_GPU)
14269 {
14270 if (device_vendor_id == VENDOR_ID_NV)
14271 {
14272 cl_uint kernel_exec_timeout = 0;
14273
14274 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14275
14276 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14277
14278 device_param->kernel_exec_timeout = kernel_exec_timeout;
14279
14280 cl_uint sm_minor = 0;
14281 cl_uint sm_major = 0;
14282
14283 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14284 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14285
14286 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14287 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14288
14289 device_param->sm_minor = sm_minor;
14290 device_param->sm_major = sm_major;
14291
14292 // CPU burning loop damper
14293 // Value is given as number between 0-100
14294 // By default 100%
14295
14296 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14297
14298 if (nvidia_spin_damp_chgd == 0)
14299 {
14300 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14301 {
14302 /**
14303 * the workaround is not a friend of rule based attacks
14304 * the words from the wordlist combined with fast and slow rules cause
14305 * fluctuations which cause inaccurate wait time estimations
14306 * using a reduced damping percentage almost compensates this
14307 */
14308
14309 device_param->nvidia_spin_damp = 64;
14310 }
14311 }
14312
14313 device_param->nvidia_spin_damp /= 100;
14314 }
14315 }
14316
14317 // display results
14318
14319 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14320 {
14321 if (machine_readable == 0)
14322 {
14323 if (device_param->skipped == 0)
14324 {
14325 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14326 device_id + 1,
14327 device_name,
14328 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14329 (unsigned int) (device_global_mem / 1024 / 1024),
14330 (unsigned int) device_processors);
14331 }
14332 else
14333 {
14334 log_info ("- Device #%u: %s, skipped",
14335 device_id + 1,
14336 device_name);
14337 }
14338 }
14339 }
14340
14341 // common driver check
14342
14343 if (device_param->skipped == 0)
14344 {
14345 if (device_type & CL_DEVICE_TYPE_GPU)
14346 {
14347 if (platform_vendor_id == VENDOR_ID_AMD)
14348 {
14349 int catalyst_check = (force == 1) ? 0 : 1;
14350
14351 int catalyst_warn = 0;
14352
14353 int catalyst_broken = 0;
14354
14355 if (catalyst_check == 1)
14356 {
14357 catalyst_warn = 1;
14358
14359 // v14.9 and higher
14360 if (atoi (device_param->driver_version) >= 1573)
14361 {
14362 catalyst_warn = 0;
14363 }
14364
14365 catalyst_check = 0;
14366 }
14367
14368 if (catalyst_broken == 1)
14369 {
14370 log_info ("");
14371 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14372 log_info ("It passes over cracked hashes and will not report them as cracked");
14373 log_info ("You are STRONGLY encouraged not to use it");
14374 log_info ("You can use --force to override this but do not post error reports if you do so");
14375 log_info ("");
14376
14377 return (-1);
14378 }
14379
14380 if (catalyst_warn == 1)
14381 {
14382 log_info ("");
14383 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14384 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14385 log_info ("See hashcat's homepage for official supported catalyst drivers");
14386 #ifdef _WIN
14387 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14388 #endif
14389 log_info ("You can use --force to override this but do not post error reports if you do so");
14390 log_info ("");
14391
14392 return (-1);
14393 }
14394 }
14395 else if (platform_vendor_id == VENDOR_ID_NV)
14396 {
14397 if (device_param->kernel_exec_timeout != 0)
14398 {
14399 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);
14400 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14401 }
14402 }
14403 }
14404
14405 /* turns out pocl still creates segfaults (because of llvm)
14406 if (device_type & CL_DEVICE_TYPE_CPU)
14407 {
14408 if (platform_vendor_id == VENDOR_ID_AMD)
14409 {
14410 if (force == 0)
14411 {
14412 log_info ("");
14413 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14414 log_info ("You are STRONGLY encouraged not to use it");
14415 log_info ("You can use --force to override this but do not post error reports if you do so");
14416 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14417 log_info ("");
14418
14419 return (-1);
14420 }
14421 }
14422 }
14423 */
14424
14425 /**
14426 * kernel accel and loops tuning db adjustment
14427 */
14428
14429 device_param->kernel_accel_min = 1;
14430 device_param->kernel_accel_max = 1024;
14431
14432 device_param->kernel_loops_min = 1;
14433 device_param->kernel_loops_max = 1024;
14434
14435 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14436
14437 if (tuningdb_entry)
14438 {
14439 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14440 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14441
14442 if (_kernel_accel)
14443 {
14444 device_param->kernel_accel_min = _kernel_accel;
14445 device_param->kernel_accel_max = _kernel_accel;
14446 }
14447
14448 if (_kernel_loops)
14449 {
14450 if (workload_profile == 1)
14451 {
14452 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14453 }
14454 else if (workload_profile == 2)
14455 {
14456 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14457 }
14458
14459 device_param->kernel_loops_min = _kernel_loops;
14460 device_param->kernel_loops_max = _kernel_loops;
14461 }
14462 }
14463
14464 // commandline parameters overwrite tuningdb entries
14465
14466 if (kernel_accel)
14467 {
14468 device_param->kernel_accel_min = kernel_accel;
14469 device_param->kernel_accel_max = kernel_accel;
14470 }
14471
14472 if (kernel_loops)
14473 {
14474 device_param->kernel_loops_min = kernel_loops;
14475 device_param->kernel_loops_max = kernel_loops;
14476 }
14477
14478 /**
14479 * activate device
14480 */
14481
14482 devices_active++;
14483 }
14484
14485 // next please
14486
14487 devices_cnt++;
14488 }
14489
14490 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14491 {
14492 if (machine_readable == 0)
14493 {
14494 log_info ("");
14495 }
14496 }
14497 }
14498
14499 if (keyspace == 0 && devices_active == 0)
14500 {
14501 log_error ("ERROR: No devices found/left");
14502
14503 return (-1);
14504 }
14505
14506 // 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)
14507
14508 if (devices_filter != (uint) -1)
14509 {
14510 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14511
14512 if (devices_filter > devices_cnt_mask)
14513 {
14514 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14515
14516 return (-1);
14517 }
14518 }
14519
14520 data.devices_cnt = devices_cnt;
14521
14522 data.devices_active = devices_active;
14523
14524 /**
14525 * HM devices: init
14526 */
14527
14528 #ifdef HAVE_HWMON
14529 hm_attrs_t hm_adapters_adl[DEVICES_MAX];
14530 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX];
14531 hm_attrs_t hm_adapters_nvml[DEVICES_MAX];
14532 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX];
14533
14534 memset (hm_adapters_adl, 0, sizeof (hm_adapters_adl));
14535 memset (hm_adapters_nvapi, 0, sizeof (hm_adapters_nvapi));
14536 memset (hm_adapters_nvml, 0, sizeof (hm_adapters_nvml));
14537 memset (hm_adapters_xnvctrl, 0, sizeof (hm_adapters_xnvctrl));
14538
14539 if (gpu_temp_disable == 0)
14540 {
14541 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14542 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14543 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14544 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
14545
14546 data.hm_adl = NULL;
14547 data.hm_nvapi = NULL;
14548 data.hm_nvml = NULL;
14549 data.hm_xnvctrl = NULL;
14550
14551 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14552 {
14553 data.hm_nvml = nvml;
14554 }
14555
14556 if (data.hm_nvml)
14557 {
14558 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14559 {
14560 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14561
14562 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14563
14564 int tmp_out = 0;
14565
14566 for (int i = 0; i < tmp_in; i++)
14567 {
14568 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14569 }
14570
14571 for (int i = 0; i < tmp_out; i++)
14572 {
14573 unsigned int speed;
14574
14575 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14576
14577 // doesn't seem to create any advantages
14578 //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14579 //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14580 }
14581 }
14582 }
14583
14584 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14585 {
14586 data.hm_nvapi = nvapi;
14587 }
14588
14589 if (data.hm_nvapi)
14590 {
14591 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14592 {
14593 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14594
14595 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14596
14597 int tmp_out = 0;
14598
14599 for (int i = 0; i < tmp_in; i++)
14600 {
14601 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14602 }
14603 }
14604 }
14605
14606 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
14607 {
14608 data.hm_xnvctrl = xnvctrl;
14609 }
14610
14611 if (data.hm_xnvctrl)
14612 {
14613 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
14614 {
14615 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14616 {
14617 hc_device_param_t *device_param = &data.devices_param[device_id];
14618
14619 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14620
14621 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
14622
14623 int speed = 0;
14624
14625 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
14626 }
14627 }
14628 }
14629
14630 if ((need_adl == 1) && (adl_init (adl) == 0))
14631 {
14632 data.hm_adl = adl;
14633 }
14634
14635 if (data.hm_adl)
14636 {
14637 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14638 {
14639 // total number of adapters
14640
14641 int hm_adapters_num;
14642
14643 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14644
14645 // adapter info
14646
14647 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14648
14649 if (lpAdapterInfo == NULL) return (-1);
14650
14651 // get a list (of ids of) valid/usable adapters
14652
14653 int num_adl_adapters = 0;
14654
14655 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14656
14657 if (num_adl_adapters > 0)
14658 {
14659 hc_thread_mutex_lock (mux_adl);
14660
14661 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14662
14663 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14664
14665 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14666 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14667
14668 hc_thread_mutex_unlock (mux_adl);
14669 }
14670
14671 myfree (valid_adl_device_list);
14672 myfree (lpAdapterInfo);
14673 }
14674 }
14675
14676 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14677 {
14678 gpu_temp_disable = 1;
14679 }
14680 }
14681
14682 /**
14683 * OpenCL devices: allocate buffer for device specific information
14684 */
14685
14686 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14687
14688 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14689
14690 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14691
14692 /**
14693 * User-defined GPU temp handling
14694 */
14695
14696 if (gpu_temp_disable == 1)
14697 {
14698 gpu_temp_abort = 0;
14699 gpu_temp_retain = 0;
14700 }
14701
14702 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14703 {
14704 if (gpu_temp_abort < gpu_temp_retain)
14705 {
14706 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14707
14708 return (-1);
14709 }
14710 }
14711
14712 data.gpu_temp_disable = gpu_temp_disable;
14713 data.gpu_temp_abort = gpu_temp_abort;
14714 data.gpu_temp_retain = gpu_temp_retain;
14715 #endif
14716
14717 /**
14718 * enable custom signal handler(s)
14719 */
14720
14721 if (benchmark == 0)
14722 {
14723 hc_signal (sigHandler_default);
14724 }
14725 else
14726 {
14727 hc_signal (sigHandler_benchmark);
14728 }
14729
14730 /**
14731 * inform the user
14732 */
14733
14734 if (data.quiet == 0)
14735 {
14736 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14737
14738 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);
14739
14740 if (attack_mode == ATTACK_MODE_STRAIGHT)
14741 {
14742 log_info ("Rules: %u", kernel_rules_cnt);
14743 }
14744
14745 if (opti_type)
14746 {
14747 log_info ("Applicable Optimizers:");
14748
14749 for (uint i = 0; i < 32; i++)
14750 {
14751 const uint opti_bit = 1u << i;
14752
14753 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14754 }
14755 }
14756
14757 /**
14758 * Watchdog and Temperature balance
14759 */
14760
14761 #ifdef HAVE_HWMON
14762 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
14763 {
14764 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14765 }
14766
14767 if (gpu_temp_abort == 0)
14768 {
14769 log_info ("Watchdog: Temperature abort trigger disabled");
14770 }
14771 else
14772 {
14773 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14774 }
14775
14776 if (gpu_temp_retain == 0)
14777 {
14778 log_info ("Watchdog: Temperature retain trigger disabled");
14779 }
14780 else
14781 {
14782 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14783 }
14784
14785 if (data.quiet == 0) log_info ("");
14786 #endif
14787 }
14788
14789 #ifdef HAVE_HWMON
14790
14791 /**
14792 * HM devices: copy
14793 */
14794
14795 if (gpu_temp_disable == 0)
14796 {
14797 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14798 {
14799 hc_device_param_t *device_param = &data.devices_param[device_id];
14800
14801 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14802
14803 if (device_param->skipped) continue;
14804
14805 const uint platform_devices_id = device_param->platform_devices_id;
14806
14807 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14808 {
14809 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14810 data.hm_device[device_id].nvapi = 0;
14811 data.hm_device[device_id].nvml = 0;
14812 data.hm_device[device_id].xnvctrl = 0;
14813 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14814 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14815 data.hm_device[device_id].fan_set_supported = 0;
14816 }
14817
14818 if (device_param->device_vendor_id == VENDOR_ID_NV)
14819 {
14820 data.hm_device[device_id].adl = 0;
14821 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14822 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14823 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
14824 data.hm_device[device_id].od_version = 0;
14825 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14826 data.hm_device[device_id].fan_set_supported = 0;
14827 }
14828 }
14829 }
14830
14831 /**
14832 * powertune on user request
14833 */
14834
14835 if (powertune_enable == 1)
14836 {
14837 hc_thread_mutex_lock (mux_adl);
14838
14839 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14840 {
14841 hc_device_param_t *device_param = &data.devices_param[device_id];
14842
14843 if (device_param->skipped) continue;
14844
14845 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14846 {
14847 /**
14848 * Temporary fix:
14849 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14850 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14851 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14852 * Driver / ADL bug?
14853 */
14854
14855 if (data.hm_device[device_id].od_version == 6)
14856 {
14857 int ADL_rc;
14858
14859 // check powertune capabilities first, if not available then skip device
14860
14861 int powertune_supported = 0;
14862
14863 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14864 {
14865 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14866
14867 return (-1);
14868 }
14869
14870 // first backup current value, we will restore it later
14871
14872 if (powertune_supported != 0)
14873 {
14874 // powercontrol settings
14875
14876 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14877
14878 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14879 {
14880 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14881 }
14882
14883 if (ADL_rc != ADL_OK)
14884 {
14885 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14886
14887 return (-1);
14888 }
14889
14890 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14891 {
14892 log_error ("ERROR: Failed to set new ADL PowerControl values");
14893
14894 return (-1);
14895 }
14896
14897 // clocks
14898
14899 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14900
14901 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14902
14903 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)
14904 {
14905 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14906
14907 return (-1);
14908 }
14909
14910 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14911
14912 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14913
14914 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14915 {
14916 log_error ("ERROR: Failed to get ADL device capabilities");
14917
14918 return (-1);
14919 }
14920
14921 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14922 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14923
14924 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14925 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14926
14927 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14928 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14929
14930 // warning if profile has too low max values
14931
14932 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14933 {
14934 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14935 }
14936
14937 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14938 {
14939 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14940 }
14941
14942 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14943
14944 performance_state->iNumberOfPerformanceLevels = 2;
14945
14946 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14947 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14948 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14949 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14950
14951 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)
14952 {
14953 log_info ("ERROR: Failed to set ADL performance state");
14954
14955 return (-1);
14956 }
14957
14958 local_free (performance_state);
14959 }
14960
14961 // set powertune value only
14962
14963 if (powertune_supported != 0)
14964 {
14965 // powertune set
14966 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14967
14968 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14969 {
14970 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14971
14972 return (-1);
14973 }
14974
14975 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14976 {
14977 log_error ("ERROR: Failed to set new ADL PowerControl values");
14978
14979 return (-1);
14980 }
14981 }
14982 }
14983 }
14984
14985 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14986 {
14987 // first backup current value, we will restore it later
14988
14989 unsigned int limit;
14990
14991 int powertune_supported = 0;
14992
14993 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14994 {
14995 powertune_supported = 1;
14996 }
14997
14998 // if backup worked, activate the maximum allowed
14999
15000 if (powertune_supported != 0)
15001 {
15002 unsigned int minLimit;
15003 unsigned int maxLimit;
15004
15005 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
15006 {
15007 if (maxLimit > 0)
15008 {
15009 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
15010 {
15011 // now we can be sure we need to reset later
15012
15013 nvml_power_limit[device_id] = limit;
15014 }
15015 }
15016 }
15017 }
15018 }
15019 }
15020
15021 hc_thread_mutex_unlock (mux_adl);
15022 }
15023
15024 #endif // HAVE_HWMON
15025
15026 #ifdef DEBUG
15027 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
15028 #endif
15029
15030 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
15031
15032 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15033 {
15034 /**
15035 * host buffer
15036 */
15037
15038 hc_device_param_t *device_param = &data.devices_param[device_id];
15039
15040 if (device_param->skipped) continue;
15041
15042 /**
15043 * device properties
15044 */
15045
15046 const char *device_name_chksum = device_param->device_name_chksum;
15047 const u32 device_processors = device_param->device_processors;
15048
15049 /**
15050 * create context for each device
15051 */
15052
15053 cl_context_properties properties[3];
15054
15055 properties[0] = CL_CONTEXT_PLATFORM;
15056 properties[1] = (cl_context_properties) device_param->platform;
15057 properties[2] = 0;
15058
15059 device_param->context = hc_clCreateContext (data.ocl, properties, 1, &device_param->device, NULL, NULL);
15060
15061 /**
15062 * create command-queue
15063 */
15064
15065 // not supported with NV
15066 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15067
15068 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
15069
15070 /**
15071 * kernel threads: some algorithms need a fixed kernel-threads count
15072 * because of shared memory usage or bitslice
15073 * there needs to be some upper limit, otherwise there's too much overhead
15074 */
15075
15076 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15077
15078 if (hash_mode == 8900) kernel_threads = 64; // Scrypt
15079 if (hash_mode == 9300) kernel_threads = 64; // Scrypt
15080
15081 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15082 {
15083 kernel_threads = KERNEL_THREADS_MAX_CPU;
15084 }
15085
15086 if (hash_mode == 1500) kernel_threads = 64; // DES
15087 if (hash_mode == 3000) kernel_threads = 64; // DES
15088 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15089 if (hash_mode == 7500) kernel_threads = 64; // RC4
15090 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15091 if (hash_mode == 9700) kernel_threads = 64; // RC4
15092 if (hash_mode == 9710) kernel_threads = 64; // RC4
15093 if (hash_mode == 9800) kernel_threads = 64; // RC4
15094 if (hash_mode == 9810) kernel_threads = 64; // RC4
15095 if (hash_mode == 10400) kernel_threads = 64; // RC4
15096 if (hash_mode == 10410) kernel_threads = 64; // RC4
15097 if (hash_mode == 10500) kernel_threads = 64; // RC4
15098 if (hash_mode == 13100) kernel_threads = 64; // RC4
15099
15100 device_param->kernel_threads = kernel_threads;
15101
15102 device_param->hardware_power = device_processors * kernel_threads;
15103
15104 /**
15105 * create input buffers on device : calculate size of fixed memory buffers
15106 */
15107
15108 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15109 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15110
15111 device_param->size_root_css = size_root_css;
15112 device_param->size_markov_css = size_markov_css;
15113
15114 size_t size_results = sizeof (uint);
15115
15116 device_param->size_results = size_results;
15117
15118 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15119 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15120
15121 size_t size_plains = digests_cnt * sizeof (plain_t);
15122 size_t size_salts = salts_cnt * sizeof (salt_t);
15123 size_t size_esalts = salts_cnt * esalt_size;
15124
15125 device_param->size_plains = size_plains;
15126 device_param->size_digests = size_digests;
15127 device_param->size_shown = size_shown;
15128 device_param->size_salts = size_salts;
15129
15130 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15131 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15132 size_t size_tm = 32 * sizeof (bs_word_t);
15133
15134 // scryptV stuff
15135
15136 size_t size_scrypt = 4;
15137
15138 if ((hash_mode == 8900) || (hash_mode == 9300))
15139 {
15140 // we need to check that all hashes have the same scrypt settings
15141
15142 const u32 scrypt_N = data.salts_buf[0].scrypt_N;
15143 const u32 scrypt_r = data.salts_buf[0].scrypt_r;
15144 const u32 scrypt_p = data.salts_buf[0].scrypt_p;
15145
15146 for (uint i = 1; i < salts_cnt; i++)
15147 {
15148 if ((data.salts_buf[i].scrypt_N != scrypt_N)
15149 || (data.salts_buf[i].scrypt_r != scrypt_r)
15150 || (data.salts_buf[i].scrypt_p != scrypt_p))
15151 {
15152 log_error ("ERROR: Mixed scrypt settings not supported");
15153
15154 return -1;
15155 }
15156 }
15157
15158 uint tmto_start = 0;
15159 uint tmto_stop = 10;
15160
15161 if (scrypt_tmto)
15162 {
15163 tmto_start = scrypt_tmto;
15164 }
15165 else
15166 {
15167 // in case the user did not specify the tmto manually
15168 // use some values known to run best (tested on 290x for AMD and GTX1080 for NV)
15169
15170 if (hash_mode == 8900)
15171 {
15172 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15173 {
15174 tmto_start = 3;
15175 }
15176 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15177 {
15178 tmto_start = 2;
15179 }
15180 }
15181 else if (hash_mode == 9300)
15182 {
15183 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15184 {
15185 tmto_start = 2;
15186 }
15187 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15188 {
15189 tmto_start = 4;
15190 }
15191 }
15192 }
15193
15194 data.scrypt_tmp_size = (128 * scrypt_r * scrypt_p);
15195
15196 device_param->kernel_accel_min = 1;
15197 device_param->kernel_accel_max = 8;
15198
15199 uint tmto;
15200
15201 for (tmto = tmto_start; tmto < tmto_stop; tmto++)
15202 {
15203 size_scrypt = (128 * scrypt_r) * scrypt_N;
15204
15205 size_scrypt /= 1 << tmto;
15206
15207 size_scrypt *= device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
15208
15209 if ((size_scrypt / 4) > device_param->device_maxmem_alloc)
15210 {
15211 if (quiet == 0) log_info ("WARNING: Not enough single-block device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15212
15213 continue;
15214 }
15215
15216 if (size_scrypt > device_param->device_global_mem)
15217 {
15218 if (quiet == 0) log_info ("WARNING: Not enough total device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15219
15220 continue;
15221 }
15222
15223 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15224 {
15225 data.scrypt_tmto_final = tmto;
15226 }
15227
15228 break;
15229 }
15230
15231 if (tmto == tmto_stop)
15232 {
15233 log_error ("ERROR: Can't allocate enough device memory");
15234
15235 return -1;
15236 }
15237
15238 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %llu\n", data.scrypt_tmto_final, (unsigned long long int) size_scrypt);
15239 }
15240
15241 size_t size_scrypt4 = size_scrypt / 4;
15242
15243 /**
15244 * some algorithms need a fixed kernel-loops count
15245 */
15246
15247 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15248 {
15249 const u32 kernel_loops_fixed = 1024;
15250
15251 device_param->kernel_loops_min = kernel_loops_fixed;
15252 device_param->kernel_loops_max = kernel_loops_fixed;
15253 }
15254
15255 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15256 {
15257 const u32 kernel_loops_fixed = 1024;
15258
15259 device_param->kernel_loops_min = kernel_loops_fixed;
15260 device_param->kernel_loops_max = kernel_loops_fixed;
15261 }
15262
15263 if (hash_mode == 8900)
15264 {
15265 const u32 kernel_loops_fixed = 1;
15266
15267 device_param->kernel_loops_min = kernel_loops_fixed;
15268 device_param->kernel_loops_max = kernel_loops_fixed;
15269 }
15270
15271 if (hash_mode == 9300)
15272 {
15273 const u32 kernel_loops_fixed = 1;
15274
15275 device_param->kernel_loops_min = kernel_loops_fixed;
15276 device_param->kernel_loops_max = kernel_loops_fixed;
15277 }
15278
15279 if (hash_mode == 12500)
15280 {
15281 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15282
15283 device_param->kernel_loops_min = kernel_loops_fixed;
15284 device_param->kernel_loops_max = kernel_loops_fixed;
15285 }
15286
15287 /**
15288 * some algorithms have a maximum kernel-loops count
15289 */
15290
15291 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15292 {
15293 u32 innerloop_cnt = 0;
15294
15295 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15296 {
15297 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15298 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15299 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15300 }
15301 else
15302 {
15303 innerloop_cnt = data.salts_buf[0].salt_iter;
15304 }
15305
15306 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15307 (innerloop_cnt <= device_param->kernel_loops_max))
15308 {
15309 device_param->kernel_loops_max = innerloop_cnt;
15310 }
15311 }
15312
15313 u32 kernel_accel_min = device_param->kernel_accel_min;
15314 u32 kernel_accel_max = device_param->kernel_accel_max;
15315
15316 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15317
15318 size_t size_pws = 4;
15319 size_t size_tmps = 4;
15320 size_t size_hooks = 4;
15321
15322 while (kernel_accel_max >= kernel_accel_min)
15323 {
15324 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15325
15326 // size_pws
15327
15328 size_pws = kernel_power_max * sizeof (pw_t);
15329
15330 // size_tmps
15331
15332 switch (hash_mode)
15333 {
15334 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15335 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15336 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15337 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15338 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15339 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15340 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15341 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15342 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15343 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15344 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15345 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15346 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15347 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15348 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15349 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15350 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15351 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15352 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15353 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15354 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15355 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15356 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15357 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15358 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15359 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15360 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15361 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15362 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15363 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15364 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15365 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15366 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15367 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15368 case 8900: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15369 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15370 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15371 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15372 case 9300: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15373 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15374 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15375 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15376 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15377 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15378 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15379 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15380 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15381 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15382 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15383 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15384 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15385 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15386 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15387 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15388 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15389 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15390 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15391 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15392 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15393 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15394 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15395 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15396 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15397 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15398 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15399 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15400 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15401 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15402 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15403 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15404 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15405 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15406 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15407 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15408 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15409 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15410 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15411 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15412 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15413 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15414 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15415 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15416 };
15417
15418 // size_hooks
15419
15420 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15421 {
15422 switch (hash_mode)
15423 {
15424 }
15425 }
15426
15427 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15428 // if not, decrease amplifier and try again
15429
15430 int memory_limit_hit = 0;
15431
15432 if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15433 if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15434 if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
15435
15436 const u64 size_total
15437 = bitmap_size
15438 + bitmap_size
15439 + bitmap_size
15440 + bitmap_size
15441 + bitmap_size
15442 + bitmap_size
15443 + bitmap_size
15444 + bitmap_size
15445 + size_bfs
15446 + size_combs
15447 + size_digests
15448 + size_esalts
15449 + size_hooks
15450 + size_markov_css
15451 + size_plains
15452 + size_pws
15453 + size_pws // not a bug
15454 + size_results
15455 + size_root_css
15456 + size_rules
15457 + size_rules_c
15458 + size_salts
15459 + size_scrypt4
15460 + size_scrypt4
15461 + size_scrypt4
15462 + size_scrypt4
15463 + size_shown
15464 + size_tm
15465 + size_tmps;
15466
15467 if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
15468
15469 if (memory_limit_hit == 1)
15470 {
15471 kernel_accel_max--;
15472
15473 continue;
15474 }
15475
15476 break;
15477 }
15478
15479 if (kernel_accel_max < kernel_accel_min)
15480 {
15481 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
15482
15483 return -1;
15484 }
15485
15486 device_param->kernel_accel_min = kernel_accel_min;
15487 device_param->kernel_accel_max = kernel_accel_max;
15488
15489 /*
15490 if (kernel_accel_max < kernel_accel)
15491 {
15492 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15493
15494 device_param->kernel_accel = kernel_accel_max;
15495 }
15496 */
15497
15498 device_param->size_bfs = size_bfs;
15499 device_param->size_combs = size_combs;
15500 device_param->size_rules = size_rules;
15501 device_param->size_rules_c = size_rules_c;
15502 device_param->size_pws = size_pws;
15503 device_param->size_tmps = size_tmps;
15504 device_param->size_hooks = size_hooks;
15505
15506 /**
15507 * default building options
15508 */
15509
15510 char cpath[1024] = { 0 };
15511
15512 char build_opts[1024] = { 0 };
15513
15514 #if _WIN
15515
15516 snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
15517
15518 char *cpath_real = mymalloc (MAX_PATH);
15519
15520 if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
15521 {
15522 log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
15523
15524 return -1;
15525 }
15526
15527 naive_replace (cpath_real, '\\', '/');
15528
15529 // not escaping here, windows has quotes
15530
15531 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
15532
15533 #else
15534
15535 snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
15536
15537 char *cpath_real = mymalloc (PATH_MAX);
15538
15539 if (realpath (cpath, cpath_real) == NULL)
15540 {
15541 log_error ("ERROR: %s: %s", cpath, strerror (errno));
15542
15543 return -1;
15544 }
15545
15546 naive_escape (cpath_real, PATH_MAX, ' ', '\\');
15547
15548 snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
15549
15550 #endif
15551
15552 // include check
15553 // this test needs to be done manually because of osx opencl runtime
15554 // if there's a problem with permission, its not reporting back and erroring out silently
15555
15556 #define files_cnt 15
15557
15558 const char *files_names[files_cnt] =
15559 {
15560 "inc_cipher_aes256.cl",
15561 "inc_cipher_serpent256.cl",
15562 "inc_cipher_twofish256.cl",
15563 "inc_common.cl",
15564 "inc_comp_multi_bs.cl",
15565 "inc_comp_multi.cl",
15566 "inc_comp_single_bs.cl",
15567 "inc_comp_single.cl",
15568 "inc_hash_constants.h",
15569 "inc_hash_functions.cl",
15570 "inc_rp.cl",
15571 "inc_rp.h",
15572 "inc_simd.cl",
15573 "inc_types.cl",
15574 "inc_vendor.cl",
15575 };
15576
15577 for (int i = 0; i < files_cnt; i++)
15578 {
15579 char path[1024] = { 0 };
15580
15581 snprintf (path, sizeof (path) - 1, "%s/%s", cpath_real, files_names[i]);
15582
15583 FILE *fd = fopen (path, "r");
15584
15585 if (fd == NULL)
15586 {
15587 log_error ("ERROR: %s: fopen(): %s", path, strerror (errno));
15588
15589 return -1;
15590 }
15591
15592 char buf[1];
15593
15594 size_t n = fread (buf, 1, 1, fd);
15595
15596 if (n != 1)
15597 {
15598 log_error ("ERROR: %s: fread(): %s", path, strerror (errno));
15599
15600 return -1;
15601 }
15602
15603 fclose (fd);
15604 }
15605
15606 myfree (cpath_real);
15607
15608 // we don't have sm_* on vendors not NV but it doesn't matter
15609
15610 char build_opts_new[1024] = { 0 };
15611
15612 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);
15613
15614 strncpy (build_opts, build_opts_new, sizeof (build_opts));
15615
15616 #ifdef DEBUG
15617 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15618 #endif
15619
15620 /**
15621 * main kernel
15622 */
15623
15624 {
15625 /**
15626 * kernel source filename
15627 */
15628
15629 char source_file[256] = { 0 };
15630
15631 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15632
15633 struct stat sst;
15634
15635 if (stat (source_file, &sst) == -1)
15636 {
15637 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15638
15639 return -1;
15640 }
15641
15642 /**
15643 * kernel cached filename
15644 */
15645
15646 char cached_file[256] = { 0 };
15647
15648 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15649
15650 int cached = 1;
15651
15652 struct stat cst;
15653
15654 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15655 {
15656 cached = 0;
15657 }
15658
15659 /**
15660 * kernel compile or load
15661 */
15662
15663 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15664
15665 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15666
15667 if (force_jit_compilation == -1)
15668 {
15669 if (cached == 0)
15670 {
15671 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));
15672
15673 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15674
15675 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15676
15677 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15678
15679 #ifdef DEBUG
15680 size_t build_log_size = 0;
15681
15682 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15683
15684 if (build_log_size > 1)
15685 {
15686 char *build_log = (char *) malloc (build_log_size + 1);
15687
15688 memset (build_log, 0, build_log_size + 1);
15689
15690 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15691
15692 puts (build_log);
15693
15694 free (build_log);
15695 }
15696 #endif
15697
15698 if (rc != 0)
15699 {
15700 device_param->skipped = true;
15701
15702 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15703
15704 continue;
15705 }
15706
15707 size_t binary_size;
15708
15709 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15710
15711 u8 *binary = (u8 *) mymalloc (binary_size);
15712
15713 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15714
15715 writeProgramBin (cached_file, binary, binary_size);
15716
15717 local_free (binary);
15718 }
15719 else
15720 {
15721 #ifdef DEBUG
15722 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15723 #endif
15724
15725 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15726
15727 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15728
15729 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15730 }
15731 }
15732 else
15733 {
15734 #ifdef DEBUG
15735 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15736 #endif
15737
15738 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15739
15740 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15741
15742 char build_opts_update[1024] = { 0 };
15743
15744 if (force_jit_compilation == 1500)
15745 {
15746 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%u", build_opts, data.salts_buf[0].salt_buf[0]);
15747 }
15748 else if (force_jit_compilation == 8900)
15749 {
15750 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);
15751 }
15752 else
15753 {
15754 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15755 }
15756
15757 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15758
15759 #ifdef DEBUG
15760 size_t build_log_size = 0;
15761
15762 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15763
15764 if (build_log_size > 1)
15765 {
15766 char *build_log = (char *) malloc (build_log_size + 1);
15767
15768 memset (build_log, 0, build_log_size + 1);
15769
15770 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15771
15772 puts (build_log);
15773
15774 free (build_log);
15775 }
15776 #endif
15777
15778 if (rc != 0)
15779 {
15780 device_param->skipped = true;
15781
15782 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15783 }
15784 }
15785
15786 local_free (kernel_lengths);
15787 local_free (kernel_sources[0]);
15788 local_free (kernel_sources);
15789 }
15790
15791 /**
15792 * word generator kernel
15793 */
15794
15795 if (attack_mode != ATTACK_MODE_STRAIGHT)
15796 {
15797 /**
15798 * kernel mp source filename
15799 */
15800
15801 char source_file[256] = { 0 };
15802
15803 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15804
15805 struct stat sst;
15806
15807 if (stat (source_file, &sst) == -1)
15808 {
15809 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15810
15811 return -1;
15812 }
15813
15814 /**
15815 * kernel mp cached filename
15816 */
15817
15818 char cached_file[256] = { 0 };
15819
15820 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15821
15822 int cached = 1;
15823
15824 struct stat cst;
15825
15826 if (stat (cached_file, &cst) == -1)
15827 {
15828 cached = 0;
15829 }
15830
15831 /**
15832 * kernel compile or load
15833 */
15834
15835 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15836
15837 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15838
15839 if (cached == 0)
15840 {
15841 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));
15842 if (quiet == 0) log_info ("");
15843
15844 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15845
15846 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15847
15848 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15849
15850 if (rc != 0)
15851 {
15852 device_param->skipped = true;
15853
15854 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
15855
15856 continue;
15857 }
15858
15859 size_t binary_size;
15860
15861 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15862
15863 u8 *binary = (u8 *) mymalloc (binary_size);
15864
15865 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15866
15867 writeProgramBin (cached_file, binary, binary_size);
15868
15869 local_free (binary);
15870 }
15871 else
15872 {
15873 #ifdef DEBUG
15874 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15875 #endif
15876
15877 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15878
15879 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15880
15881 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15882 }
15883
15884 local_free (kernel_lengths);
15885 local_free (kernel_sources[0]);
15886 local_free (kernel_sources);
15887 }
15888
15889 /**
15890 * amplifier kernel
15891 */
15892
15893 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15894 {
15895
15896 }
15897 else
15898 {
15899 /**
15900 * kernel amp source filename
15901 */
15902
15903 char source_file[256] = { 0 };
15904
15905 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15906
15907 struct stat sst;
15908
15909 if (stat (source_file, &sst) == -1)
15910 {
15911 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15912
15913 return -1;
15914 }
15915
15916 /**
15917 * kernel amp cached filename
15918 */
15919
15920 char cached_file[256] = { 0 };
15921
15922 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15923
15924 int cached = 1;
15925
15926 struct stat cst;
15927
15928 if (stat (cached_file, &cst) == -1)
15929 {
15930 cached = 0;
15931 }
15932
15933 /**
15934 * kernel compile or load
15935 */
15936
15937 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15938
15939 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15940
15941 if (cached == 0)
15942 {
15943 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));
15944 if (quiet == 0) log_info ("");
15945
15946 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15947
15948 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15949
15950 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15951
15952 if (rc != 0)
15953 {
15954 device_param->skipped = true;
15955
15956 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15957
15958 continue;
15959 }
15960
15961 size_t binary_size;
15962
15963 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15964
15965 u8 *binary = (u8 *) mymalloc (binary_size);
15966
15967 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15968
15969 writeProgramBin (cached_file, binary, binary_size);
15970
15971 local_free (binary);
15972 }
15973 else
15974 {
15975 #ifdef DEBUG
15976 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15977 #endif
15978
15979 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15980
15981 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15982
15983 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15984 }
15985
15986 local_free (kernel_lengths);
15987 local_free (kernel_sources[0]);
15988 local_free (kernel_sources);
15989 }
15990
15991 // some algorithm collide too fast, make that impossible
15992
15993 if (benchmark == 1)
15994 {
15995 ((uint *) digests_buf)[0] = -1;
15996 ((uint *) digests_buf)[1] = -1;
15997 ((uint *) digests_buf)[2] = -1;
15998 ((uint *) digests_buf)[3] = -1;
15999 }
16000
16001 /**
16002 * global buffers
16003 */
16004
16005 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
16006 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
16007 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
16008 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
16009 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
16010 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
16011 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
16012 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
16013 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
16014 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
16015 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
16016 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
16017 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
16018 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
16019 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
16020 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
16021 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
16022 device_param->d_scryptV0_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
16023 device_param->d_scryptV1_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
16024 device_param->d_scryptV2_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
16025 device_param->d_scryptV3_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL);
16026
16027 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);
16028 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);
16029 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);
16030 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);
16031 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);
16032 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);
16033 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);
16034 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);
16035 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
16036 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
16037 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
16038
16039 /**
16040 * special buffers
16041 */
16042
16043 if (attack_kern == ATTACK_KERN_STRAIGHT)
16044 {
16045 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
16046 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
16047
16048 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
16049 }
16050 else if (attack_kern == ATTACK_KERN_COMBI)
16051 {
16052 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
16053 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
16054 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
16055 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
16056 }
16057 else if (attack_kern == ATTACK_KERN_BF)
16058 {
16059 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
16060 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
16061 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
16062 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
16063 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
16064 }
16065
16066 if (size_esalts)
16067 {
16068 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
16069
16070 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
16071 }
16072
16073 /**
16074 * main host data
16075 */
16076
16077 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
16078
16079 device_param->pws_buf = pws_buf;
16080
16081 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
16082
16083 device_param->combs_buf = combs_buf;
16084
16085 void *hooks_buf = mymalloc (size_hooks);
16086
16087 device_param->hooks_buf = hooks_buf;
16088
16089 /**
16090 * kernel args
16091 */
16092
16093 device_param->kernel_params_buf32[24] = bitmap_mask;
16094 device_param->kernel_params_buf32[25] = bitmap_shift1;
16095 device_param->kernel_params_buf32[26] = bitmap_shift2;
16096 device_param->kernel_params_buf32[27] = 0; // salt_pos
16097 device_param->kernel_params_buf32[28] = 0; // loop_pos
16098 device_param->kernel_params_buf32[29] = 0; // loop_cnt
16099 device_param->kernel_params_buf32[30] = 0; // kernel_rules_cnt
16100 device_param->kernel_params_buf32[31] = 0; // digests_cnt
16101 device_param->kernel_params_buf32[32] = 0; // digests_offset
16102 device_param->kernel_params_buf32[33] = 0; // combs_mode
16103 device_param->kernel_params_buf32[34] = 0; // gid_max
16104
16105 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16106 ? &device_param->d_pws_buf
16107 : &device_param->d_pws_amp_buf;
16108 device_param->kernel_params[ 1] = &device_param->d_rules_c;
16109 device_param->kernel_params[ 2] = &device_param->d_combs_c;
16110 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
16111 device_param->kernel_params[ 4] = &device_param->d_tmps;
16112 device_param->kernel_params[ 5] = &device_param->d_hooks;
16113 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
16114 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
16115 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
16116 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
16117 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
16118 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
16119 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
16120 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
16121 device_param->kernel_params[14] = &device_param->d_plain_bufs;
16122 device_param->kernel_params[15] = &device_param->d_digests_buf;
16123 device_param->kernel_params[16] = &device_param->d_digests_shown;
16124 device_param->kernel_params[17] = &device_param->d_salt_bufs;
16125 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
16126 device_param->kernel_params[19] = &device_param->d_result;
16127 device_param->kernel_params[20] = &device_param->d_scryptV0_buf;
16128 device_param->kernel_params[21] = &device_param->d_scryptV1_buf;
16129 device_param->kernel_params[22] = &device_param->d_scryptV2_buf;
16130 device_param->kernel_params[23] = &device_param->d_scryptV3_buf;
16131 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
16132 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
16133 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
16134 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
16135 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
16136 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
16137 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
16138 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
16139 device_param->kernel_params[32] = &device_param->kernel_params_buf32[32];
16140 device_param->kernel_params[33] = &device_param->kernel_params_buf32[33];
16141 device_param->kernel_params[34] = &device_param->kernel_params_buf32[34];
16142
16143 device_param->kernel_params_mp_buf64[3] = 0;
16144 device_param->kernel_params_mp_buf32[4] = 0;
16145 device_param->kernel_params_mp_buf32[5] = 0;
16146 device_param->kernel_params_mp_buf32[6] = 0;
16147 device_param->kernel_params_mp_buf32[7] = 0;
16148 device_param->kernel_params_mp_buf32[8] = 0;
16149
16150 device_param->kernel_params_mp[0] = NULL;
16151 device_param->kernel_params_mp[1] = NULL;
16152 device_param->kernel_params_mp[2] = NULL;
16153 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16154 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16155 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16156 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16157 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16158 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16159
16160 device_param->kernel_params_mp_l_buf64[3] = 0;
16161 device_param->kernel_params_mp_l_buf32[4] = 0;
16162 device_param->kernel_params_mp_l_buf32[5] = 0;
16163 device_param->kernel_params_mp_l_buf32[6] = 0;
16164 device_param->kernel_params_mp_l_buf32[7] = 0;
16165 device_param->kernel_params_mp_l_buf32[8] = 0;
16166 device_param->kernel_params_mp_l_buf32[9] = 0;
16167
16168 device_param->kernel_params_mp_l[0] = NULL;
16169 device_param->kernel_params_mp_l[1] = NULL;
16170 device_param->kernel_params_mp_l[2] = NULL;
16171 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
16172 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
16173 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16174 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16175 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16176 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16177 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16178
16179 device_param->kernel_params_mp_r_buf64[3] = 0;
16180 device_param->kernel_params_mp_r_buf32[4] = 0;
16181 device_param->kernel_params_mp_r_buf32[5] = 0;
16182 device_param->kernel_params_mp_r_buf32[6] = 0;
16183 device_param->kernel_params_mp_r_buf32[7] = 0;
16184 device_param->kernel_params_mp_r_buf32[8] = 0;
16185
16186 device_param->kernel_params_mp_r[0] = NULL;
16187 device_param->kernel_params_mp_r[1] = NULL;
16188 device_param->kernel_params_mp_r[2] = NULL;
16189 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16190 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16191 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16192 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16193 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16194 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16195
16196 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16197 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16198
16199 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16200 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16201 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16202 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16203 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16204 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16205 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16206
16207 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16208 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16209
16210 device_param->kernel_params_memset_buf32[1] = 0; // value
16211 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16212
16213 device_param->kernel_params_memset[0] = NULL;
16214 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
16215 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
16216
16217 /**
16218 * kernel name
16219 */
16220
16221 size_t kernel_wgs_tmp;
16222
16223 char kernel_name[64] = { 0 };
16224
16225 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16226 {
16227 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16228 {
16229 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
16230
16231 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16232
16233 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
16234
16235 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16236
16237 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
16238
16239 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16240 }
16241 else
16242 {
16243 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
16244
16245 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16246
16247 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
16248
16249 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16250
16251 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
16252
16253 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16254 }
16255
16256 if (data.attack_mode == ATTACK_MODE_BF)
16257 {
16258 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16259 {
16260 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
16261
16262 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16263
16264 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);
16265 }
16266 }
16267 }
16268 else
16269 {
16270 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
16271
16272 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16273
16274 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
16275
16276 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16277
16278 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
16279
16280 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16281
16282 if (opts_type & OPTS_TYPE_HOOK12)
16283 {
16284 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
16285
16286 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16287
16288 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);
16289 }
16290
16291 if (opts_type & OPTS_TYPE_HOOK23)
16292 {
16293 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
16294
16295 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
16296
16297 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);
16298 }
16299 }
16300
16301 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);
16302 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);
16303 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);
16304
16305 for (uint i = 0; i <= 23; i++)
16306 {
16307 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
16308 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
16309 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
16310
16311 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
16312 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
16313 }
16314
16315 for (uint i = 24; i <= 34; i++)
16316 {
16317 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
16318 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
16319 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
16320
16321 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
16322 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
16323 }
16324
16325 // GPU memset
16326
16327 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
16328
16329 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);
16330
16331 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
16332 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
16333 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
16334
16335 // MP start
16336
16337 if (attack_mode == ATTACK_MODE_BF)
16338 {
16339 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
16340 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
16341
16342 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);
16343 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);
16344
16345 if (opts_type & OPTS_TYPE_PT_BITSLICE)
16346 {
16347 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
16348 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
16349 }
16350 }
16351 else if (attack_mode == ATTACK_MODE_HYBRID1)
16352 {
16353 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16354
16355 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);
16356 }
16357 else if (attack_mode == ATTACK_MODE_HYBRID2)
16358 {
16359 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16360
16361 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);
16362 }
16363
16364 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16365 {
16366 // nothing to do
16367 }
16368 else
16369 {
16370 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16371
16372 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);
16373 }
16374
16375 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16376 {
16377 // nothing to do
16378 }
16379 else
16380 {
16381 for (uint i = 0; i < 5; i++)
16382 {
16383 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16384 }
16385
16386 for (uint i = 5; i < 7; i++)
16387 {
16388 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16389 }
16390 }
16391
16392 // maybe this has been updated by clGetKernelWorkGroupInfo()
16393 // value can only be decreased, so we don't need to reallocate buffers
16394
16395 device_param->kernel_threads = kernel_threads;
16396
16397 // zero some data buffers
16398
16399 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16400 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16401 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16402 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16403 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16404 run_kernel_bzero (device_param, device_param->d_result, size_results);
16405
16406 /**
16407 * special buffers
16408 */
16409
16410 if (attack_kern == ATTACK_KERN_STRAIGHT)
16411 {
16412 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16413 }
16414 else if (attack_kern == ATTACK_KERN_COMBI)
16415 {
16416 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16417 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16418 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16419 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16420 }
16421 else if (attack_kern == ATTACK_KERN_BF)
16422 {
16423 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16424 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16425 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16426 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16427 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16428 }
16429
16430 #if defined(HAVE_HWMON)
16431
16432 /**
16433 * Store initial fanspeed if gpu_temp_retain is enabled
16434 */
16435
16436 if (gpu_temp_disable == 0)
16437 {
16438 if (gpu_temp_retain != 0)
16439 {
16440 hc_thread_mutex_lock (mux_adl);
16441
16442 if (data.hm_device[device_id].fan_get_supported == 1)
16443 {
16444 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16445 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16446
16447 // we also set it to tell the OS we take control over the fan and it's automatic controller
16448 // if it was set to automatic. we do not control user-defined fanspeeds.
16449
16450 if (fanpolicy == 1)
16451 {
16452 data.hm_device[device_id].fan_set_supported = 1;
16453
16454 int rc = -1;
16455
16456 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16457 {
16458 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16459 }
16460 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16461 {
16462 #ifdef LINUX
16463 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
16464 #endif
16465
16466 #ifdef WIN
16467 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
16468 #endif
16469 }
16470
16471 if (rc == 0)
16472 {
16473 data.hm_device[device_id].fan_set_supported = 1;
16474 }
16475 else
16476 {
16477 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16478
16479 data.hm_device[device_id].fan_set_supported = 0;
16480 }
16481 }
16482 else
16483 {
16484 data.hm_device[device_id].fan_set_supported = 0;
16485 }
16486 }
16487
16488 hc_thread_mutex_unlock (mux_adl);
16489 }
16490 }
16491
16492 #endif // HAVE_HWMON
16493 }
16494
16495 if (data.quiet == 0) log_info_nn ("");
16496
16497 /**
16498 * In benchmark-mode, inform user which algorithm is checked
16499 */
16500
16501 if (benchmark == 1)
16502 {
16503 if (machine_readable == 0)
16504 {
16505 quiet = 0;
16506
16507 data.quiet = quiet;
16508
16509 char *hash_type = strhashtype (data.hash_mode); // not a bug
16510
16511 log_info ("Hashtype: %s", hash_type);
16512 log_info ("");
16513 }
16514 }
16515
16516 /**
16517 * keep track of the progress
16518 */
16519
16520 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16521 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16522 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16523
16524 /**
16525 * open filehandles
16526 */
16527
16528 #if _WIN
16529 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16530 {
16531 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16532
16533 return (-1);
16534 }
16535
16536 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16537 {
16538 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16539
16540 return (-1);
16541 }
16542
16543 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16544 {
16545 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16546
16547 return (-1);
16548 }
16549 #endif
16550
16551 /**
16552 * dictionary pad
16553 */
16554
16555 segment_size *= (1024 * 1024);
16556
16557 data.segment_size = segment_size;
16558
16559 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16560
16561 wl_data->buf = (char *) mymalloc (segment_size);
16562 wl_data->avail = segment_size;
16563 wl_data->incr = segment_size;
16564 wl_data->cnt = 0;
16565 wl_data->pos = 0;
16566
16567 cs_t *css_buf = NULL;
16568 uint css_cnt = 0;
16569 uint dictcnt = 0;
16570 uint maskcnt = 1;
16571 char **masks = NULL;
16572 char **dictfiles = NULL;
16573
16574 uint mask_from_file = 0;
16575
16576 if (attack_mode == ATTACK_MODE_STRAIGHT)
16577 {
16578 if (wordlist_mode == WL_MODE_FILE)
16579 {
16580 int wls_left = myargc - (optind + 1);
16581
16582 for (int i = 0; i < wls_left; i++)
16583 {
16584 char *l0_filename = myargv[optind + 1 + i];
16585
16586 struct stat l0_stat;
16587
16588 if (stat (l0_filename, &l0_stat) == -1)
16589 {
16590 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16591
16592 return (-1);
16593 }
16594
16595 uint is_dir = S_ISDIR (l0_stat.st_mode);
16596
16597 if (is_dir == 0)
16598 {
16599 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16600
16601 dictcnt++;
16602
16603 dictfiles[dictcnt - 1] = l0_filename;
16604 }
16605 else
16606 {
16607 // do not allow --keyspace w/ a directory
16608
16609 if (keyspace == 1)
16610 {
16611 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
16612
16613 return (-1);
16614 }
16615
16616 char **dictionary_files = NULL;
16617
16618 dictionary_files = scan_directory (l0_filename);
16619
16620 if (dictionary_files != NULL)
16621 {
16622 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16623
16624 for (int d = 0; dictionary_files[d] != NULL; d++)
16625 {
16626 char *l1_filename = dictionary_files[d];
16627
16628 struct stat l1_stat;
16629
16630 if (stat (l1_filename, &l1_stat) == -1)
16631 {
16632 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16633
16634 return (-1);
16635 }
16636
16637 if (S_ISREG (l1_stat.st_mode))
16638 {
16639 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16640
16641 dictcnt++;
16642
16643 dictfiles[dictcnt - 1] = strdup (l1_filename);
16644 }
16645 }
16646 }
16647
16648 local_free (dictionary_files);
16649 }
16650 }
16651
16652 if (dictcnt < 1)
16653 {
16654 log_error ("ERROR: No usable dictionary file found.");
16655
16656 return (-1);
16657 }
16658 }
16659 else if (wordlist_mode == WL_MODE_STDIN)
16660 {
16661 dictcnt = 1;
16662 }
16663 }
16664 else if (attack_mode == ATTACK_MODE_COMBI)
16665 {
16666 // display
16667
16668 char *dictfile1 = myargv[optind + 1 + 0];
16669 char *dictfile2 = myargv[optind + 1 + 1];
16670
16671 // find the bigger dictionary and use as base
16672
16673 FILE *fp1 = NULL;
16674 FILE *fp2 = NULL;
16675
16676 struct stat tmp_stat;
16677
16678 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16679 {
16680 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16681
16682 return (-1);
16683 }
16684
16685 if (stat (dictfile1, &tmp_stat) == -1)
16686 {
16687 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16688
16689 fclose (fp1);
16690
16691 return (-1);
16692 }
16693
16694 if (S_ISDIR (tmp_stat.st_mode))
16695 {
16696 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16697
16698 fclose (fp1);
16699
16700 return (-1);
16701 }
16702
16703 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16704 {
16705 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16706
16707 fclose (fp1);
16708
16709 return (-1);
16710 }
16711
16712 if (stat (dictfile2, &tmp_stat) == -1)
16713 {
16714 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16715
16716 fclose (fp1);
16717 fclose (fp2);
16718
16719 return (-1);
16720 }
16721
16722 if (S_ISDIR (tmp_stat.st_mode))
16723 {
16724 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16725
16726 fclose (fp1);
16727 fclose (fp2);
16728
16729 return (-1);
16730 }
16731
16732 data.combs_cnt = 1;
16733
16734 data.quiet = 1;
16735
16736 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16737
16738 data.quiet = quiet;
16739
16740 if (words1_cnt == 0)
16741 {
16742 log_error ("ERROR: %s: empty file", dictfile1);
16743
16744 fclose (fp1);
16745 fclose (fp2);
16746
16747 return (-1);
16748 }
16749
16750 data.combs_cnt = 1;
16751
16752 data.quiet = 1;
16753
16754 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16755
16756 data.quiet = quiet;
16757
16758 if (words2_cnt == 0)
16759 {
16760 log_error ("ERROR: %s: empty file", dictfile2);
16761
16762 fclose (fp1);
16763 fclose (fp2);
16764
16765 return (-1);
16766 }
16767
16768 fclose (fp1);
16769 fclose (fp2);
16770
16771 data.dictfile = dictfile1;
16772 data.dictfile2 = dictfile2;
16773
16774 if (words1_cnt >= words2_cnt)
16775 {
16776 data.combs_cnt = words2_cnt;
16777 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16778
16779 dictfiles = &data.dictfile;
16780
16781 dictcnt = 1;
16782 }
16783 else
16784 {
16785 data.combs_cnt = words1_cnt;
16786 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16787
16788 dictfiles = &data.dictfile2;
16789
16790 dictcnt = 1;
16791
16792 // we also have to switch wordlist related rules!
16793
16794 char *tmpc = data.rule_buf_l;
16795
16796 data.rule_buf_l = data.rule_buf_r;
16797 data.rule_buf_r = tmpc;
16798
16799 int tmpi = data.rule_len_l;
16800
16801 data.rule_len_l = data.rule_len_r;
16802 data.rule_len_r = tmpi;
16803 }
16804 }
16805 else if (attack_mode == ATTACK_MODE_BF)
16806 {
16807 char *mask = NULL;
16808
16809 maskcnt = 0;
16810
16811 if (benchmark == 0)
16812 {
16813 mask = myargv[optind + 1];
16814
16815 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16816
16817 if ((optind + 2) <= myargc)
16818 {
16819 struct stat file_stat;
16820
16821 if (stat (mask, &file_stat) == -1)
16822 {
16823 maskcnt = 1;
16824
16825 masks[maskcnt - 1] = mystrdup (mask);
16826 }
16827 else
16828 {
16829 int wls_left = myargc - (optind + 1);
16830
16831 uint masks_avail = INCR_MASKS;
16832
16833 for (int i = 0; i < wls_left; i++)
16834 {
16835 if (i != 0)
16836 {
16837 mask = myargv[optind + 1 + i];
16838
16839 if (stat (mask, &file_stat) == -1)
16840 {
16841 log_error ("ERROR: %s: %s", mask, strerror (errno));
16842
16843 return (-1);
16844 }
16845 }
16846
16847 uint is_file = S_ISREG (file_stat.st_mode);
16848
16849 if (is_file == 1)
16850 {
16851 FILE *mask_fp;
16852
16853 if ((mask_fp = fopen (mask, "r")) == NULL)
16854 {
16855 log_error ("ERROR: %s: %s", mask, strerror (errno));
16856
16857 return (-1);
16858 }
16859
16860 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16861
16862 while (!feof (mask_fp))
16863 {
16864 memset (line_buf, 0, HCBUFSIZ);
16865
16866 int line_len = fgetl (mask_fp, line_buf);
16867
16868 if (line_len == 0) continue;
16869
16870 if (line_buf[0] == '#') continue;
16871
16872 if (masks_avail == maskcnt)
16873 {
16874 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16875
16876 masks_avail += INCR_MASKS;
16877 }
16878
16879 masks[maskcnt] = mystrdup (line_buf);
16880
16881 maskcnt++;
16882 }
16883
16884 myfree (line_buf);
16885
16886 fclose (mask_fp);
16887 }
16888 else
16889 {
16890 log_error ("ERROR: %s: unsupported file-type", mask);
16891
16892 return (-1);
16893 }
16894 }
16895
16896 mask_from_file = 1;
16897 }
16898 }
16899 else
16900 {
16901 custom_charset_1 = (char *) "?l?d?u";
16902 custom_charset_2 = (char *) "?l?d";
16903 custom_charset_3 = (char *) "?l?d*!$@_";
16904
16905 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16906 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16907 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16908
16909 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16910
16911 wordlist_mode = WL_MODE_MASK;
16912
16913 data.wordlist_mode = wordlist_mode;
16914
16915 increment = 1;
16916
16917 maskcnt = 1;
16918 }
16919 }
16920 else
16921 {
16922 /**
16923 * generate full masks and charsets
16924 */
16925
16926 masks = (char **) mymalloc (sizeof (char *));
16927
16928 switch (hash_mode)
16929 {
16930 case 1731: pw_min = 5;
16931 pw_max = 5;
16932 mask = mystrdup ("?b?b?b?b?b");
16933 break;
16934 case 12500: pw_min = 5;
16935 pw_max = 5;
16936 mask = mystrdup ("?b?b?b?b?b");
16937 break;
16938 default: pw_min = 7;
16939 pw_max = 7;
16940 mask = mystrdup ("?b?b?b?b?b?b?b");
16941 break;
16942 }
16943
16944 maskcnt = 1;
16945
16946 masks[maskcnt - 1] = mystrdup (mask);
16947
16948 wordlist_mode = WL_MODE_MASK;
16949
16950 data.wordlist_mode = wordlist_mode;
16951
16952 increment = 1;
16953 }
16954
16955 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16956
16957 if (increment)
16958 {
16959 if (increment_min > pw_min) pw_min = increment_min;
16960
16961 if (increment_max < pw_max) pw_max = increment_max;
16962 }
16963 }
16964 else if (attack_mode == ATTACK_MODE_HYBRID1)
16965 {
16966 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16967
16968 // display
16969
16970 char *mask = myargv[myargc - 1];
16971
16972 maskcnt = 0;
16973
16974 masks = (char **) mymalloc (1 * sizeof (char *));
16975
16976 // mod
16977
16978 struct stat file_stat;
16979
16980 if (stat (mask, &file_stat) == -1)
16981 {
16982 maskcnt = 1;
16983
16984 masks[maskcnt - 1] = mystrdup (mask);
16985 }
16986 else
16987 {
16988 uint is_file = S_ISREG (file_stat.st_mode);
16989
16990 if (is_file == 1)
16991 {
16992 FILE *mask_fp;
16993
16994 if ((mask_fp = fopen (mask, "r")) == NULL)
16995 {
16996 log_error ("ERROR: %s: %s", mask, strerror (errno));
16997
16998 return (-1);
16999 }
17000
17001 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17002
17003 uint masks_avail = 1;
17004
17005 while (!feof (mask_fp))
17006 {
17007 memset (line_buf, 0, HCBUFSIZ);
17008
17009 int line_len = fgetl (mask_fp, line_buf);
17010
17011 if (line_len == 0) continue;
17012
17013 if (line_buf[0] == '#') continue;
17014
17015 if (masks_avail == maskcnt)
17016 {
17017 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17018
17019 masks_avail += INCR_MASKS;
17020 }
17021
17022 masks[maskcnt] = mystrdup (line_buf);
17023
17024 maskcnt++;
17025 }
17026
17027 myfree (line_buf);
17028
17029 fclose (mask_fp);
17030
17031 mask_from_file = 1;
17032 }
17033 else
17034 {
17035 maskcnt = 1;
17036
17037 masks[maskcnt - 1] = mystrdup (mask);
17038 }
17039 }
17040
17041 // base
17042
17043 int wls_left = myargc - (optind + 2);
17044
17045 for (int i = 0; i < wls_left; i++)
17046 {
17047 char *filename = myargv[optind + 1 + i];
17048
17049 struct stat file_stat;
17050
17051 if (stat (filename, &file_stat) == -1)
17052 {
17053 log_error ("ERROR: %s: %s", filename, strerror (errno));
17054
17055 return (-1);
17056 }
17057
17058 uint is_dir = S_ISDIR (file_stat.st_mode);
17059
17060 if (is_dir == 0)
17061 {
17062 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17063
17064 dictcnt++;
17065
17066 dictfiles[dictcnt - 1] = filename;
17067 }
17068 else
17069 {
17070 // do not allow --keyspace w/ a directory
17071
17072 if (keyspace == 1)
17073 {
17074 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17075
17076 return (-1);
17077 }
17078
17079 char **dictionary_files = NULL;
17080
17081 dictionary_files = scan_directory (filename);
17082
17083 if (dictionary_files != NULL)
17084 {
17085 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17086
17087 for (int d = 0; dictionary_files[d] != NULL; d++)
17088 {
17089 char *l1_filename = dictionary_files[d];
17090
17091 struct stat l1_stat;
17092
17093 if (stat (l1_filename, &l1_stat) == -1)
17094 {
17095 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17096
17097 return (-1);
17098 }
17099
17100 if (S_ISREG (l1_stat.st_mode))
17101 {
17102 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17103
17104 dictcnt++;
17105
17106 dictfiles[dictcnt - 1] = strdup (l1_filename);
17107 }
17108 }
17109 }
17110
17111 local_free (dictionary_files);
17112 }
17113 }
17114
17115 if (dictcnt < 1)
17116 {
17117 log_error ("ERROR: No usable dictionary file found.");
17118
17119 return (-1);
17120 }
17121
17122 if (increment)
17123 {
17124 maskcnt = 0;
17125
17126 uint mask_min = increment_min; // we can't reject smaller masks here
17127 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17128
17129 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17130 {
17131 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17132
17133 if (cur_mask == NULL) break;
17134
17135 masks[maskcnt] = cur_mask;
17136
17137 maskcnt++;
17138
17139 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17140 }
17141 }
17142 }
17143 else if (attack_mode == ATTACK_MODE_HYBRID2)
17144 {
17145 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17146
17147 // display
17148
17149 char *mask = myargv[optind + 1 + 0];
17150
17151 maskcnt = 0;
17152
17153 masks = (char **) mymalloc (1 * sizeof (char *));
17154
17155 // mod
17156
17157 struct stat file_stat;
17158
17159 if (stat (mask, &file_stat) == -1)
17160 {
17161 maskcnt = 1;
17162
17163 masks[maskcnt - 1] = mystrdup (mask);
17164 }
17165 else
17166 {
17167 uint is_file = S_ISREG (file_stat.st_mode);
17168
17169 if (is_file == 1)
17170 {
17171 FILE *mask_fp;
17172
17173 if ((mask_fp = fopen (mask, "r")) == NULL)
17174 {
17175 log_error ("ERROR: %s: %s", mask, strerror (errno));
17176
17177 return (-1);
17178 }
17179
17180 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17181
17182 uint masks_avail = 1;
17183
17184 while (!feof (mask_fp))
17185 {
17186 memset (line_buf, 0, HCBUFSIZ);
17187
17188 int line_len = fgetl (mask_fp, line_buf);
17189
17190 if (line_len == 0) continue;
17191
17192 if (line_buf[0] == '#') continue;
17193
17194 if (masks_avail == maskcnt)
17195 {
17196 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17197
17198 masks_avail += INCR_MASKS;
17199 }
17200
17201 masks[maskcnt] = mystrdup (line_buf);
17202
17203 maskcnt++;
17204 }
17205
17206 myfree (line_buf);
17207
17208 fclose (mask_fp);
17209
17210 mask_from_file = 1;
17211 }
17212 else
17213 {
17214 maskcnt = 1;
17215
17216 masks[maskcnt - 1] = mystrdup (mask);
17217 }
17218 }
17219
17220 // base
17221
17222 int wls_left = myargc - (optind + 2);
17223
17224 for (int i = 0; i < wls_left; i++)
17225 {
17226 char *filename = myargv[optind + 2 + i];
17227
17228 struct stat file_stat;
17229
17230 if (stat (filename, &file_stat) == -1)
17231 {
17232 log_error ("ERROR: %s: %s", filename, strerror (errno));
17233
17234 return (-1);
17235 }
17236
17237 uint is_dir = S_ISDIR (file_stat.st_mode);
17238
17239 if (is_dir == 0)
17240 {
17241 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17242
17243 dictcnt++;
17244
17245 dictfiles[dictcnt - 1] = filename;
17246 }
17247 else
17248 {
17249 // do not allow --keyspace w/ a directory
17250
17251 if (keyspace == 1)
17252 {
17253 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17254
17255 return (-1);
17256 }
17257
17258 char **dictionary_files = NULL;
17259
17260 dictionary_files = scan_directory (filename);
17261
17262 if (dictionary_files != NULL)
17263 {
17264 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17265
17266 for (int d = 0; dictionary_files[d] != NULL; d++)
17267 {
17268 char *l1_filename = dictionary_files[d];
17269
17270 struct stat l1_stat;
17271
17272 if (stat (l1_filename, &l1_stat) == -1)
17273 {
17274 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17275
17276 return (-1);
17277 }
17278
17279 if (S_ISREG (l1_stat.st_mode))
17280 {
17281 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17282
17283 dictcnt++;
17284
17285 dictfiles[dictcnt - 1] = strdup (l1_filename);
17286 }
17287 }
17288 }
17289
17290 local_free (dictionary_files);
17291 }
17292 }
17293
17294 if (dictcnt < 1)
17295 {
17296 log_error ("ERROR: No usable dictionary file found.");
17297
17298 return (-1);
17299 }
17300
17301 if (increment)
17302 {
17303 maskcnt = 0;
17304
17305 uint mask_min = increment_min; // we can't reject smaller masks here
17306 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
17307
17308 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
17309 {
17310 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
17311
17312 if (cur_mask == NULL) break;
17313
17314 masks[maskcnt] = cur_mask;
17315
17316 maskcnt++;
17317
17318 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
17319 }
17320 }
17321 }
17322
17323 data.pw_min = pw_min;
17324 data.pw_max = pw_max;
17325
17326 /**
17327 * weak hash check
17328 */
17329
17330 if (weak_hash_threshold >= salts_cnt)
17331 {
17332 hc_device_param_t *device_param = NULL;
17333
17334 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17335 {
17336 device_param = &data.devices_param[device_id];
17337
17338 if (device_param->skipped) continue;
17339
17340 break;
17341 }
17342
17343 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
17344
17345 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
17346 {
17347 weak_hash_check (device_param, salt_pos);
17348 }
17349
17350 // Display hack, guarantee that there is at least one \r before real start
17351
17352 //if (data.quiet == 0) log_info ("");
17353 }
17354
17355 /**
17356 * status and monitor threads
17357 */
17358
17359 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17360 {
17361 data.devices_status = STATUS_STARTING;
17362 }
17363
17364 uint inner_threads_cnt = 0;
17365
17366 hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17367
17368 data.shutdown_inner = 0;
17369
17370 /**
17371 * Outfile remove
17372 */
17373
17374 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
17375 {
17376 hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL);
17377
17378 inner_threads_cnt++;
17379
17380 if (outfile_check_timer != 0)
17381 {
17382 if (data.outfile_check_directory != NULL)
17383 {
17384 if ((hash_mode != 5200) &&
17385 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17386 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17387 (hash_mode != 9000))
17388 {
17389 hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL);
17390
17391 inner_threads_cnt++;
17392 }
17393 else
17394 {
17395 outfile_check_timer = 0;
17396 }
17397 }
17398 else
17399 {
17400 outfile_check_timer = 0;
17401 }
17402 }
17403 }
17404
17405 /**
17406 * Inform the user if we got some hashes remove because of the pot file remove feature
17407 */
17408
17409 if (data.quiet == 0)
17410 {
17411 if (potfile_remove_cracks > 0)
17412 {
17413 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
17414 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
17415 }
17416 }
17417
17418 data.outfile_check_timer = outfile_check_timer;
17419
17420 /**
17421 * main loop
17422 */
17423
17424 char **induction_dictionaries = NULL;
17425
17426 int induction_dictionaries_cnt = 0;
17427
17428 hcstat_table_t *root_table_buf = NULL;
17429 hcstat_table_t *markov_table_buf = NULL;
17430
17431 uint initial_restore_done = 0;
17432
17433 data.maskcnt = maskcnt;
17434
17435 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17436 {
17437 if (data.devices_status == STATUS_CRACKED) continue;
17438 if (data.devices_status == STATUS_ABORTED) continue;
17439 if (data.devices_status == STATUS_QUIT) continue;
17440
17441 if (maskpos > rd->maskpos)
17442 {
17443 rd->dictpos = 0;
17444 }
17445
17446 rd->maskpos = maskpos;
17447 data.maskpos = maskpos;
17448
17449 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17450 {
17451 char *mask = masks[maskpos];
17452
17453 if (mask_from_file == 1)
17454 {
17455 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17456
17457 char *str_ptr;
17458 uint str_pos;
17459
17460 uint mask_offset = 0;
17461
17462 uint separator_cnt;
17463
17464 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17465 {
17466 str_ptr = strstr (mask + mask_offset, ",");
17467
17468 if (str_ptr == NULL) break;
17469
17470 str_pos = str_ptr - mask;
17471
17472 // escaped separator, i.e. "\,"
17473
17474 if (str_pos > 0)
17475 {
17476 if (mask[str_pos - 1] == '\\')
17477 {
17478 separator_cnt --;
17479
17480 mask_offset = str_pos + 1;
17481
17482 continue;
17483 }
17484 }
17485
17486 // reset the offset
17487
17488 mask_offset = 0;
17489
17490 mask[str_pos] = '\0';
17491
17492 switch (separator_cnt)
17493 {
17494 case 0:
17495 mp_reset_usr (mp_usr, 0);
17496
17497 custom_charset_1 = mask;
17498 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17499 break;
17500
17501 case 1:
17502 mp_reset_usr (mp_usr, 1);
17503
17504 custom_charset_2 = mask;
17505 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17506 break;
17507
17508 case 2:
17509 mp_reset_usr (mp_usr, 2);
17510
17511 custom_charset_3 = mask;
17512 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17513 break;
17514
17515 case 3:
17516 mp_reset_usr (mp_usr, 3);
17517
17518 custom_charset_4 = mask;
17519 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17520 break;
17521 }
17522
17523 mask = mask + str_pos + 1;
17524 }
17525
17526 /**
17527 * What follows is a very special case where "\," is within the mask field of a line in a .hcmask file only because otherwise (without the "\")
17528 * it would be interpreted as a custom charset definition.
17529 *
17530 * We need to replace all "\," with just "," within the mask (but allow the special case "\\," which means "\" followed by ",")
17531 * Note: "\\" is not needed to replace all "\" within the mask! The meaning of "\\" within a line containing the string "\\," is just to allow "\" followed by ","
17532 */
17533
17534 uint mask_len_cur = strlen (mask);
17535
17536 uint mask_out_pos = 0;
17537 char mask_prev = 0;
17538
17539 for (uint mask_iter = 0; mask_iter < mask_len_cur; mask_iter++, mask_out_pos++)
17540 {
17541 if (mask[mask_iter] == ',')
17542 {
17543 if (mask_prev == '\\')
17544 {
17545 mask_out_pos -= 1; // this means: skip the previous "\"
17546 }
17547 }
17548
17549 mask_prev = mask[mask_iter];
17550
17551 mask[mask_out_pos] = mask[mask_iter];
17552 }
17553
17554 mask[mask_out_pos] = '\0';
17555 }
17556
17557 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17558 {
17559 if (maskpos > 0)
17560 {
17561 local_free (css_buf);
17562 local_free (data.root_css_buf);
17563 local_free (data.markov_css_buf);
17564
17565 local_free (masks[maskpos - 1]);
17566 }
17567
17568 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17569
17570 data.mask = mask;
17571 data.css_cnt = css_cnt;
17572 data.css_buf = css_buf;
17573
17574 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17575
17576 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17577
17578 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17579 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17580
17581 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17582
17583 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17584
17585 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17586 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17587
17588 data.root_css_buf = root_css_buf;
17589 data.markov_css_buf = markov_css_buf;
17590
17591 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17592
17593 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17594
17595 local_free (root_table_buf);
17596 local_free (markov_table_buf);
17597
17598 // args
17599
17600 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17601 {
17602 hc_device_param_t *device_param = &data.devices_param[device_id];
17603
17604 if (device_param->skipped) continue;
17605
17606 device_param->kernel_params_mp[0] = &device_param->d_combs;
17607 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17608 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17609
17610 device_param->kernel_params_mp_buf64[3] = 0;
17611 device_param->kernel_params_mp_buf32[4] = css_cnt;
17612 device_param->kernel_params_mp_buf32[5] = 0;
17613 device_param->kernel_params_mp_buf32[6] = 0;
17614 device_param->kernel_params_mp_buf32[7] = 0;
17615
17616 if (attack_mode == ATTACK_MODE_HYBRID1)
17617 {
17618 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17619 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17620 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17621 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17622 }
17623 else if (attack_mode == ATTACK_MODE_HYBRID2)
17624 {
17625 device_param->kernel_params_mp_buf32[5] = 0;
17626 device_param->kernel_params_mp_buf32[6] = 0;
17627 device_param->kernel_params_mp_buf32[7] = 0;
17628 }
17629
17630 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]);
17631 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]);
17632 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]);
17633
17634 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);
17635 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);
17636 }
17637 }
17638 else if (attack_mode == ATTACK_MODE_BF)
17639 {
17640 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17641
17642 if (increment)
17643 {
17644 for (uint i = 0; i < dictcnt; i++)
17645 {
17646 local_free (dictfiles[i]);
17647 }
17648
17649 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17650 {
17651 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17652
17653 if (l1_filename == NULL) break;
17654
17655 dictcnt++;
17656
17657 dictfiles[dictcnt - 1] = l1_filename;
17658 }
17659 }
17660 else
17661 {
17662 dictcnt++;
17663
17664 dictfiles[dictcnt - 1] = mask;
17665 }
17666
17667 if (dictcnt == 0)
17668 {
17669 log_error ("ERROR: Mask is too small");
17670
17671 return (-1);
17672 }
17673 }
17674 }
17675
17676 free (induction_dictionaries);
17677
17678 // induction_dictionaries_cnt = 0; // implied
17679
17680 if (attack_mode != ATTACK_MODE_BF)
17681 {
17682 if (keyspace == 0)
17683 {
17684 induction_dictionaries = scan_directory (induction_directory);
17685
17686 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17687 }
17688 }
17689
17690 if (induction_dictionaries_cnt)
17691 {
17692 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17693 }
17694
17695 /**
17696 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17697 */
17698 if (keyspace == 1)
17699 {
17700 if ((maskcnt > 1) || (dictcnt > 1))
17701 {
17702 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17703
17704 return (-1);
17705 }
17706 }
17707
17708 for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
17709 {
17710 if (data.devices_status == STATUS_CRACKED) continue;
17711 if (data.devices_status == STATUS_ABORTED) continue;
17712 if (data.devices_status == STATUS_QUIT) continue;
17713
17714 rd->dictpos = dictpos;
17715
17716 char *subid = logfile_generate_subid ();
17717
17718 data.subid = subid;
17719
17720 logfile_sub_msg ("START");
17721
17722 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17723 {
17724 data.devices_status = STATUS_INIT;
17725 }
17726
17727 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17728 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17729 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17730
17731 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17732
17733 data.cpt_pos = 0;
17734
17735 data.cpt_start = time (NULL);
17736
17737 data.cpt_total = 0;
17738
17739 if (data.restore == 0)
17740 {
17741 rd->words_cur = skip;
17742
17743 skip = 0;
17744
17745 data.skip = 0;
17746 }
17747
17748 data.ms_paused = 0;
17749
17750 data.kernel_power_final = 0;
17751
17752 data.words_cur = rd->words_cur;
17753
17754 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17755 {
17756 hc_device_param_t *device_param = &data.devices_param[device_id];
17757
17758 if (device_param->skipped) continue;
17759
17760 device_param->speed_pos = 0;
17761
17762 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17763 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17764
17765 device_param->exec_pos = 0;
17766
17767 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17768
17769 device_param->outerloop_pos = 0;
17770 device_param->outerloop_left = 0;
17771 device_param->innerloop_pos = 0;
17772 device_param->innerloop_left = 0;
17773
17774 // some more resets:
17775
17776 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17777
17778 device_param->pws_cnt = 0;
17779
17780 device_param->words_off = 0;
17781 device_param->words_done = 0;
17782 }
17783
17784 // figure out some workload
17785
17786 if (attack_mode == ATTACK_MODE_STRAIGHT)
17787 {
17788 if (data.wordlist_mode == WL_MODE_FILE)
17789 {
17790 char *dictfile = NULL;
17791
17792 if (induction_dictionaries_cnt)
17793 {
17794 dictfile = induction_dictionaries[0];
17795 }
17796 else
17797 {
17798 dictfile = dictfiles[dictpos];
17799 }
17800
17801 data.dictfile = dictfile;
17802
17803 logfile_sub_string (dictfile);
17804
17805 for (uint i = 0; i < rp_files_cnt; i++)
17806 {
17807 logfile_sub_var_string ("rulefile", rp_files[i]);
17808 }
17809
17810 FILE *fd2 = fopen (dictfile, "rb");
17811
17812 if (fd2 == NULL)
17813 {
17814 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17815
17816 return (-1);
17817 }
17818
17819 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17820
17821 fclose (fd2);
17822
17823 if (data.words_cnt == 0)
17824 {
17825 logfile_sub_msg ("STOP");
17826
17827 continue;
17828 }
17829 }
17830 }
17831 else if (attack_mode == ATTACK_MODE_COMBI)
17832 {
17833 char *dictfile = data.dictfile;
17834 char *dictfile2 = data.dictfile2;
17835
17836 logfile_sub_string (dictfile);
17837 logfile_sub_string (dictfile2);
17838
17839 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17840 {
17841 FILE *fd2 = fopen (dictfile, "rb");
17842
17843 if (fd2 == NULL)
17844 {
17845 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17846
17847 return (-1);
17848 }
17849
17850 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17851
17852 fclose (fd2);
17853 }
17854 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17855 {
17856 FILE *fd2 = fopen (dictfile2, "rb");
17857
17858 if (fd2 == NULL)
17859 {
17860 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17861
17862 return (-1);
17863 }
17864
17865 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17866
17867 fclose (fd2);
17868 }
17869
17870 if (data.words_cnt == 0)
17871 {
17872 logfile_sub_msg ("STOP");
17873
17874 continue;
17875 }
17876 }
17877 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17878 {
17879 char *dictfile = NULL;
17880
17881 if (induction_dictionaries_cnt)
17882 {
17883 dictfile = induction_dictionaries[0];
17884 }
17885 else
17886 {
17887 dictfile = dictfiles[dictpos];
17888 }
17889
17890 data.dictfile = dictfile;
17891
17892 char *mask = data.mask;
17893
17894 logfile_sub_string (dictfile);
17895 logfile_sub_string (mask);
17896
17897 FILE *fd2 = fopen (dictfile, "rb");
17898
17899 if (fd2 == NULL)
17900 {
17901 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17902
17903 return (-1);
17904 }
17905
17906 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17907
17908 fclose (fd2);
17909
17910 if (data.words_cnt == 0)
17911 {
17912 logfile_sub_msg ("STOP");
17913
17914 continue;
17915 }
17916 }
17917 else if (attack_mode == ATTACK_MODE_BF)
17918 {
17919 local_free (css_buf);
17920 local_free (data.root_css_buf);
17921 local_free (data.markov_css_buf);
17922
17923 char *mask = dictfiles[dictpos];
17924
17925 logfile_sub_string (mask);
17926
17927 // base
17928
17929 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17930
17931 if (opts_type & OPTS_TYPE_PT_UNICODE)
17932 {
17933 uint css_cnt_unicode = css_cnt * 2;
17934
17935 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17936
17937 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17938 {
17939 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17940
17941 css_buf_unicode[j + 1].cs_buf[0] = 0;
17942 css_buf_unicode[j + 1].cs_len = 1;
17943 }
17944
17945 free (css_buf);
17946
17947 css_buf = css_buf_unicode;
17948 css_cnt = css_cnt_unicode;
17949 }
17950
17951 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17952
17953 uint mask_min = pw_min;
17954 uint mask_max = pw_max;
17955
17956 if (opts_type & OPTS_TYPE_PT_UNICODE)
17957 {
17958 mask_min *= 2;
17959 mask_max *= 2;
17960 }
17961
17962 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17963 {
17964 if (css_cnt < mask_min)
17965 {
17966 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
17967 }
17968
17969 if (css_cnt > mask_max)
17970 {
17971 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
17972 }
17973
17974 // skip to next mask
17975
17976 logfile_sub_msg ("STOP");
17977
17978 continue;
17979 }
17980
17981 uint save_css_cnt = css_cnt;
17982
17983 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17984 {
17985 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17986 {
17987 uint salt_len = (uint) data.salts_buf[0].salt_len;
17988 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17989
17990 uint css_cnt_salt = css_cnt + salt_len;
17991
17992 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17993
17994 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17995
17996 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17997 {
17998 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17999 css_buf_salt[j].cs_len = 1;
18000 }
18001
18002 free (css_buf);
18003
18004 css_buf = css_buf_salt;
18005 css_cnt = css_cnt_salt;
18006 }
18007 }
18008
18009 data.mask = mask;
18010 data.css_cnt = css_cnt;
18011 data.css_buf = css_buf;
18012
18013 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
18014
18015 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
18016
18017 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
18018
18019 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
18020 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
18021
18022 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
18023
18024 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
18025
18026 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
18027 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
18028
18029 data.root_css_buf = root_css_buf;
18030 data.markov_css_buf = markov_css_buf;
18031
18032 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
18033
18034 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
18035
18036 local_free (root_table_buf);
18037 local_free (markov_table_buf);
18038
18039 // copy + args
18040
18041 uint css_cnt_l = css_cnt;
18042 uint css_cnt_r;
18043
18044 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
18045 {
18046 if (save_css_cnt < 6)
18047 {
18048 css_cnt_r = 1;
18049 }
18050 else if (save_css_cnt == 6)
18051 {
18052 css_cnt_r = 2;
18053 }
18054 else
18055 {
18056 if (opts_type & OPTS_TYPE_PT_UNICODE)
18057 {
18058 if (save_css_cnt == 8 || save_css_cnt == 10)
18059 {
18060 css_cnt_r = 2;
18061 }
18062 else
18063 {
18064 css_cnt_r = 4;
18065 }
18066 }
18067 else
18068 {
18069 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
18070 {
18071 css_cnt_r = 3;
18072 }
18073 else
18074 {
18075 css_cnt_r = 4;
18076 }
18077 }
18078 }
18079 }
18080 else
18081 {
18082 css_cnt_r = 1;
18083
18084 /* unfinished code?
18085 int sum = css_buf[css_cnt_r - 1].cs_len;
18086
18087 for (uint i = 1; i < 4 && i < css_cnt; i++)
18088 {
18089 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
18090
18091 css_cnt_r++;
18092
18093 sum *= css_buf[css_cnt_r - 1].cs_len;
18094 }
18095 */
18096 }
18097
18098 css_cnt_l -= css_cnt_r;
18099
18100 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
18101
18102 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18103 {
18104 hc_device_param_t *device_param = &data.devices_param[device_id];
18105
18106 if (device_param->skipped) continue;
18107
18108 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
18109 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
18110 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
18111
18112 device_param->kernel_params_mp_l_buf64[3] = 0;
18113 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
18114 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
18115 device_param->kernel_params_mp_l_buf32[6] = 0;
18116 device_param->kernel_params_mp_l_buf32[7] = 0;
18117 device_param->kernel_params_mp_l_buf32[8] = 0;
18118
18119 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
18120 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
18121 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
18122 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
18123
18124 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
18125 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
18126 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
18127
18128 device_param->kernel_params_mp_r_buf64[3] = 0;
18129 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
18130 device_param->kernel_params_mp_r_buf32[5] = 0;
18131 device_param->kernel_params_mp_r_buf32[6] = 0;
18132 device_param->kernel_params_mp_r_buf32[7] = 0;
18133
18134 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]);
18135 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]);
18136 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]);
18137
18138 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]);
18139 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]);
18140 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]);
18141
18142 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);
18143 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);
18144 }
18145 }
18146
18147 u64 words_base = data.words_cnt;
18148
18149 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18150 {
18151 if (data.kernel_rules_cnt)
18152 {
18153 words_base /= data.kernel_rules_cnt;
18154 }
18155 }
18156 else if (data.attack_kern == ATTACK_KERN_COMBI)
18157 {
18158 if (data.combs_cnt)
18159 {
18160 words_base /= data.combs_cnt;
18161 }
18162 }
18163 else if (data.attack_kern == ATTACK_KERN_BF)
18164 {
18165 if (data.bfs_cnt)
18166 {
18167 words_base /= data.bfs_cnt;
18168 }
18169 }
18170
18171 data.words_base = words_base;
18172
18173 if (keyspace == 1)
18174 {
18175 log_info ("%llu", (unsigned long long int) words_base);
18176
18177 return (0);
18178 }
18179
18180 if (data.words_cur > data.words_base)
18181 {
18182 log_error ("ERROR: Restore value greater keyspace");
18183
18184 return (-1);
18185 }
18186
18187 if (data.words_cur)
18188 {
18189 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
18190 {
18191 for (uint i = 0; i < data.salts_cnt; i++)
18192 {
18193 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
18194 }
18195 }
18196 else if (data.attack_kern == ATTACK_KERN_COMBI)
18197 {
18198 for (uint i = 0; i < data.salts_cnt; i++)
18199 {
18200 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
18201 }
18202 }
18203 else if (data.attack_kern == ATTACK_KERN_BF)
18204 {
18205 for (uint i = 0; i < data.salts_cnt; i++)
18206 {
18207 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
18208 }
18209 }
18210 }
18211
18212 /*
18213 * Update loopback file
18214 */
18215
18216 if (loopback == 1)
18217 {
18218 time_t now;
18219
18220 time (&now);
18221
18222 uint random_num = get_random_num (0, 9999);
18223
18224 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
18225
18226 data.loopback_file = loopback_file;
18227 }
18228
18229 /*
18230 * Update dictionary statistic
18231 */
18232
18233 if (keyspace == 0)
18234 {
18235 dictstat_fp = fopen (dictstat, "wb");
18236
18237 if (dictstat_fp)
18238 {
18239 lock_file (dictstat_fp);
18240
18241 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
18242
18243 fclose (dictstat_fp);
18244 }
18245 }
18246
18247 /**
18248 * create autotune threads
18249 */
18250
18251 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
18252
18253 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18254 {
18255 data.devices_status = STATUS_AUTOTUNE;
18256 }
18257
18258 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18259 {
18260 hc_device_param_t *device_param = &devices_param[device_id];
18261
18262 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
18263 }
18264
18265 hc_thread_wait (data.devices_cnt, c_threads);
18266
18267 /*
18268 * Inform user about possible slow speeds
18269 */
18270
18271 uint hardware_power_all = 0;
18272
18273 uint kernel_power_all = 0;
18274
18275 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18276 {
18277 hc_device_param_t *device_param = &devices_param[device_id];
18278
18279 hardware_power_all += device_param->hardware_power;
18280
18281 kernel_power_all += device_param->kernel_power;
18282 }
18283
18284 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
18285
18286 data.kernel_power_all = kernel_power_all;
18287
18288 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18289 {
18290 if (data.words_base < kernel_power_all)
18291 {
18292 if (quiet == 0)
18293 {
18294 clear_prompt ();
18295
18296 log_info ("ATTENTION!");
18297 log_info (" The wordlist or mask you are using is too small.");
18298 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
18299 log_info (" The cracking speed will drop.");
18300 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
18301 log_info ("");
18302 }
18303 }
18304 }
18305
18306 /**
18307 * create cracker threads
18308 */
18309
18310 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18311 {
18312 data.devices_status = STATUS_RUNNING;
18313 }
18314
18315 if (initial_restore_done == 0)
18316 {
18317 if (data.restore_disable == 0) cycle_restore ();
18318
18319 initial_restore_done = 1;
18320 }
18321
18322 hc_timer_set (&data.timer_running);
18323
18324 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
18325 {
18326 if ((quiet == 0) && (status == 0) && (benchmark == 0))
18327 {
18328 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
18329 if (quiet == 0) fflush (stdout);
18330 }
18331 }
18332 else if (wordlist_mode == WL_MODE_STDIN)
18333 {
18334 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
18335 if (data.quiet == 0) log_info ("");
18336 }
18337
18338 time_t runtime_start;
18339
18340 time (&runtime_start);
18341
18342 data.runtime_start = runtime_start;
18343
18344 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18345 {
18346 hc_device_param_t *device_param = &devices_param[device_id];
18347
18348 if (wordlist_mode == WL_MODE_STDIN)
18349 {
18350 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
18351 }
18352 else
18353 {
18354 hc_thread_create (c_threads[device_id], thread_calc, device_param);
18355 }
18356 }
18357
18358 hc_thread_wait (data.devices_cnt, c_threads);
18359
18360 local_free (c_threads);
18361
18362 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18363 {
18364 data.devices_status = STATUS_EXHAUSTED;
18365 }
18366
18367 logfile_sub_var_uint ("status-after-work", data.devices_status);
18368
18369 data.restore = 0;
18370
18371 if (induction_dictionaries_cnt)
18372 {
18373 unlink (induction_dictionaries[0]);
18374 }
18375
18376 free (induction_dictionaries);
18377
18378 if (attack_mode != ATTACK_MODE_BF)
18379 {
18380 induction_dictionaries = scan_directory (induction_directory);
18381
18382 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18383 }
18384
18385 if (benchmark == 1)
18386 {
18387 status_benchmark ();
18388
18389 if (machine_readable == 0)
18390 {
18391 log_info ("");
18392 }
18393 }
18394 else
18395 {
18396 if (quiet == 0)
18397 {
18398 clear_prompt ();
18399
18400 log_info ("");
18401
18402 status_display ();
18403
18404 log_info ("");
18405 }
18406 else
18407 {
18408 if (status == 1)
18409 {
18410 status_display ();
18411 }
18412 }
18413 }
18414
18415 if (induction_dictionaries_cnt)
18416 {
18417 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18418
18419 // yeah, this next statement is a little hack to make sure that --loopback runs correctly (because with it we guarantee that the loop iterates one more time)
18420
18421 dictpos--;
18422 }
18423
18424 time_t runtime_stop;
18425
18426 time (&runtime_stop);
18427
18428 data.runtime_stop = runtime_stop;
18429
18430 logfile_sub_uint (runtime_start);
18431 logfile_sub_uint (runtime_stop);
18432
18433 logfile_sub_msg ("STOP");
18434
18435 global_free (subid);
18436
18437 // from this point we handle bypass as running
18438
18439 if (data.devices_status == STATUS_BYPASS)
18440 {
18441 data.devices_status = STATUS_RUNNING;
18442 }
18443
18444 // and overwrite benchmark aborts as well
18445
18446 if (data.benchmark == 1)
18447 {
18448 if (data.devices_status == STATUS_ABORTED)
18449 {
18450 data.devices_status = STATUS_RUNNING;
18451 }
18452 }
18453
18454 // finalize task
18455
18456 if (data.devices_status == STATUS_CRACKED) break;
18457 if (data.devices_status == STATUS_ABORTED) break;
18458 if (data.devices_status == STATUS_QUIT) break;
18459 }
18460
18461 if (data.devices_status == STATUS_CRACKED) break;
18462 if (data.devices_status == STATUS_ABORTED) break;
18463 if (data.devices_status == STATUS_QUIT) break;
18464 }
18465
18466 // 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
18467 if (attack_mode == ATTACK_MODE_STRAIGHT)
18468 {
18469 if (data.wordlist_mode == WL_MODE_FILE)
18470 {
18471 if (data.dictfile == NULL)
18472 {
18473 if (dictfiles != NULL)
18474 {
18475 data.dictfile = dictfiles[0];
18476
18477 hc_timer_set (&data.timer_running);
18478 }
18479 }
18480 }
18481 }
18482 // NOTE: combi is okay because it is already set beforehand
18483 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18484 {
18485 if (data.dictfile == NULL)
18486 {
18487 if (dictfiles != NULL)
18488 {
18489 hc_timer_set (&data.timer_running);
18490
18491 data.dictfile = dictfiles[0];
18492 }
18493 }
18494 }
18495 else if (attack_mode == ATTACK_MODE_BF)
18496 {
18497 if (data.mask == NULL)
18498 {
18499 hc_timer_set (&data.timer_running);
18500
18501 data.mask = masks[0];
18502 }
18503 }
18504
18505 // if cracked / aborted remove last induction dictionary
18506
18507 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18508 {
18509 struct stat induct_stat;
18510
18511 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18512 {
18513 unlink (induction_dictionaries[file_pos]);
18514 }
18515 }
18516
18517 // wait for inner threads
18518
18519 data.shutdown_inner = 1;
18520
18521 for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++)
18522 {
18523 hc_thread_wait (1, &inner_threads[thread_idx]);
18524 }
18525
18526 local_free (inner_threads);
18527
18528 // we dont need restore file anymore
18529 if (data.restore_disable == 0)
18530 {
18531 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18532 {
18533 unlink (eff_restore_file);
18534 unlink (new_restore_file);
18535 }
18536 else
18537 {
18538 cycle_restore ();
18539 }
18540 }
18541
18542 // finally save left hashes
18543
18544 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18545 {
18546 save_hash ();
18547 }
18548
18549 /**
18550 * Clean up
18551 */
18552
18553 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18554 {
18555 hc_device_param_t *device_param = &data.devices_param[device_id];
18556
18557 if (device_param->skipped) continue;
18558
18559 local_free (device_param->combs_buf);
18560 local_free (device_param->hooks_buf);
18561 local_free (device_param->device_name);
18562 local_free (device_param->device_name_chksum);
18563 local_free (device_param->device_version);
18564 local_free (device_param->driver_version);
18565
18566 if (device_param->pws_buf) myfree (device_param->pws_buf);
18567 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18568 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18569 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18570 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18571 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18572 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18573 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18574 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18575 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18576 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18577 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18578 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18579 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18580 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18581 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18582 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18583 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18584 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18585 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18586 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18587 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18588 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18589 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18590 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18591 if (device_param->d_scryptV0_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV0_buf);
18592 if (device_param->d_scryptV1_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV1_buf);
18593 if (device_param->d_scryptV2_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV2_buf);
18594 if (device_param->d_scryptV3_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV3_buf);
18595 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18596 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18597 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18598
18599 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18600 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18601 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18602 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18603 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18604 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18605 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18606 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18607 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18608 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18609 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18610
18611 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18612 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18613 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18614
18615 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18616 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18617 }
18618
18619 // reset default fan speed
18620
18621 #ifdef HAVE_HWMON
18622 if (gpu_temp_disable == 0)
18623 {
18624 if (gpu_temp_retain != 0)
18625 {
18626 hc_thread_mutex_lock (mux_adl);
18627
18628 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18629 {
18630 hc_device_param_t *device_param = &data.devices_param[device_id];
18631
18632 if (device_param->skipped) continue;
18633
18634 if (data.hm_device[device_id].fan_set_supported == 1)
18635 {
18636 int rc = -1;
18637
18638 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18639 {
18640 rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0);
18641 }
18642 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18643 {
18644 #ifdef LINUX
18645 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
18646 #endif
18647
18648 #ifdef WIN
18649 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 0);
18650 #endif
18651 }
18652
18653 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18654 }
18655 }
18656
18657 hc_thread_mutex_unlock (mux_adl);
18658 }
18659 }
18660
18661 // reset power tuning
18662
18663 if (powertune_enable == 1)
18664 {
18665 hc_thread_mutex_lock (mux_adl);
18666
18667 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18668 {
18669 hc_device_param_t *device_param = &data.devices_param[device_id];
18670
18671 if (device_param->skipped) continue;
18672
18673 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18674 {
18675 if (data.hm_device[device_id].od_version == 6)
18676 {
18677 // check powertune capabilities first, if not available then skip device
18678
18679 int powertune_supported = 0;
18680
18681 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18682 {
18683 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18684
18685 return (-1);
18686 }
18687
18688 if (powertune_supported != 0)
18689 {
18690 // powercontrol settings
18691
18692 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18693 {
18694 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18695
18696 return (-1);
18697 }
18698
18699 // clocks
18700
18701 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18702
18703 performance_state->iNumberOfPerformanceLevels = 2;
18704
18705 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18706 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18707 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18708 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18709
18710 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18711 {
18712 log_info ("ERROR: Failed to restore ADL performance state");
18713
18714 return (-1);
18715 }
18716
18717 local_free (performance_state);
18718 }
18719 }
18720 }
18721
18722 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18723 {
18724 unsigned int limit = nvml_power_limit[device_id];
18725
18726 if (limit > 0)
18727 {
18728 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18729 }
18730 }
18731 }
18732
18733 hc_thread_mutex_unlock (mux_adl);
18734 }
18735
18736 if (gpu_temp_disable == 0)
18737 {
18738 if (data.hm_nvml)
18739 {
18740 hm_NVML_nvmlShutdown (data.hm_nvml);
18741
18742 nvml_close (data.hm_nvml);
18743
18744 data.hm_nvml = NULL;
18745 }
18746
18747 if (data.hm_nvapi)
18748 {
18749 hm_NvAPI_Unload (data.hm_nvapi);
18750
18751 nvapi_close (data.hm_nvapi);
18752
18753 data.hm_nvapi = NULL;
18754 }
18755
18756 if (data.hm_xnvctrl)
18757 {
18758 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
18759
18760 xnvctrl_close (data.hm_xnvctrl);
18761
18762 data.hm_xnvctrl = NULL;
18763 }
18764
18765 if (data.hm_adl)
18766 {
18767 hm_ADL_Main_Control_Destroy (data.hm_adl);
18768
18769 adl_close (data.hm_adl);
18770
18771 data.hm_adl = NULL;
18772 }
18773 }
18774 #endif // HAVE_HWMON
18775
18776 // free memory
18777
18778 local_free (masks);
18779
18780 local_free (dictstat_base);
18781
18782 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18783 {
18784 pot_t *pot_ptr = &pot[pot_pos];
18785
18786 hash_t *hash = &pot_ptr->hash;
18787
18788 local_free (hash->digest);
18789
18790 if (isSalted)
18791 {
18792 local_free (hash->salt);
18793 }
18794 }
18795
18796 local_free (pot);
18797
18798 local_free (all_kernel_rules_cnt);
18799 local_free (all_kernel_rules_buf);
18800
18801 local_free (wl_data->buf);
18802 local_free (wl_data);
18803
18804 local_free (bitmap_s1_a);
18805 local_free (bitmap_s1_b);
18806 local_free (bitmap_s1_c);
18807 local_free (bitmap_s1_d);
18808 local_free (bitmap_s2_a);
18809 local_free (bitmap_s2_b);
18810 local_free (bitmap_s2_c);
18811 local_free (bitmap_s2_d);
18812
18813 #ifdef HAVE_HWMON
18814 local_free (od_clock_mem_status);
18815 local_free (od_power_control_status);
18816 local_free (nvml_power_limit);
18817 #endif
18818
18819 global_free (devices_param);
18820
18821 global_free (kernel_rules_buf);
18822
18823 global_free (root_css_buf);
18824 global_free (markov_css_buf);
18825
18826 global_free (digests_buf);
18827 global_free (digests_shown);
18828 global_free (digests_shown_tmp);
18829
18830 global_free (salts_buf);
18831 global_free (salts_shown);
18832
18833 global_free (esalts_buf);
18834
18835 global_free (words_progress_done);
18836 global_free (words_progress_rejected);
18837 global_free (words_progress_restored);
18838
18839 if (pot_fp) fclose (pot_fp);
18840
18841 if (data.devices_status == STATUS_QUIT) break;
18842 }
18843
18844 // wait for outer threads
18845
18846 data.shutdown_outer = 1;
18847
18848 for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++)
18849 {
18850 hc_thread_wait (1, &outer_threads[thread_idx]);
18851 }
18852
18853 local_free (outer_threads);
18854
18855 // destroy others mutex
18856
18857 hc_thread_mutex_delete (mux_dispatcher);
18858 hc_thread_mutex_delete (mux_counter);
18859 hc_thread_mutex_delete (mux_display);
18860 hc_thread_mutex_delete (mux_adl);
18861
18862 // free memory
18863
18864 local_free (eff_restore_file);
18865 local_free (new_restore_file);
18866
18867 local_free (rd);
18868
18869 // tuning db
18870
18871 tuning_db_destroy (tuning_db);
18872
18873 // loopback
18874
18875 local_free (loopback_file);
18876
18877 if (loopback == 1) unlink (loopback_file);
18878
18879 // induction directory
18880
18881 if (induction_dir == NULL)
18882 {
18883 if (attack_mode != ATTACK_MODE_BF)
18884 {
18885 if (rmdir (induction_directory) == -1)
18886 {
18887 if (errno == ENOENT)
18888 {
18889 // good, we can ignore
18890 }
18891 else if (errno == ENOTEMPTY)
18892 {
18893 // good, we can ignore
18894 }
18895 else
18896 {
18897 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18898
18899 return (-1);
18900 }
18901 }
18902
18903 local_free (induction_directory);
18904 }
18905 }
18906
18907 // outfile-check directory
18908
18909 if (outfile_check_dir == NULL)
18910 {
18911 if (rmdir (outfile_check_directory) == -1)
18912 {
18913 if (errno == ENOENT)
18914 {
18915 // good, we can ignore
18916 }
18917 else if (errno == ENOTEMPTY)
18918 {
18919 // good, we can ignore
18920 }
18921 else
18922 {
18923 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18924
18925 return (-1);
18926 }
18927 }
18928
18929 local_free (outfile_check_directory);
18930 }
18931
18932 time_t proc_stop;
18933
18934 time (&proc_stop);
18935
18936 logfile_top_uint (proc_start);
18937 logfile_top_uint (proc_stop);
18938
18939 logfile_top_msg ("STOP");
18940
18941 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18942 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18943
18944 if (data.ocl) ocl_close (data.ocl);
18945
18946 if (data.devices_status == STATUS_ABORTED) return 2;
18947 if (data.devices_status == STATUS_QUIT) return 2;
18948 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18949 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18950 if (data.devices_status == STATUS_CRACKED) return 0;
18951
18952 return -1;
18953 }
Hashcat additions to support pwdhash