projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Change format of option headers to something less eye cancerous.
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMATE 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "- [ Options ] -",
353 "",
354 " Options Short / Long | Type | Description | Example",
355 "===============================|======|======================================================|=======================",
356 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
357 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
358 " -V, --version | | Print version |",
359 " -h, --help | | Print help |",
360 " --quiet | | Suppress output |",
361 " --hex-charset | | Assume charset is given in hex |",
362 " --hex-salt | | Assume salt is given in hex |",
363 " --hex-wordlist | | Assume words in wordlist is given in hex |",
364 " --force | | Ignore warnings |",
365 " --status | | Enable automatic update of the status-screen |",
366 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
367 " --status-automate | | Display the status view in a machine readable format |",
368 " --loopback | | Add new plains to induct directory |",
369 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
370 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
371 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
372 " --markov-classic | | Enables classic markov-chains, no per-position |",
373 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
374 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
375 " --session | Str | Define specific session name | --session=mysession",
376 " --restore | | Restore session from --session |",
377 " --restore-disable | | Do not write restore file |",
378 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
379 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
380 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
381 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
382 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
383 " --show | | Show cracked passwords only |",
384 " --left | | Show un-cracked passwords only |",
385 " --username | | Enable ignoring of usernames in hashfile |",
386 " --remove | | Enable remove of hash once it is cracked |",
387 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
388 " --potfile-disable | | Do not write potfile |",
389 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
390 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
391 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
392 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
393 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
394 " --logfile-disable | | Disable the logfile |",
395 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
396 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
397 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
398 " -b, --benchmark | | Run benchmark |",
399 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
400 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
401 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
402 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
403 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
404 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
405 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
406 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
407 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
408 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
409 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
410 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
411 #ifdef HAVE_HWMON
412 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
413 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
414 #ifdef HAVE_ADL
415 " --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) |",
416 #endif
417 #endif
418 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
419 " -s, --skip | Num | Skip X words from the start | -s 1000000",
420 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
421 " --keyspace | | Show keyspace base:mod values and quit |",
422 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
423 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
424 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
425 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
426 " --generate-rules-func-min | Num | Force min X funcs per rule |",
427 " --generate-rules-func-max | Num | Force max X funcs per rule |",
428 " --generate-rules-seed | Num | Force RNG seed set to X |",
429 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
430 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
431 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
432 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
433 " -i, --increment | | Enable mask increment mode |",
434 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
435 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
436 "",
437 "- [ Hash modes ] -",
438 "",
439 " # | Name | Category",
440 " ------+--------------------------------------------------+--------------------------------------",
441 " 900 | MD4 | Raw Hash",
442 " 0 | MD5 | Raw Hash",
443 " 5100 | Half MD5 | Raw Hash",
444 " 100 | SHA1 | Raw Hash",
445 " 10800 | SHA-384 | Raw Hash",
446 " 1400 | SHA-256 | Raw Hash",
447 " 1700 | SHA-512 | Raw Hash",
448 " 5000 | SHA-3(Keccak) | Raw Hash",
449 " 10100 | SipHash | Raw Hash",
450 " 6000 | RipeMD160 | Raw Hash",
451 " 6100 | Whirlpool | Raw Hash",
452 " 6900 | GOST R 34.11-94 | Raw Hash",
453 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
454 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
455 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
456 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
457 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
458 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
459 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
460 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
461 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
462 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
463 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
464 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
465 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
466 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
467 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
468 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
469 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
470 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
471 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
472 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
473 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
474 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
475 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
476 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
477 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
478 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
479 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
480 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
481 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
482 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
483 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
484 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
485 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
486 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
487 " 400 | phpass | Generic KDF",
488 " 8900 | scrypt | Generic KDF",
489 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
490 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
491 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
492 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
493 " 23 | Skype | Network protocols",
494 " 2500 | WPA/WPA2 | Network protocols",
495 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
496 " 5300 | IKE-PSK MD5 | Network protocols",
497 " 5400 | IKE-PSK SHA1 | Network protocols",
498 " 5500 | NetNTLMv1 | Network protocols",
499 " 5500 | NetNTLMv1 + ESS | Network protocols",
500 " 5600 | NetNTLMv2 | Network protocols",
501 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
502 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
503 " 8300 | DNSSEC (NSEC3) | Network protocols",
504 " 10200 | Cram MD5 | Network protocols",
505 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
506 " 11200 | MySQL CRAM (SHA1) | Network protocols",
507 " 11400 | SIP digest authentication (MD5) | Network protocols",
508 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
509 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
510 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
511 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
512 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
513 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
514 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
515 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
516 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
517 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
518 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
519 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
520 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
521 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
522 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
523 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
524 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
525 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
526 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
527 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
528 " 12 | PostgreSQL | Database Server",
529 " 131 | MSSQL(2000) | Database Server",
530 " 132 | MSSQL(2005) | Database Server",
531 " 1731 | MSSQL(2012) | Database Server",
532 " 1731 | MSSQL(2014) | Database Server",
533 " 200 | MySQL323 | Database Server",
534 " 300 | MySQL4.1/MySQL5 | Database Server",
535 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
536 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
537 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
538 " 8000 | Sybase ASE | Database Server",
539 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
540 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
541 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
542 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
543 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
544 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
545 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
546 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
547 " 11500 | CRC32 | Checksums",
548 " 3000 | LM | Operating-Systems",
549 " 1000 | NTLM | Operating-Systems",
550 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
551 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
552 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
553 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
554 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
555 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
556 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
557 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
558 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
559 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
560 " 1722 | OSX v10.7 | Operating-Systems",
561 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
562 " 6300 | AIX {smd5} | Operating-Systems",
563 " 6700 | AIX {ssha1} | Operating-Systems",
564 " 6400 | AIX {ssha256} | Operating-Systems",
565 " 6500 | AIX {ssha512} | Operating-Systems",
566 " 2400 | Cisco-PIX | Operating-Systems",
567 " 2410 | Cisco-ASA | Operating-Systems",
568 " 500 | Cisco-IOS $1$ | Operating-Systems",
569 " 5700 | Cisco-IOS $4$ | Operating-Systems",
570 " 9200 | Cisco-IOS $8$ | Operating-Systems",
571 " 9300 | Cisco-IOS $9$ | Operating-Systems",
572 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
573 " 501 | Juniper IVE | Operating-Systems",
574 " 5800 | Android PIN | Operating-Systems",
575 " 8100 | Citrix Netscaler | Operating-Systems",
576 " 8500 | RACF | Operating-Systems",
577 " 7200 | GRUB 2 | Operating-Systems",
578 " 9900 | Radmin2 | Operating-Systems",
579 " 125 | ArubaOS | Operating-Systems",
580 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
581 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
582 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
583 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
584 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
585 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
586 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
587 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
588 " 11600 | 7-Zip | Archives",
589 " 12500 | RAR3-hp | Archives",
590 " 13000 | RAR5 | Archives",
591 " 13200 | AxCrypt | Archives",
592 " 13300 | AxCrypt in memory SHA1 | Archives",
593 " 13600 | WinZip | Archives",
594 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
595 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
596 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
597 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
598 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
599 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
600 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
601 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
602 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
603 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
604 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
605 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
606 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
607 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
608 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
609 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
610 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
611 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
612 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
613 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
614 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
615 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
616 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
617 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
618 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
619 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
620 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
621 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
622 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
623 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
624 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
625 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
626 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
627 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
628 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
629 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
630 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
631 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
632 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
633 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
634 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
635 " 9400 | MS Office 2007 | Documents",
636 " 9500 | MS Office 2010 | Documents",
637 " 9600 | MS Office 2013 | Documents",
638 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
639 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
640 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
641 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
642 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
643 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
644 " 9000 | Password Safe v2 | Password Managers",
645 " 5200 | Password Safe v3 | Password Managers",
646 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
647 " 6600 | 1Password, agilekeychain | Password Managers",
648 " 8200 | 1Password, cloudkeychain | Password Managers",
649 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
650 " 12700 | Blockchain, My Wallet | Password Managers",
651 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
652 "",
653 "- [ Outfile Formats ] -",
654 "",
655 " # | Format",
656 " ---+--------",
657 " 1 | hash[:salt]",
658 " 2 | plain",
659 " 3 | hash[:salt]:plain",
660 " 4 | hex_plain",
661 " 5 | hash[:salt]:hex_plain",
662 " 6 | plain:hex_plain",
663 " 7 | hash[:salt]:plain:hex_plain",
664 " 8 | crackpos",
665 " 9 | hash[:salt]:crack_pos",
666 " 10 | plain:crack_pos",
667 " 11 | hash[:salt]:plain:crack_pos",
668 " 12 | hex_plain:crack_pos",
669 " 13 | hash[:salt]:hex_plain:crack_pos",
670 " 14 | plain:hex_plain:crack_pos",
671 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
672 "",
673 "- [ Rule Debugging Modes ] -",
674 "",
675 " # | Format",
676 " ---+--------",
677 " 1 | Finding-Rule",
678 " 2 | Original-Word",
679 " 3 | Original-Word:Finding-Rule",
680 " 4 | Original-Word:Finding-Rule:Processed-Word",
681 "",
682 "- [ Attack Modes ] -",
683 "",
684 " # | Mode",
685 " ---+------",
686 " 0 | Straight",
687 " 1 | Combination",
688 " 3 | Brute-force",
689 " 6 | Hybrid Wordlist + Mask",
690 " 7 | Hybrid Mask + Wordlist",
691 "",
692 "- [ Built-in Charsets ] -",
693 "",
694 " ? | Charset",
695 " ---+---------",
696 " l | abcdefghijklmnopqrstuvwxyz",
697 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
698 " d | 0123456789",
699 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
700 " a | ?l?u?d?s",
701 " b | 0x00 - 0xff",
702 "",
703 "- [ OpenCL Device Types ] -",
704 "",
705 " # | Device Type",
706 " ---+-------------",
707 " 1 | CPU",
708 " 2 | GPU",
709 " 3 | FPGA, DSP, Co-Processor",
710 "",
711 "- [ Workload Profiles ] -",
712 "",
713 " # | Performance | Runtime | Power Consumption | Desktop Impact",
714 " ---+-------------+---------+-------------------+----------------",
715 " 1 | Low | 2 ms | Low | Minimal",
716 " 2 | Default | 12 ms | Economic | Noticeable",
717 " 3 | High | 96 ms | High | Unresponsive",
718 " 4 | Nightmare | 480 ms | Insane | Headless",
719 "",
720 "If you have no idea what just happened then visit the following pages:",
721 "",
722 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
723 "* https://hashcat.net/wiki/#frequently_asked_questions",
724 "",
725 NULL
726 };
727
728 /**
729 * hashcat specific functions
730 */
731
732 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
733 {
734 int exec_pos = (int) device_param->exec_pos - last_num_entries;
735
736 if (exec_pos < 0) exec_pos += EXEC_CACHE;
737
738 double exec_ms_sum = 0;
739
740 int exec_ms_cnt = 0;
741
742 for (int i = 0; i < last_num_entries; i++)
743 {
744 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
745
746 if (exec_ms)
747 {
748 exec_ms_sum += exec_ms;
749
750 exec_ms_cnt++;
751 }
752 }
753
754 if (exec_ms_cnt == 0) return 0;
755
756 return exec_ms_sum / exec_ms_cnt;
757 }
758
759 void status_display_automate ()
760 {
761 FILE *out = stdout;
762
763 fprintf (out, "STATUS\t%u\t", data.devices_status);
764
765 /**
766 * speed new
767 */
768
769 fprintf (out, "SPEED\t");
770
771 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
772 {
773 hc_device_param_t *device_param = &data.devices_param[device_id];
774
775 if (device_param->skipped) continue;
776
777 u64 speed_cnt = 0;
778 double speed_ms = 0;
779
780 for (int i = 0; i < SPEED_CACHE; i++)
781 {
782 speed_cnt += device_param->speed_cnt[i];
783 speed_ms += device_param->speed_ms[i];
784 }
785
786 speed_cnt /= SPEED_CACHE;
787 speed_ms /= SPEED_CACHE;
788
789 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
790 }
791
792 /**
793 * exec time
794 */
795
796 fprintf (out, "EXEC_RUNTIME\t");
797
798 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
799 {
800 hc_device_param_t *device_param = &data.devices_param[device_id];
801
802 if (device_param->skipped) continue;
803
804 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
805
806 fprintf (out, "%f\t", exec_ms_avg);
807 }
808
809 /**
810 * words_cur
811 */
812
813 u64 words_cur = get_lowest_words_done ();
814
815 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
816
817 /**
818 * counter
819 */
820
821 u64 progress_total = data.words_cnt * data.salts_cnt;
822
823 u64 all_done = 0;
824 u64 all_rejected = 0;
825 u64 all_restored = 0;
826
827 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
828 {
829 all_done += data.words_progress_done[salt_pos];
830 all_rejected += data.words_progress_rejected[salt_pos];
831 all_restored += data.words_progress_restored[salt_pos];
832 }
833
834 u64 progress_cur = all_restored + all_done + all_rejected;
835 u64 progress_end = progress_total;
836
837 u64 progress_skip = 0;
838
839 if (data.skip)
840 {
841 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
842
843 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
844 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
845 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
846 }
847
848 if (data.limit)
849 {
850 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
851
852 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
853 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
854 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
855 }
856
857 u64 progress_cur_relative_skip = progress_cur - progress_skip;
858 u64 progress_end_relative_skip = progress_end - progress_skip;
859
860 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
861
862 /**
863 * cracks
864 */
865
866 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
867 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
868
869 /**
870 * temperature
871 */
872
873 #ifdef HAVE_HWMON
874 if (data.gpu_temp_disable == 0)
875 {
876 fprintf (out, "TEMP\t");
877
878 hc_thread_mutex_lock (mux_adl);
879
880 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
881 {
882 hc_device_param_t *device_param = &data.devices_param[device_id];
883
884 if (device_param->skipped) continue;
885
886 int temp = hm_get_temperature_with_device_id (device_id);
887
888 fprintf (out, "%d\t", temp);
889 }
890
891 hc_thread_mutex_unlock (mux_adl);
892 }
893 #endif // HAVE_HWMON
894
895 /**
896 * flush
897 */
898
899 #ifdef _WIN
900 fputc ('\r', out);
901 fputc ('\n', out);
902 #endif
903
904 #ifdef _POSIX
905 fputc ('\n', out);
906 #endif
907
908 fflush (out);
909 }
910
911 void status_display ()
912 {
913 if (data.devices_status == STATUS_INIT) return;
914 if (data.devices_status == STATUS_STARTING) return;
915 if (data.devices_status == STATUS_BYPASS) return;
916
917 if (data.status_automate == 1)
918 {
919 status_display_automate ();
920
921 return;
922 }
923
924 char tmp_buf[1000] = { 0 };
925
926 uint tmp_len = 0;
927
928 log_info ("Session.Name...: %s", data.session);
929
930 char *status_type = strstatus (data.devices_status);
931
932 uint hash_mode = data.hash_mode;
933
934 char *hash_type = strhashtype (hash_mode); // not a bug
935
936 log_info ("Status.........: %s", status_type);
937
938 /**
939 * show rules
940 */
941
942 if (data.rp_files_cnt)
943 {
944 uint i;
945
946 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
947 {
948 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
949 }
950
951 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
952
953 log_info ("Rules.Type.....: %s", tmp_buf);
954
955 tmp_len = 0;
956 }
957
958 if (data.rp_gen)
959 {
960 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
961
962 if (data.rp_gen_seed)
963 {
964 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
965 }
966 }
967
968 /**
969 * show input
970 */
971
972 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
973 {
974 if (data.wordlist_mode == WL_MODE_FILE)
975 {
976 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
977 }
978 else if (data.wordlist_mode == WL_MODE_STDIN)
979 {
980 log_info ("Input.Mode.....: Pipe");
981 }
982 }
983 else if (data.attack_mode == ATTACK_MODE_COMBI)
984 {
985 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
986 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
987 }
988 else if (data.attack_mode == ATTACK_MODE_BF)
989 {
990 char *mask = data.mask;
991
992 if (mask != NULL)
993 {
994 uint mask_len = data.css_cnt;
995
996 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
997
998 if (mask_len > 0)
999 {
1000 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1001 {
1002 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1003 {
1004 mask_len -= data.salts_buf[0].salt_len;
1005 }
1006 }
1007
1008 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1009
1010 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1011 }
1012
1013 if (data.maskcnt > 1)
1014 {
1015 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1016
1017 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1018 }
1019
1020 log_info ("Input.Mode.....: %s", tmp_buf);
1021 }
1022
1023 tmp_len = 0;
1024 }
1025 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1026 {
1027 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1028 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1029 }
1030 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1031 {
1032 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1033 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1034 }
1035
1036 if (data.digests_cnt == 1)
1037 {
1038 if (data.hash_mode == 2500)
1039 {
1040 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1041
1042 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1043 (char *) data.salts_buf[0].salt_buf,
1044 wpa->orig_mac1[0],
1045 wpa->orig_mac1[1],
1046 wpa->orig_mac1[2],
1047 wpa->orig_mac1[3],
1048 wpa->orig_mac1[4],
1049 wpa->orig_mac1[5],
1050 wpa->orig_mac2[0],
1051 wpa->orig_mac2[1],
1052 wpa->orig_mac2[2],
1053 wpa->orig_mac2[3],
1054 wpa->orig_mac2[4],
1055 wpa->orig_mac2[5]);
1056 }
1057 else if (data.hash_mode == 5200)
1058 {
1059 log_info ("Hash.Target....: File (%s)", data.hashfile);
1060 }
1061 else if (data.hash_mode == 9000)
1062 {
1063 log_info ("Hash.Target....: File (%s)", data.hashfile);
1064 }
1065 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1066 {
1067 log_info ("Hash.Target....: File (%s)", data.hashfile);
1068 }
1069 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1070 {
1071 log_info ("Hash.Target....: File (%s)", data.hashfile);
1072 }
1073 else
1074 {
1075 char out_buf[HCBUFSIZ] = { 0 };
1076
1077 ascii_digest (out_buf, 0, 0);
1078
1079 // limit length
1080 if (strlen (out_buf) > 40)
1081 {
1082 out_buf[41] = '.';
1083 out_buf[42] = '.';
1084 out_buf[43] = '.';
1085 out_buf[44] = 0;
1086 }
1087
1088 log_info ("Hash.Target....: %s", out_buf);
1089 }
1090 }
1091 else
1092 {
1093 if (data.hash_mode == 3000)
1094 {
1095 char out_buf1[32] = { 0 };
1096 char out_buf2[32] = { 0 };
1097
1098 ascii_digest (out_buf1, 0, 0);
1099 ascii_digest (out_buf2, 0, 1);
1100
1101 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1102 }
1103 else
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 }
1108
1109 log_info ("Hash.Type......: %s", hash_type);
1110
1111 /**
1112 * speed new
1113 */
1114
1115 u64 speed_cnt[DEVICES_MAX] = { 0 };
1116 double speed_ms[DEVICES_MAX] = { 0 };
1117
1118 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1119 {
1120 hc_device_param_t *device_param = &data.devices_param[device_id];
1121
1122 if (device_param->skipped) continue;
1123
1124 speed_cnt[device_id] = 0;
1125 speed_ms[device_id] = 0;
1126
1127 for (int i = 0; i < SPEED_CACHE; i++)
1128 {
1129 speed_cnt[device_id] += device_param->speed_cnt[i];
1130 speed_ms[device_id] += device_param->speed_ms[i];
1131 }
1132
1133 speed_cnt[device_id] /= SPEED_CACHE;
1134 speed_ms[device_id] /= SPEED_CACHE;
1135 }
1136
1137 double hashes_all_ms = 0;
1138
1139 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1140
1141 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1142 {
1143 hc_device_param_t *device_param = &data.devices_param[device_id];
1144
1145 if (device_param->skipped) continue;
1146
1147 hashes_dev_ms[device_id] = 0;
1148
1149 if (speed_ms[device_id])
1150 {
1151 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1152
1153 hashes_all_ms += hashes_dev_ms[device_id];
1154 }
1155 }
1156
1157 /**
1158 * exec time
1159 */
1160
1161 double exec_all_ms[DEVICES_MAX] = { 0 };
1162
1163 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1164 {
1165 hc_device_param_t *device_param = &data.devices_param[device_id];
1166
1167 if (device_param->skipped) continue;
1168
1169 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1170
1171 exec_all_ms[device_id] = exec_ms_avg;
1172 }
1173
1174 /**
1175 * timers
1176 */
1177
1178 double ms_running = 0;
1179
1180 hc_timer_get (data.timer_running, ms_running);
1181
1182 double ms_paused = data.ms_paused;
1183
1184 if (data.devices_status == STATUS_PAUSED)
1185 {
1186 double ms_paused_tmp = 0;
1187
1188 hc_timer_get (data.timer_paused, ms_paused_tmp);
1189
1190 ms_paused += ms_paused_tmp;
1191 }
1192
1193 #ifdef WIN
1194
1195 __time64_t sec_run = ms_running / 1000;
1196
1197 #else
1198
1199 time_t sec_run = ms_running / 1000;
1200
1201 #endif
1202
1203 if (sec_run)
1204 {
1205 char display_run[32] = { 0 };
1206
1207 struct tm tm_run;
1208
1209 struct tm *tmp = NULL;
1210
1211 #ifdef WIN
1212
1213 tmp = _gmtime64 (&sec_run);
1214
1215 #else
1216
1217 tmp = gmtime (&sec_run);
1218
1219 #endif
1220
1221 if (tmp != NULL)
1222 {
1223 memset (&tm_run, 0, sizeof (tm_run));
1224
1225 memcpy (&tm_run, tmp, sizeof (tm_run));
1226
1227 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1228
1229 char *start = ctime (&data.proc_start);
1230
1231 size_t start_len = strlen (start);
1232
1233 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1234 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1235
1236 log_info ("Time.Started...: %s (%s)", start, display_run);
1237 }
1238 }
1239 else
1240 {
1241 log_info ("Time.Started...: 0 secs");
1242 }
1243
1244 /**
1245 * counters
1246 */
1247
1248 u64 progress_total = data.words_cnt * data.salts_cnt;
1249
1250 u64 all_done = 0;
1251 u64 all_rejected = 0;
1252 u64 all_restored = 0;
1253
1254 u64 progress_noneed = 0;
1255
1256 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1257 {
1258 all_done += data.words_progress_done[salt_pos];
1259 all_rejected += data.words_progress_rejected[salt_pos];
1260 all_restored += data.words_progress_restored[salt_pos];
1261
1262 // Important for ETA only
1263
1264 if (data.salts_shown[salt_pos] == 1)
1265 {
1266 const u64 all = data.words_progress_done[salt_pos]
1267 + data.words_progress_rejected[salt_pos]
1268 + data.words_progress_restored[salt_pos];
1269
1270 const u64 left = data.words_cnt - all;
1271
1272 progress_noneed += left;
1273 }
1274 }
1275
1276 u64 progress_cur = all_restored + all_done + all_rejected;
1277 u64 progress_end = progress_total;
1278
1279 u64 progress_skip = 0;
1280
1281 if (data.skip)
1282 {
1283 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1284
1285 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1286 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1287 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1288 }
1289
1290 if (data.limit)
1291 {
1292 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1293
1294 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1295 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1296 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1297 }
1298
1299 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1300 u64 progress_end_relative_skip = progress_end - progress_skip;
1301
1302 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1303 {
1304 if (data.devices_status != STATUS_CRACKED)
1305 {
1306 #ifdef WIN
1307 __time64_t sec_etc = 0;
1308 #else
1309 time_t sec_etc = 0;
1310 #endif
1311
1312 if (hashes_all_ms)
1313 {
1314 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1315
1316 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1317
1318 sec_etc = ms_left / 1000;
1319 }
1320
1321 if (sec_etc == 0)
1322 {
1323 //log_info ("Time.Estimated.: 0 secs");
1324 }
1325 else if ((u64) sec_etc > ETC_MAX)
1326 {
1327 log_info ("Time.Estimated.: > 10 Years");
1328 }
1329 else
1330 {
1331 char display_etc[32] = { 0 };
1332
1333 struct tm tm_etc;
1334
1335 struct tm *tmp = NULL;
1336
1337 #ifdef WIN
1338
1339 tmp = _gmtime64 (&sec_etc);
1340
1341 #else
1342
1343 tmp = gmtime (&sec_etc);
1344
1345 #endif
1346
1347 if (tmp != NULL)
1348 {
1349 memset (&tm_etc, 0, sizeof (tm_etc));
1350
1351 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1352
1353 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1354
1355 time_t now;
1356
1357 time (&now);
1358
1359 now += sec_etc;
1360
1361 char *etc = ctime (&now);
1362
1363 size_t etc_len = strlen (etc);
1364
1365 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1366 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1367
1368 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1369 }
1370 }
1371 }
1372 }
1373
1374 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1375 {
1376 hc_device_param_t *device_param = &data.devices_param[device_id];
1377
1378 if (device_param->skipped) continue;
1379
1380 char display_dev_cur[16] = { 0 };
1381
1382 strncpy (display_dev_cur, "0.00", 4);
1383
1384 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1385
1386 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1387 }
1388
1389 char display_all_cur[16] = { 0 };
1390
1391 strncpy (display_all_cur, "0.00", 4);
1392
1393 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1394
1395 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1396
1397 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1398 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1399
1400 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);
1401
1402 // crack-per-time
1403
1404 if (data.digests_cnt > 100)
1405 {
1406 time_t now = time (NULL);
1407
1408 int cpt_cur_min = 0;
1409 int cpt_cur_hour = 0;
1410 int cpt_cur_day = 0;
1411
1412 for (int i = 0; i < CPT_BUF; i++)
1413 {
1414 const uint cracked = data.cpt_buf[i].cracked;
1415 const time_t timestamp = data.cpt_buf[i].timestamp;
1416
1417 if ((timestamp + 60) > now)
1418 {
1419 cpt_cur_min += cracked;
1420 }
1421
1422 if ((timestamp + 3600) > now)
1423 {
1424 cpt_cur_hour += cracked;
1425 }
1426
1427 if ((timestamp + 86400) > now)
1428 {
1429 cpt_cur_day += cracked;
1430 }
1431 }
1432
1433 double ms_real = ms_running - ms_paused;
1434
1435 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1436 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1437 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1438
1439 if ((data.cpt_start + 86400) < now)
1440 {
1441 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1442 cpt_cur_min,
1443 cpt_cur_hour,
1444 cpt_cur_day,
1445 cpt_avg_min,
1446 cpt_avg_hour,
1447 cpt_avg_day);
1448 }
1449 else if ((data.cpt_start + 3600) < now)
1450 {
1451 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1452 cpt_cur_min,
1453 cpt_cur_hour,
1454 cpt_avg_min,
1455 cpt_avg_hour,
1456 cpt_avg_day);
1457 }
1458 else if ((data.cpt_start + 60) < now)
1459 {
1460 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1461 cpt_cur_min,
1462 cpt_avg_min,
1463 cpt_avg_hour,
1464 cpt_avg_day);
1465 }
1466 else
1467 {
1468 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1469 cpt_avg_min,
1470 cpt_avg_hour,
1471 cpt_avg_day);
1472 }
1473 }
1474
1475 // Restore point
1476
1477 u64 restore_point = get_lowest_words_done ();
1478
1479 u64 restore_total = data.words_base;
1480
1481 float percent_restore = 0;
1482
1483 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1484
1485 if (progress_end_relative_skip)
1486 {
1487 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1488 {
1489 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1490 float percent_rejected = 0.0;
1491
1492 if (progress_cur)
1493 {
1494 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1495 }
1496
1497 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);
1498 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1499
1500 if (data.restore_disable == 0)
1501 {
1502 if (percent_finished != 1)
1503 {
1504 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1505 }
1506 }
1507 }
1508 }
1509 else
1510 {
1511 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1512 {
1513 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1514 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1515
1516 if (data.restore_disable == 0)
1517 {
1518 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1519 }
1520 }
1521 else
1522 {
1523 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1524 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1525
1526 // --restore not allowed if stdin is used -- really? why?
1527
1528 //if (data.restore_disable == 0)
1529 //{
1530 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1531 //}
1532 }
1533 }
1534
1535 #ifdef HAVE_HWMON
1536 if (data.gpu_temp_disable == 0)
1537 {
1538 hc_thread_mutex_lock (mux_adl);
1539
1540 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1541 {
1542 hc_device_param_t *device_param = &data.devices_param[device_id];
1543
1544 if (device_param->skipped) continue;
1545
1546 #define HM_STR_BUF_SIZE 255
1547
1548 if (data.hm_device[device_id].fan_supported == 1)
1549 {
1550 char utilization[HM_STR_BUF_SIZE] = { 0 };
1551 char temperature[HM_STR_BUF_SIZE] = { 0 };
1552 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1553
1554 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1555 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1556
1557 if (device_param->vendor_id == VENDOR_ID_AMD)
1558 {
1559 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1560 }
1561 else if (device_param->vendor_id == VENDOR_ID_NV)
1562 {
1563 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1564 }
1565
1566 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1567 }
1568 else
1569 {
1570 char utilization[HM_STR_BUF_SIZE] = { 0 };
1571 char temperature[HM_STR_BUF_SIZE] = { 0 };
1572
1573 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1574 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1575
1576 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1577 }
1578 }
1579
1580 hc_thread_mutex_unlock (mux_adl);
1581 }
1582 #endif // HAVE_HWMON
1583 }
1584
1585 static void status_benchmark_automate ()
1586 {
1587 u64 speed_cnt[DEVICES_MAX] = { 0 };
1588 double speed_ms[DEVICES_MAX] = { 0 };
1589
1590 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1591 {
1592 hc_device_param_t *device_param = &data.devices_param[device_id];
1593
1594 if (device_param->skipped) continue;
1595
1596 speed_cnt[device_id] = device_param->speed_cnt[0];
1597 speed_ms[device_id] = device_param->speed_ms[0];
1598 }
1599
1600 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1601
1602 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1603 {
1604 hc_device_param_t *device_param = &data.devices_param[device_id];
1605
1606 if (device_param->skipped) continue;
1607
1608 hashes_dev_ms[device_id] = 0;
1609
1610 if (speed_ms[device_id])
1611 {
1612 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1613 }
1614 }
1615
1616 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1617 {
1618 hc_device_param_t *device_param = &data.devices_param[device_id];
1619
1620 if (device_param->skipped) continue;
1621
1622 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1623 }
1624 }
1625
1626 static void status_benchmark ()
1627 {
1628 if (data.devices_status == STATUS_INIT) return;
1629 if (data.devices_status == STATUS_STARTING) return;
1630 if (data.devices_status == STATUS_BYPASS) return;
1631
1632 if (data.status_automate == 1)
1633 {
1634 status_benchmark_automate ();
1635
1636 return;
1637 }
1638
1639 u64 speed_cnt[DEVICES_MAX] = { 0 };
1640 double speed_ms[DEVICES_MAX] = { 0 };
1641
1642 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1643 {
1644 hc_device_param_t *device_param = &data.devices_param[device_id];
1645
1646 if (device_param->skipped) continue;
1647
1648 speed_cnt[device_id] = device_param->speed_cnt[0];
1649 speed_ms[device_id] = device_param->speed_ms[0];
1650 }
1651
1652 double hashes_all_ms = 0;
1653
1654 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1655
1656 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1657 {
1658 hc_device_param_t *device_param = &data.devices_param[device_id];
1659
1660 if (device_param->skipped) continue;
1661
1662 hashes_dev_ms[device_id] = 0;
1663
1664 if (speed_ms[device_id])
1665 {
1666 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1667
1668 hashes_all_ms += hashes_dev_ms[device_id];
1669 }
1670 }
1671
1672 /**
1673 * exec time
1674 */
1675
1676 double exec_all_ms[DEVICES_MAX] = { 0 };
1677
1678 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1679 {
1680 hc_device_param_t *device_param = &data.devices_param[device_id];
1681
1682 if (device_param->skipped) continue;
1683
1684 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1685
1686 exec_all_ms[device_id] = exec_ms_avg;
1687 }
1688
1689 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1690 {
1691 hc_device_param_t *device_param = &data.devices_param[device_id];
1692
1693 if (device_param->skipped) continue;
1694
1695 char display_dev_cur[16] = { 0 };
1696
1697 strncpy (display_dev_cur, "0.00", 4);
1698
1699 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1700
1701 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1702 }
1703
1704 char display_all_cur[16] = { 0 };
1705
1706 strncpy (display_all_cur, "0.00", 4);
1707
1708 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1709
1710 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1711 }
1712
1713 /**
1714 * hashcat -only- functions
1715 */
1716
1717 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1718 {
1719 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1720 {
1721 if (attack_kern == ATTACK_KERN_STRAIGHT)
1722 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1723 else if (attack_kern == ATTACK_KERN_COMBI)
1724 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1725 else if (attack_kern == ATTACK_KERN_BF)
1726 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1727 }
1728 else
1729 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1730 }
1731
1732 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)
1733 {
1734 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1735 {
1736 if (attack_kern == ATTACK_KERN_STRAIGHT)
1737 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1738 else if (attack_kern == ATTACK_KERN_COMBI)
1739 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1740 else if (attack_kern == ATTACK_KERN_BF)
1741 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1742 }
1743 else
1744 {
1745 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1746 }
1747 }
1748
1749 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1750 {
1751 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1752 {
1753 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1754 }
1755 else
1756 {
1757 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1758 }
1759 }
1760
1761 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)
1762 {
1763 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1764 {
1765 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1766 }
1767 else
1768 {
1769 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1770 }
1771 }
1772
1773 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1774 {
1775 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1776 }
1777
1778 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1779 {
1780 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1781 }
1782
1783 static uint convert_from_hex (char *line_buf, const uint line_len)
1784 {
1785 if (line_len & 1) return (line_len); // not in hex
1786
1787 if (data.hex_wordlist == 1)
1788 {
1789 uint i;
1790 uint j;
1791
1792 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1793 {
1794 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1795 }
1796
1797 memset (line_buf + i, 0, line_len - i);
1798
1799 return (i);
1800 }
1801 else if (line_len >= 6) // $HEX[] = 6
1802 {
1803 if (line_buf[0] != '$') return (line_len);
1804 if (line_buf[1] != 'H') return (line_len);
1805 if (line_buf[2] != 'E') return (line_len);
1806 if (line_buf[3] != 'X') return (line_len);
1807 if (line_buf[4] != '[') return (line_len);
1808 if (line_buf[line_len - 1] != ']') return (line_len);
1809
1810 uint i;
1811 uint j;
1812
1813 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1814 {
1815 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1816 }
1817
1818 memset (line_buf + i, 0, line_len - i);
1819
1820 return (i);
1821 }
1822
1823 return (line_len);
1824 }
1825
1826 static void clear_prompt ()
1827 {
1828 fputc ('\r', stdout);
1829
1830 for (size_t i = 0; i < strlen (PROMPT); i++)
1831 {
1832 fputc (' ', stdout);
1833 }
1834
1835 fputc ('\r', stdout);
1836
1837 fflush (stdout);
1838 }
1839
1840 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1841 {
1842 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);
1843 }
1844
1845 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1846 {
1847 char *outfile = data.outfile;
1848 uint quiet = data.quiet;
1849 FILE *pot_fp = data.pot_fp;
1850 uint loopback = data.loopback;
1851 uint debug_mode = data.debug_mode;
1852 char *debug_file = data.debug_file;
1853
1854 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1855 int debug_rule_len = 0; // -1 error
1856 uint debug_plain_len = 0;
1857
1858 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1859
1860 // hash
1861
1862 char out_buf[HCBUFSIZ] = { 0 };
1863
1864 const u32 salt_pos = plain->salt_pos;
1865 const u32 digest_pos = plain->digest_pos; // relative
1866 const u32 gidvid = plain->gidvid;
1867 const u32 il_pos = plain->il_pos;
1868
1869 ascii_digest (out_buf, salt_pos, digest_pos);
1870
1871 // plain
1872
1873 u64 crackpos = device_param->words_off;
1874
1875 uint plain_buf[16] = { 0 };
1876
1877 u8 *plain_ptr = (u8 *) plain_buf;
1878
1879 unsigned int plain_len = 0;
1880
1881 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1882 {
1883 pw_t pw;
1884
1885 gidd_to_pw_t (device_param, gidvid, &pw);
1886
1887 for (int i = 0; i < 16; i++)
1888 {
1889 plain_buf[i] = pw.i[i];
1890 }
1891
1892 plain_len = pw.pw_len;
1893
1894 const uint off = device_param->innerloop_pos + il_pos;
1895
1896 if (debug_mode > 0)
1897 {
1898 debug_rule_len = 0;
1899
1900 // save rule
1901 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1902 {
1903 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1904
1905 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1906 }
1907
1908 // save plain
1909 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1910 {
1911 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1912
1913 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1914
1915 debug_plain_len = plain_len;
1916 }
1917 }
1918
1919 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1920
1921 crackpos += gidvid;
1922 crackpos *= data.kernel_rules_cnt;
1923 crackpos += device_param->innerloop_pos + il_pos;
1924
1925 if (plain_len > data.pw_max) plain_len = data.pw_max;
1926 }
1927 else if (data.attack_mode == ATTACK_MODE_COMBI)
1928 {
1929 pw_t pw;
1930
1931 gidd_to_pw_t (device_param, gidvid, &pw);
1932
1933 for (int i = 0; i < 16; i++)
1934 {
1935 plain_buf[i] = pw.i[i];
1936 }
1937
1938 plain_len = pw.pw_len;
1939
1940 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1941 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1942
1943 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1944 {
1945 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1946 }
1947 else
1948 {
1949 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1950
1951 memcpy (plain_ptr, comb_buf, comb_len);
1952 }
1953
1954 plain_len += comb_len;
1955
1956 crackpos += gidvid;
1957 crackpos *= data.combs_cnt;
1958 crackpos += device_param->innerloop_pos + il_pos;
1959
1960 if (data.pw_max != PW_DICTMAX1)
1961 {
1962 if (plain_len > data.pw_max) plain_len = data.pw_max;
1963 }
1964 }
1965 else if (data.attack_mode == ATTACK_MODE_BF)
1966 {
1967 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1968 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1969
1970 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1971 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1972
1973 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1974 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1975
1976 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1977 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1978
1979 plain_len = data.css_cnt;
1980
1981 crackpos += gidvid;
1982 crackpos *= data.bfs_cnt;
1983 crackpos += device_param->innerloop_pos + il_pos;
1984 }
1985 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1986 {
1987 pw_t pw;
1988
1989 gidd_to_pw_t (device_param, gidvid, &pw);
1990
1991 for (int i = 0; i < 16; i++)
1992 {
1993 plain_buf[i] = pw.i[i];
1994 }
1995
1996 plain_len = pw.pw_len;
1997
1998 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1999
2000 uint start = 0;
2001 uint stop = device_param->kernel_params_mp_buf32[4];
2002
2003 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2004
2005 plain_len += start + stop;
2006
2007 crackpos += gidvid;
2008 crackpos *= data.combs_cnt;
2009 crackpos += device_param->innerloop_pos + il_pos;
2010
2011 if (data.pw_max != PW_DICTMAX1)
2012 {
2013 if (plain_len > data.pw_max) plain_len = data.pw_max;
2014 }
2015 }
2016 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2017 {
2018 pw_t pw;
2019
2020 gidd_to_pw_t (device_param, gidvid, &pw);
2021
2022 for (int i = 0; i < 16; i++)
2023 {
2024 plain_buf[i] = pw.i[i];
2025 }
2026
2027 plain_len = pw.pw_len;
2028
2029 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2030
2031 uint start = 0;
2032 uint stop = device_param->kernel_params_mp_buf32[4];
2033
2034 memmove (plain_ptr + stop, plain_ptr, plain_len);
2035
2036 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2037
2038 plain_len += start + stop;
2039
2040 crackpos += gidvid;
2041 crackpos *= data.combs_cnt;
2042 crackpos += device_param->innerloop_pos + il_pos;
2043
2044 if (data.pw_max != PW_DICTMAX1)
2045 {
2046 if (plain_len > data.pw_max) plain_len = data.pw_max;
2047 }
2048 }
2049
2050 if (data.attack_mode == ATTACK_MODE_BF)
2051 {
2052 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2053 {
2054 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2055 {
2056 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2057 {
2058 plain_len = plain_len - data.salts_buf[0].salt_len;
2059 }
2060 }
2061
2062 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2063 {
2064 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2065 {
2066 plain_ptr[j] = plain_ptr[i];
2067 }
2068
2069 plain_len = plain_len / 2;
2070 }
2071 }
2072 }
2073
2074 // if enabled, update also the potfile
2075
2076 if (pot_fp)
2077 {
2078 lock_file (pot_fp);
2079
2080 fprintf (pot_fp, "%s:", out_buf);
2081
2082 format_plain (pot_fp, plain_ptr, plain_len, 1);
2083
2084 fputc ('\n', pot_fp);
2085
2086 fflush (pot_fp);
2087
2088 unlock_file (pot_fp);
2089 }
2090
2091 // outfile
2092
2093 FILE *out_fp = NULL;
2094
2095 if (outfile != NULL)
2096 {
2097 if ((out_fp = fopen (outfile, "ab")) == NULL)
2098 {
2099 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2100
2101 out_fp = stdout;
2102 }
2103 lock_file (out_fp);
2104 }
2105 else
2106 {
2107 out_fp = stdout;
2108
2109 if (quiet == 0) clear_prompt ();
2110 }
2111
2112 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2113
2114 if (outfile != NULL)
2115 {
2116 if (out_fp != stdout)
2117 {
2118 fclose (out_fp);
2119 }
2120 }
2121 else
2122 {
2123 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2124 {
2125 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2126 {
2127 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2128 if (quiet == 0) fflush (stdout);
2129 }
2130 }
2131 }
2132
2133 // loopback
2134
2135 if (loopback)
2136 {
2137 char *loopback_file = data.loopback_file;
2138
2139 FILE *fb_fp = NULL;
2140
2141 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2142 {
2143 lock_file (fb_fp);
2144
2145 format_plain (fb_fp, plain_ptr, plain_len, 1);
2146
2147 fputc ('\n', fb_fp);
2148
2149 fclose (fb_fp);
2150 }
2151 }
2152
2153 // (rule) debug mode
2154
2155 // the next check implies that:
2156 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2157 // - debug_mode > 0
2158
2159 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2160 {
2161 if (debug_rule_len < 0) debug_rule_len = 0;
2162
2163 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2164
2165 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2166
2167 if ((quiet == 0) && (debug_file == NULL))
2168 {
2169 fprintf (stdout, "%s", PROMPT);
2170
2171 fflush (stdout);
2172 }
2173 }
2174 }
2175
2176 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2177 {
2178 salt_t *salt_buf = &data.salts_buf[salt_pos];
2179
2180 u32 num_cracked;
2181
2182 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2183
2184 if (num_cracked)
2185 {
2186 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2187
2188 log_info_nn ("");
2189
2190 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2191
2192 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);
2193
2194 uint cpt_cracked = 0;
2195
2196 for (uint i = 0; i < num_cracked; i++)
2197 {
2198 const uint hash_pos = cracked[i].hash_pos;
2199
2200 if (data.digests_shown[hash_pos] == 1) continue;
2201
2202 hc_thread_mutex_lock (mux_display);
2203
2204 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2205 {
2206 data.digests_shown[hash_pos] = 1;
2207
2208 data.digests_done++;
2209
2210 cpt_cracked++;
2211
2212 salt_buf->digests_done++;
2213
2214 if (salt_buf->digests_done == salt_buf->digests_cnt)
2215 {
2216 data.salts_shown[salt_pos] = 1;
2217
2218 data.salts_done++;
2219 }
2220 }
2221
2222 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2223
2224 hc_thread_mutex_unlock (mux_display);
2225
2226 check_hash (device_param, &cracked[i]);
2227 }
2228
2229 myfree (cracked);
2230
2231 if (cpt_cracked > 0)
2232 {
2233 hc_thread_mutex_lock (mux_display);
2234
2235 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2236 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2237
2238 data.cpt_pos++;
2239
2240 data.cpt_total += cpt_cracked;
2241
2242 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2243
2244 hc_thread_mutex_unlock (mux_display);
2245 }
2246
2247 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2248 {
2249 // we need to reset cracked state on the device
2250 // otherwise host thinks again and again the hash was cracked
2251 // and returns invalid password each time
2252
2253 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2254
2255 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);
2256 }
2257
2258 num_cracked = 0;
2259
2260 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2261 }
2262 }
2263
2264 static void save_hash ()
2265 {
2266 char *hashfile = data.hashfile;
2267
2268 char new_hashfile[256] = { 0 };
2269 char old_hashfile[256] = { 0 };
2270
2271 snprintf (new_hashfile, 255, "%s.new", hashfile);
2272 snprintf (old_hashfile, 255, "%s.old", hashfile);
2273
2274 unlink (new_hashfile);
2275
2276 char separator = data.separator;
2277
2278 FILE *fp = fopen (new_hashfile, "wb");
2279
2280 if (fp == NULL)
2281 {
2282 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2283
2284 exit (-1);
2285 }
2286
2287 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2288 {
2289 if (data.salts_shown[salt_pos] == 1) continue;
2290
2291 salt_t *salt_buf = &data.salts_buf[salt_pos];
2292
2293 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2294 {
2295 uint idx = salt_buf->digests_offset + digest_pos;
2296
2297 if (data.digests_shown[idx] == 1) continue;
2298
2299 if (data.hash_mode != 2500)
2300 {
2301 char out_buf[HCBUFSIZ] = { 0 };
2302
2303 if (data.username == 1)
2304 {
2305 user_t *user = data.hash_info[idx]->user;
2306
2307 uint i;
2308
2309 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2310
2311 fputc (separator, fp);
2312 }
2313
2314 ascii_digest (out_buf, salt_pos, digest_pos);
2315
2316 fputs (out_buf, fp);
2317
2318 log_out (fp, "");
2319 }
2320 else
2321 {
2322 hccap_t hccap;
2323
2324 to_hccap_t (&hccap, salt_pos, digest_pos);
2325
2326 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2327 }
2328 }
2329 }
2330
2331 fflush (fp);
2332
2333 fclose (fp);
2334
2335 unlink (old_hashfile);
2336
2337 if (rename (hashfile, old_hashfile) != 0)
2338 {
2339 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2340
2341 exit (-1);
2342 }
2343
2344 unlink (hashfile);
2345
2346 if (rename (new_hashfile, hashfile) != 0)
2347 {
2348 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2349
2350 exit (-1);
2351 }
2352
2353 unlink (old_hashfile);
2354 }
2355
2356 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2357 {
2358 // function called only in case kernel_power_all > words_left
2359
2360 float kernel_power_div = (float) (total_left) / kernel_power_all;
2361
2362 kernel_power_div += kernel_power_div / 100;
2363
2364 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2365
2366 while (kernel_power_new < total_left)
2367 {
2368 kernel_power_div += kernel_power_div / 100;
2369
2370 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2371 }
2372
2373 if (data.quiet == 0)
2374 {
2375 clear_prompt ();
2376
2377 //log_info ("");
2378
2379 log_info ("INFO: approaching final keyspace, workload adjusted");
2380 log_info ("");
2381
2382 fprintf (stdout, "%s", PROMPT);
2383
2384 fflush (stdout);
2385 }
2386
2387 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2388
2389 return kernel_power_div;
2390 }
2391
2392 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2393 {
2394 uint num_elements = num;
2395
2396 device_param->kernel_params_buf32[30] = data.combs_mode;
2397 device_param->kernel_params_buf32[31] = num;
2398
2399 uint kernel_threads = device_param->kernel_threads;
2400
2401 while (num_elements % kernel_threads) num_elements++;
2402
2403 cl_kernel kernel = NULL;
2404
2405 switch (kern_run)
2406 {
2407 case KERN_RUN_1: kernel = device_param->kernel1; break;
2408 case KERN_RUN_12: kernel = device_param->kernel12; break;
2409 case KERN_RUN_2: kernel = device_param->kernel2; break;
2410 case KERN_RUN_23: kernel = device_param->kernel23; break;
2411 case KERN_RUN_3: kernel = device_param->kernel3; break;
2412 }
2413
2414 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2415 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2416 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2417 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2418 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2419 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2420 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2421 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2422 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2423 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2424 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2425
2426 cl_event event;
2427
2428 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2429 {
2430 const size_t global_work_size[3] = { num_elements, 32, 1 };
2431 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2432
2433 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2434 }
2435 else
2436 {
2437 if (kern_run == KERN_RUN_2)
2438 {
2439 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2440 {
2441 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2442 }
2443 }
2444
2445 while (num_elements % kernel_threads) num_elements++;
2446
2447 const size_t global_work_size[3] = { num_elements, 1, 1 };
2448 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2449
2450 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2451 }
2452
2453 hc_clFlush (data.ocl, device_param->command_queue);
2454
2455 hc_clWaitForEvents (data.ocl, 1, &event);
2456
2457 if (event_update)
2458 {
2459 cl_ulong time_start;
2460 cl_ulong time_end;
2461
2462 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2463 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2464
2465 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2466
2467 uint exec_pos = device_param->exec_pos;
2468
2469 device_param->exec_ms[exec_pos] = exec_time;
2470
2471 exec_pos++;
2472
2473 if (exec_pos == EXEC_CACHE)
2474 {
2475 exec_pos = 0;
2476 }
2477
2478 device_param->exec_pos = exec_pos;
2479 }
2480
2481 hc_clReleaseEvent (data.ocl, event);
2482
2483 hc_clFinish (data.ocl, device_param->command_queue);
2484 }
2485
2486 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2487 {
2488 uint num_elements = num;
2489
2490 switch (kern_run)
2491 {
2492 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2493 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2494 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2495 }
2496
2497 // causes problems with special threads like in bcrypt
2498 // const uint kernel_threads = device_param->kernel_threads;
2499
2500 uint kernel_threads = device_param->kernel_threads;
2501
2502 while (num_elements % kernel_threads) num_elements++;
2503
2504 cl_kernel kernel = NULL;
2505
2506 switch (kern_run)
2507 {
2508 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2509 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2510 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2511 }
2512
2513 switch (kern_run)
2514 {
2515 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2516 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2517 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2518 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2519 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2520 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2521 break;
2522 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2523 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2524 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2525 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2526 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2527 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2528 break;
2529 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2530 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2531 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2532 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2533 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2534 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2535 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2536 break;
2537 }
2538
2539 const size_t global_work_size[3] = { num_elements, 1, 1 };
2540 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2541
2542 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2543
2544 hc_clFlush (data.ocl, device_param->command_queue);
2545
2546 hc_clFinish (data.ocl, device_param->command_queue);
2547 }
2548
2549 static void run_kernel_tm (hc_device_param_t *device_param)
2550 {
2551 const uint num_elements = 1024; // fixed
2552
2553 uint kernel_threads = 32;
2554
2555 cl_kernel kernel = device_param->kernel_tm;
2556
2557 const size_t global_work_size[3] = { num_elements, 1, 1 };
2558 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2559
2560 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2561
2562 hc_clFlush (data.ocl, device_param->command_queue);
2563
2564 hc_clFinish (data.ocl, device_param->command_queue);
2565 }
2566
2567 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2568 {
2569 uint num_elements = num;
2570
2571 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2572 device_param->kernel_params_amp_buf32[6] = num_elements;
2573
2574 // causes problems with special threads like in bcrypt
2575 // const uint kernel_threads = device_param->kernel_threads;
2576
2577 uint kernel_threads = device_param->kernel_threads;
2578
2579 while (num_elements % kernel_threads) num_elements++;
2580
2581 cl_kernel kernel = device_param->kernel_amp;
2582
2583 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2584 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2585
2586 const size_t global_work_size[3] = { num_elements, 1, 1 };
2587 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2588
2589 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2590
2591 hc_clFlush (data.ocl, device_param->command_queue);
2592
2593 hc_clFinish (data.ocl, device_param->command_queue);
2594 }
2595
2596 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2597 {
2598 int rc = -1;
2599
2600 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2601 {
2602 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2603
2604 const cl_uchar zero = 0;
2605
2606 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2607 }
2608
2609 if (rc != 0)
2610 {
2611 // NOTE: clEnqueueFillBuffer () always fails with -59
2612 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2613 // How's that possible, OpenCL 1.2 support is advertised??
2614 // We need to workaround...
2615
2616 #define FILLSZ 0x100000
2617
2618 char *tmp = (char *) mymalloc (FILLSZ);
2619
2620 for (size_t i = 0; i < size; i += FILLSZ)
2621 {
2622 const size_t left = size - i;
2623
2624 const size_t fillsz = MIN (FILLSZ, left);
2625
2626 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2627 }
2628
2629 myfree (tmp);
2630 }
2631 }
2632
2633 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)
2634 {
2635 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2636 {
2637 if (attack_mode == ATTACK_MODE_BF)
2638 {
2639 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2640 {
2641 const uint size_tm = 32 * sizeof (bs_word_t);
2642
2643 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2644
2645 run_kernel_tm (device_param);
2646
2647 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);
2648 }
2649 }
2650
2651 if (highest_pw_len < 16)
2652 {
2653 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2654 }
2655 else if (highest_pw_len < 32)
2656 {
2657 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2658 }
2659 else
2660 {
2661 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2662 }
2663 }
2664 else
2665 {
2666 run_kernel_amp (device_param, pws_cnt);
2667
2668 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2669
2670 if (opts_type & OPTS_TYPE_HOOK12)
2671 {
2672 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2673 }
2674
2675 uint iter = salt_buf->salt_iter;
2676
2677 uint loop_step = device_param->kernel_loops;
2678
2679 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2680 {
2681 uint loop_left = iter - loop_pos;
2682
2683 loop_left = MIN (loop_left, loop_step);
2684
2685 device_param->kernel_params_buf32[25] = loop_pos;
2686 device_param->kernel_params_buf32[26] = loop_left;
2687
2688 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2689
2690 if (data.devices_status == STATUS_CRACKED) break;
2691 if (data.devices_status == STATUS_ABORTED) break;
2692 if (data.devices_status == STATUS_QUIT) break;
2693
2694 /**
2695 * speed
2696 */
2697
2698 const float iter_part = (float) (loop_pos + loop_left) / iter;
2699
2700 const u64 perf_sum_all = pws_cnt * iter_part;
2701
2702 double speed_ms;
2703
2704 hc_timer_get (device_param->timer_speed, speed_ms);
2705
2706 const u32 speed_pos = device_param->speed_pos;
2707
2708 device_param->speed_cnt[speed_pos] = perf_sum_all;
2709
2710 device_param->speed_ms[speed_pos] = speed_ms;
2711
2712 if (data.benchmark == 1)
2713 {
2714 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2715 }
2716 }
2717
2718 if (opts_type & OPTS_TYPE_HOOK23)
2719 {
2720 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2721
2722 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);
2723
2724 // do something with data
2725
2726 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);
2727 }
2728
2729 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2730 }
2731 }
2732
2733 static int run_rule_engine (const int rule_len, const char *rule_buf)
2734 {
2735 if (rule_len == 0)
2736 {
2737 return 0;
2738 }
2739 else if (rule_len == 1)
2740 {
2741 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2742 }
2743
2744 return 1;
2745 }
2746
2747 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2748 {
2749 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2750 {
2751 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);
2752 }
2753 else if (data.attack_kern == ATTACK_KERN_COMBI)
2754 {
2755 if (data.attack_mode == ATTACK_MODE_COMBI)
2756 {
2757 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2758 {
2759 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2760 {
2761 for (u32 i = 0; i < pws_cnt; i++)
2762 {
2763 const u32 pw_len = device_param->pws_buf[i].pw_len;
2764
2765 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2766
2767 ptr[pw_len] = 0x01;
2768 }
2769 }
2770 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2771 {
2772 for (u32 i = 0; i < pws_cnt; i++)
2773 {
2774 const u32 pw_len = device_param->pws_buf[i].pw_len;
2775
2776 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2777
2778 ptr[pw_len] = 0x80;
2779 }
2780 }
2781 }
2782 }
2783 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2784 {
2785 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2786 {
2787 for (u32 i = 0; i < pws_cnt; i++)
2788 {
2789 const u32 pw_len = device_param->pws_buf[i].pw_len;
2790
2791 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2792
2793 ptr[pw_len] = 0x01;
2794 }
2795 }
2796 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2797 {
2798 for (u32 i = 0; i < pws_cnt; i++)
2799 {
2800 const u32 pw_len = device_param->pws_buf[i].pw_len;
2801
2802 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2803
2804 ptr[pw_len] = 0x80;
2805 }
2806 }
2807 }
2808
2809 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);
2810 }
2811 else if (data.attack_kern == ATTACK_KERN_BF)
2812 {
2813 const u64 off = device_param->words_off;
2814
2815 device_param->kernel_params_mp_l_buf64[3] = off;
2816
2817 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2818 }
2819 }
2820
2821 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2822 {
2823 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2824
2825 device_param->kernel_params_buf32[25] = 0;
2826 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2827 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2828
2829 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2830 {
2831 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2832 }
2833 else
2834 {
2835 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2836 }
2837
2838 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2839
2840 return exec_ms_prev;
2841 }
2842
2843 static void autotune (hc_device_param_t *device_param)
2844 {
2845 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2846
2847 const u32 kernel_accel_min = device_param->kernel_accel_min;
2848 const u32 kernel_accel_max = device_param->kernel_accel_max;
2849
2850 const u32 kernel_loops_min = device_param->kernel_loops_min;
2851 const u32 kernel_loops_max = device_param->kernel_loops_max;
2852
2853 u32 kernel_accel = kernel_accel_min;
2854 u32 kernel_loops = kernel_loops_min;
2855
2856 // in this case the user specified a fixed -u and -n on the commandline
2857 // no way to tune anything
2858 // but we need to run a few caching rounds
2859
2860 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2861 {
2862 try_run (device_param, kernel_accel, kernel_loops);
2863 try_run (device_param, kernel_accel, kernel_loops);
2864 try_run (device_param, kernel_accel, kernel_loops);
2865 try_run (device_param, kernel_accel, kernel_loops);
2866
2867 device_param->kernel_accel = kernel_accel;
2868 device_param->kernel_loops = kernel_loops;
2869
2870 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2871
2872 device_param->kernel_power = kernel_power;
2873
2874 return;
2875 }
2876
2877 // from here it's clear we are allowed to autotune
2878 // so let's init some fake words
2879
2880 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2881
2882 for (u32 i = 0; i < kernel_power_max; i++)
2883 {
2884 device_param->pws_buf[i].i[0] = i;
2885 device_param->pws_buf[i].i[1] = 0x01234567;
2886 device_param->pws_buf[i].pw_len = 7;
2887 }
2888
2889 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);
2890
2891 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2892 {
2893 run_kernel_amp (device_param, kernel_power_max);
2894 }
2895
2896 #define VERIFIER_CNT 1
2897
2898 // first find out highest kernel-loops that stays below target_ms
2899
2900 if (kernel_loops_min < kernel_loops_max)
2901 {
2902 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2903 {
2904 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2905
2906 for (int i = 0; i < VERIFIER_CNT; i++)
2907 {
2908 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2909
2910 exec_ms = MIN (exec_ms, exec_ms_v);
2911 }
2912
2913 if (exec_ms < target_ms) break;
2914 }
2915 }
2916
2917 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2918
2919 #define STEPS_CNT 10
2920
2921 if (kernel_accel_min < kernel_accel_max)
2922 {
2923 for (int i = 0; i < STEPS_CNT; i++)
2924 {
2925 const u32 kernel_accel_try = 1 << i;
2926
2927 if (kernel_accel_try < kernel_accel_min) continue;
2928 if (kernel_accel_try > kernel_accel_max) break;
2929
2930 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2931
2932 for (int i = 0; i < VERIFIER_CNT; i++)
2933 {
2934 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
2935
2936 exec_ms = MIN (exec_ms, exec_ms_v);
2937 }
2938
2939 if (exec_ms > target_ms) break;
2940
2941 kernel_accel = kernel_accel_try;
2942 }
2943 }
2944
2945 // at this point we want to know the actual runtime for the following reason:
2946 // we need a reference for the balancing loop following up, and this
2947 // the balancing loop can have an effect that the creates a new opportunity, for example:
2948 // if the target is 95 ms and the current runtime is 48ms the above loop
2949 // stopped the execution because the previous exec_ms was > 95ms
2950 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
2951 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
2952
2953 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
2954
2955 for (int i = 0; i < VERIFIER_CNT; i++)
2956 {
2957 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
2958
2959 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
2960 }
2961
2962 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
2963 {
2964 for (u32 f = 2; f < 1024; f++)
2965 {
2966 const u32 kernel_accel_try = kernel_accel * f;
2967 const u32 kernel_loops_try = kernel_loops / f;
2968
2969 if (kernel_accel_try > kernel_accel_max) break;
2970 if (kernel_loops_try < kernel_loops_min) break;
2971
2972 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
2973
2974 for (int i = 0; i < VERIFIER_CNT; i++)
2975 {
2976 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
2977
2978 exec_ms = MIN (exec_ms, exec_ms_v);
2979 }
2980
2981 if (exec_ms < exec_ms_pre_final)
2982 {
2983 exec_ms_pre_final = exec_ms;
2984
2985 kernel_accel = kernel_accel_try;
2986 kernel_loops = kernel_loops_try;
2987 }
2988 }
2989 }
2990
2991 const double exec_left = target_ms / exec_ms_pre_final;
2992
2993 const double accel_left = kernel_accel_max / kernel_accel;
2994
2995 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
2996
2997 if (exec_accel_min >= 1.0)
2998 {
2999 // this is safe to not overflow kernel_accel_max because of accel_left
3000
3001 kernel_accel = (double) kernel_accel * exec_accel_min;
3002 }
3003
3004 // reset them fake words
3005
3006 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3007
3008 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);
3009 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);
3010
3011 // reset timer
3012
3013 device_param->exec_pos = 0;
3014
3015 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3016
3017 // store
3018
3019 device_param->kernel_accel = kernel_accel;
3020 device_param->kernel_loops = kernel_loops;
3021
3022 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3023
3024 device_param->kernel_power = kernel_power;
3025
3026 #ifdef DEBUG
3027
3028 if (data.quiet == 0)
3029 {
3030 clear_prompt ();
3031
3032 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3033 "Device #%u: autotuned kernel-loops to %u\n",
3034 device_param->device_id + 1, kernel_accel,
3035 device_param->device_id + 1, kernel_loops);
3036
3037 fprintf (stdout, "%s", PROMPT);
3038
3039 fflush (stdout);
3040 }
3041
3042 #endif
3043 }
3044
3045 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3046 {
3047 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3048
3049 // init speed timer
3050
3051 uint speed_pos = device_param->speed_pos;
3052
3053 #ifdef _POSIX
3054 if (device_param->timer_speed.tv_sec == 0)
3055 {
3056 hc_timer_set (&device_param->timer_speed);
3057 }
3058 #endif
3059
3060 #ifdef _WIN
3061 if (device_param->timer_speed.QuadPart == 0)
3062 {
3063 hc_timer_set (&device_param->timer_speed);
3064 }
3065 #endif
3066
3067 // find higest password length, this is for optimization stuff
3068
3069 uint highest_pw_len = 0;
3070
3071 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3072 {
3073 }
3074 else if (data.attack_kern == ATTACK_KERN_COMBI)
3075 {
3076 }
3077 else if (data.attack_kern == ATTACK_KERN_BF)
3078 {
3079 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3080 + device_param->kernel_params_mp_l_buf32[5];
3081 }
3082
3083 // iteration type
3084
3085 uint innerloop_step = 0;
3086 uint innerloop_cnt = 0;
3087
3088 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3089 else innerloop_step = 1;
3090
3091 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3092 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3093 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3094
3095 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3096
3097 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3098 {
3099 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3100
3101 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3102
3103 if (data.devices_status == STATUS_CRACKED) break;
3104 if (data.devices_status == STATUS_ABORTED) break;
3105 if (data.devices_status == STATUS_QUIT) break;
3106 if (data.devices_status == STATUS_BYPASS) break;
3107
3108 salt_t *salt_buf = &data.salts_buf[salt_pos];
3109
3110 device_param->kernel_params_buf32[24] = salt_pos;
3111 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3112 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3113
3114 FILE *combs_fp = device_param->combs_fp;
3115
3116 if (data.attack_mode == ATTACK_MODE_COMBI)
3117 {
3118 rewind (combs_fp);
3119 }
3120
3121 // innerloops
3122
3123 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3124 {
3125 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3126
3127 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3128
3129 if (data.devices_status == STATUS_CRACKED) break;
3130 if (data.devices_status == STATUS_ABORTED) break;
3131 if (data.devices_status == STATUS_QUIT) break;
3132 if (data.devices_status == STATUS_BYPASS) break;
3133
3134 uint innerloop_left = innerloop_cnt - innerloop_pos;
3135
3136 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3137
3138 device_param->innerloop_pos = innerloop_pos;
3139 device_param->innerloop_left = innerloop_left;
3140
3141 device_param->kernel_params_buf32[27] = innerloop_left;
3142
3143 // i think we can get rid of this
3144 if (innerloop_left == 0)
3145 {
3146 puts ("bug, how should this happen????\n");
3147
3148 continue;
3149 }
3150
3151 if (data.salts_shown[salt_pos] == 1)
3152 {
3153 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3154
3155 continue;
3156 }
3157
3158 // initialize amplifiers
3159
3160 if (data.attack_mode == ATTACK_MODE_COMBI)
3161 {
3162 uint i = 0;
3163
3164 while (i < innerloop_left)
3165 {
3166 if (feof (combs_fp)) break;
3167
3168 int line_len = fgetl (combs_fp, line_buf);
3169
3170 if (line_len >= PW_MAX1) continue;
3171
3172 line_len = convert_from_hex (line_buf, line_len);
3173
3174 char *line_buf_new = line_buf;
3175
3176 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3177 {
3178 char rule_buf_out[BLOCK_SIZE] = { 0 };
3179
3180 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3181
3182 if (rule_len_out < 0)
3183 {
3184 data.words_progress_rejected[salt_pos] += pws_cnt;
3185
3186 continue;
3187 }
3188
3189 line_len = rule_len_out;
3190
3191 line_buf_new = rule_buf_out;
3192 }
3193
3194 line_len = MIN (line_len, PW_DICTMAX);
3195
3196 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3197
3198 memcpy (ptr, line_buf_new, line_len);
3199
3200 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3201
3202 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3203 {
3204 uppercase (ptr, line_len);
3205 }
3206
3207 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3208 {
3209 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3210 {
3211 ptr[line_len] = 0x80;
3212 }
3213
3214 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3215 {
3216 ptr[line_len] = 0x01;
3217 }
3218 }
3219
3220 device_param->combs_buf[i].pw_len = line_len;
3221
3222 i++;
3223 }
3224
3225 for (uint j = i; j < innerloop_left; j++)
3226 {
3227 device_param->combs_buf[j].i[0] = 0;
3228 device_param->combs_buf[j].i[1] = 0;
3229 device_param->combs_buf[j].i[2] = 0;
3230 device_param->combs_buf[j].i[3] = 0;
3231 device_param->combs_buf[j].i[4] = 0;
3232 device_param->combs_buf[j].i[5] = 0;
3233 device_param->combs_buf[j].i[6] = 0;
3234 device_param->combs_buf[j].i[7] = 0;
3235
3236 device_param->combs_buf[j].pw_len = 0;
3237 }
3238
3239 innerloop_left = i;
3240 }
3241 else if (data.attack_mode == ATTACK_MODE_BF)
3242 {
3243 u64 off = innerloop_pos;
3244
3245 device_param->kernel_params_mp_r_buf64[3] = off;
3246
3247 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3248 }
3249 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3250 {
3251 u64 off = innerloop_pos;
3252
3253 device_param->kernel_params_mp_buf64[3] = off;
3254
3255 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3256 }
3257 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3258 {
3259 u64 off = innerloop_pos;
3260
3261 device_param->kernel_params_mp_buf64[3] = off;
3262
3263 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3264 }
3265
3266 // copy amplifiers
3267
3268 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3269 {
3270 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);
3271 }
3272 else if (data.attack_mode == ATTACK_MODE_COMBI)
3273 {
3274 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);
3275 }
3276 else if (data.attack_mode == ATTACK_MODE_BF)
3277 {
3278 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);
3279 }
3280 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3281 {
3282 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);
3283 }
3284 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3285 {
3286 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);
3287 }
3288
3289 if (data.benchmark == 1)
3290 {
3291 hc_timer_set (&device_param->timer_speed);
3292 }
3293
3294 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3295
3296 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3297
3298 if (data.devices_status == STATUS_CRACKED) break;
3299 if (data.devices_status == STATUS_ABORTED) break;
3300 if (data.devices_status == STATUS_QUIT) break;
3301
3302 /**
3303 * result
3304 */
3305
3306 check_cracked (device_param, salt_pos);
3307
3308 /**
3309 * progress
3310 */
3311
3312 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3313
3314 hc_thread_mutex_lock (mux_counter);
3315
3316 data.words_progress_done[salt_pos] += perf_sum_all;
3317
3318 hc_thread_mutex_unlock (mux_counter);
3319
3320 /**
3321 * speed
3322 */
3323
3324 double speed_ms;
3325
3326 hc_timer_get (device_param->timer_speed, speed_ms);
3327
3328 hc_timer_set (&device_param->timer_speed);
3329
3330 // current speed
3331
3332 //hc_thread_mutex_lock (mux_display);
3333
3334 device_param->speed_cnt[speed_pos] = perf_sum_all;
3335
3336 device_param->speed_ms[speed_pos] = speed_ms;
3337
3338 //hc_thread_mutex_unlock (mux_display);
3339
3340 speed_pos++;
3341
3342 if (speed_pos == SPEED_CACHE)
3343 {
3344 speed_pos = 0;
3345 }
3346
3347 /**
3348 * benchmark
3349 */
3350
3351 if (data.benchmark == 1) break;
3352 }
3353 }
3354
3355 device_param->speed_pos = speed_pos;
3356
3357 myfree (line_buf);
3358 }
3359
3360 static void load_segment (wl_data_t *wl_data, FILE *fd)
3361 {
3362 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3363
3364 wl_data->pos = 0;
3365
3366 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3367
3368 wl_data->buf[wl_data->cnt] = 0;
3369
3370 if (wl_data->cnt == 0) return;
3371
3372 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3373
3374 while (!feof (fd))
3375 {
3376 if (wl_data->cnt == wl_data->avail)
3377 {
3378 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3379
3380 wl_data->avail += wl_data->incr;
3381 }
3382
3383 const int c = fgetc (fd);
3384
3385 if (c == EOF) break;
3386
3387 wl_data->buf[wl_data->cnt] = (char) c;
3388
3389 wl_data->cnt++;
3390
3391 if (c == '\n') break;
3392 }
3393
3394 // ensure stream ends with a newline
3395
3396 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3397 {
3398 wl_data->cnt++;
3399
3400 wl_data->buf[wl_data->cnt - 1] = '\n';
3401 }
3402
3403 return;
3404 }
3405
3406 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3407 {
3408 char *ptr = buf;
3409
3410 for (u32 i = 0; i < sz; i++, ptr++)
3411 {
3412 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3413
3414 if (i == 7)
3415 {
3416 *off = i;
3417 *len = i;
3418
3419 return;
3420 }
3421
3422 if (*ptr != '\n') continue;
3423
3424 *off = i + 1;
3425
3426 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3427
3428 *len = i;
3429
3430 return;
3431 }
3432
3433 *off = sz;
3434 *len = sz;
3435 }
3436
3437 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3438 {
3439 char *ptr = buf;
3440
3441 for (u32 i = 0; i < sz; i++, ptr++)
3442 {
3443 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3444
3445 if (*ptr != '\n') continue;
3446
3447 *off = i + 1;
3448
3449 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3450
3451 *len = i;
3452
3453 return;
3454 }
3455
3456 *off = sz;
3457 *len = sz;
3458 }
3459
3460 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3461 {
3462 char *ptr = buf;
3463
3464 for (u32 i = 0; i < sz; i++, ptr++)
3465 {
3466 if (*ptr != '\n') continue;
3467
3468 *off = i + 1;
3469
3470 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3471
3472 *len = i;
3473
3474 return;
3475 }
3476
3477 *off = sz;
3478 *len = sz;
3479 }
3480
3481 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3482 {
3483 while (wl_data->pos < wl_data->cnt)
3484 {
3485 uint off;
3486 uint len;
3487
3488 char *ptr = wl_data->buf + wl_data->pos;
3489
3490 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3491
3492 wl_data->pos += off;
3493
3494 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3495 {
3496 char rule_buf_out[BLOCK_SIZE] = { 0 };
3497
3498 int rule_len_out = -1;
3499
3500 if (len < BLOCK_SIZE)
3501 {
3502 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3503 }
3504
3505 if (rule_len_out < 0)
3506 {
3507 continue;
3508 }
3509
3510 if (rule_len_out > PW_MAX)
3511 {
3512 continue;
3513 }
3514 }
3515 else
3516 {
3517 if (len > PW_MAX)
3518 {
3519 continue;
3520 }
3521 }
3522
3523 *out_buf = ptr;
3524 *out_len = len;
3525
3526 return;
3527 }
3528
3529 if (feof (fd))
3530 {
3531 fprintf (stderr, "BUG feof()!!\n");
3532
3533 return;
3534 }
3535
3536 load_segment (wl_data, fd);
3537
3538 get_next_word (wl_data, fd, out_buf, out_len);
3539 }
3540
3541 #ifdef _POSIX
3542 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3543 #endif
3544
3545 #ifdef _WIN
3546 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3547 #endif
3548 {
3549 hc_signal (NULL);
3550
3551 dictstat_t d;
3552
3553 d.cnt = 0;
3554
3555 #ifdef _POSIX
3556 fstat (fileno (fd), &d.stat);
3557 #endif
3558
3559 #ifdef _WIN
3560 _fstat64 (fileno (fd), &d.stat);
3561 #endif
3562
3563 d.stat.st_mode = 0;
3564 d.stat.st_nlink = 0;
3565 d.stat.st_uid = 0;
3566 d.stat.st_gid = 0;
3567 d.stat.st_rdev = 0;
3568 d.stat.st_atime = 0;
3569
3570 #ifdef _POSIX
3571 d.stat.st_blksize = 0;
3572 d.stat.st_blocks = 0;
3573 #endif
3574
3575 if (d.stat.st_size == 0) return 0;
3576
3577 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3578
3579 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3580 {
3581 if (d_cache)
3582 {
3583 u64 cnt = d_cache->cnt;
3584
3585 u64 keyspace = cnt;
3586
3587 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3588 {
3589 keyspace *= data.kernel_rules_cnt;
3590 }
3591 else if (data.attack_kern == ATTACK_KERN_COMBI)
3592 {
3593 keyspace *= data.combs_cnt;
3594 }
3595
3596 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);
3597 if (data.quiet == 0) log_info ("");
3598
3599 hc_signal (sigHandler_default);
3600
3601 return (keyspace);
3602 }
3603 }
3604
3605 time_t now = 0;
3606 time_t prev = 0;
3607
3608 u64 comp = 0;
3609 u64 cnt = 0;
3610 u64 cnt2 = 0;
3611
3612 while (!feof (fd))
3613 {
3614 load_segment (wl_data, fd);
3615
3616 comp += wl_data->cnt;
3617
3618 u32 i = 0;
3619
3620 while (i < wl_data->cnt)
3621 {
3622 u32 len;
3623 u32 off;
3624
3625 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3626
3627 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3628 {
3629 char rule_buf_out[BLOCK_SIZE] = { 0 };
3630
3631 int rule_len_out = -1;
3632
3633 if (len < BLOCK_SIZE)
3634 {
3635 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3636 }
3637
3638 if (rule_len_out < 0)
3639 {
3640 len = PW_MAX1;
3641 }
3642 else
3643 {
3644 len = rule_len_out;
3645 }
3646 }
3647
3648 if (len < PW_MAX1)
3649 {
3650 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3651 {
3652 cnt += data.kernel_rules_cnt;
3653 }
3654 else if (data.attack_kern == ATTACK_KERN_COMBI)
3655 {
3656 cnt += data.combs_cnt;
3657 }
3658
3659 d.cnt++;
3660 }
3661
3662 i += off;
3663
3664 cnt2++;
3665 }
3666
3667 time (&now);
3668
3669 if ((now - prev) == 0) continue;
3670
3671 float percent = (float) comp / (float) d.stat.st_size;
3672
3673 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);
3674
3675 time (&prev);
3676 }
3677
3678 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);
3679 if (data.quiet == 0) log_info ("");
3680
3681 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3682
3683 hc_signal (sigHandler_default);
3684
3685 return (cnt);
3686 }
3687
3688 static void *thread_monitor (void *p)
3689 {
3690 uint runtime_check = 0;
3691 uint remove_check = 0;
3692 uint status_check = 0;
3693 uint restore_check = 0;
3694
3695 uint restore_left = data.restore_timer;
3696 uint remove_left = data.remove_timer;
3697 uint status_left = data.status_timer;
3698
3699 #ifdef HAVE_HWMON
3700 uint hwmon_check = 0;
3701
3702 // these variables are mainly used for fan control (AMD only)
3703
3704 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3705
3706 // temperature controller "loopback" values
3707
3708 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3709 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3710
3711 #ifdef HAVE_ADL
3712 int temp_threshold = 1; // degrees celcius
3713
3714 int fan_speed_min = 15; // in percentage
3715 int fan_speed_max = 100;
3716 #endif // HAVE_ADL
3717
3718 time_t last_temp_check_time;
3719 #endif // HAVE_HWMON
3720
3721 uint sleep_time = 1;
3722
3723 if (data.runtime)
3724 {
3725 runtime_check = 1;
3726 }
3727
3728 if (data.restore_timer)
3729 {
3730 restore_check = 1;
3731 }
3732
3733 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3734 {
3735 remove_check = 1;
3736 }
3737
3738 if (data.status == 1)
3739 {
3740 status_check = 1;
3741 }
3742
3743 #ifdef HAVE_HWMON
3744 if (data.gpu_temp_disable == 0)
3745 {
3746 time (&last_temp_check_time);
3747
3748 hwmon_check = 1;
3749 }
3750 #endif
3751
3752 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3753 {
3754 #ifdef HAVE_HWMON
3755 if (hwmon_check == 0)
3756 #endif
3757 return (p);
3758 }
3759
3760 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3761 {
3762 hc_sleep (sleep_time);
3763
3764 if (data.devices_status != STATUS_RUNNING) continue;
3765
3766 #ifdef HAVE_HWMON
3767 if (hwmon_check == 1)
3768 {
3769 hc_thread_mutex_lock (mux_adl);
3770
3771 time_t temp_check_time;
3772
3773 time (&temp_check_time);
3774
3775 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3776
3777 if (Ta == 0) Ta = 1;
3778
3779 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3780 {
3781 hc_device_param_t *device_param = &data.devices_param[device_id];
3782
3783 if (device_param->skipped) continue;
3784
3785 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3786
3787 const int temperature = hm_get_temperature_with_device_id (device_id);
3788
3789 if (temperature > (int) data.gpu_temp_abort)
3790 {
3791 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3792
3793 if (data.devices_status != STATUS_QUIT) myabort ();
3794
3795 break;
3796 }
3797
3798 #ifdef HAVE_ADL
3799 const int gpu_temp_retain = data.gpu_temp_retain;
3800
3801 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3802 {
3803 if (data.hm_device[device_id].fan_supported == 1)
3804 {
3805 int temp_cur = temperature;
3806
3807 int temp_diff_new = gpu_temp_retain - temp_cur;
3808
3809 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3810
3811 // calculate Ta value (time difference in seconds between the last check and this check)
3812
3813 last_temp_check_time = temp_check_time;
3814
3815 float Kp = 1.8;
3816 float Ki = 0.005;
3817 float Kd = 6;
3818
3819 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3820
3821 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);
3822
3823 if (abs (fan_diff_required) >= temp_threshold)
3824 {
3825 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3826
3827 int fan_speed_level = fan_speed_cur;
3828
3829 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3830
3831 int fan_speed_new = fan_speed_level - fan_diff_required;
3832
3833 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3834 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3835
3836 if (fan_speed_new != fan_speed_cur)
3837 {
3838 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3839 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3840
3841 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3842 {
3843 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3844
3845 fan_speed_chgd[device_id] = 1;
3846 }
3847
3848 temp_diff_old[device_id] = temp_diff_new;
3849 }
3850 }
3851 }
3852 }
3853 #endif // HAVE_ADL
3854 }
3855
3856 hc_thread_mutex_unlock (mux_adl);
3857 }
3858 #endif // HAVE_HWMON
3859
3860 if (restore_check == 1)
3861 {
3862 restore_left--;
3863
3864 if (restore_left == 0)
3865 {
3866 if (data.restore_disable == 0) cycle_restore ();
3867
3868 restore_left = data.restore_timer;
3869 }
3870 }
3871
3872 if ((runtime_check == 1) && (data.runtime_start > 0))
3873 {
3874 time_t runtime_cur;
3875
3876 time (&runtime_cur);
3877
3878 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3879
3880 if (runtime_left <= 0)
3881 {
3882 if (data.benchmark == 0)
3883 {
3884 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3885 }
3886
3887 if (data.devices_status != STATUS_QUIT) myabort ();
3888 }
3889 }
3890
3891 if (remove_check == 1)
3892 {
3893 remove_left--;
3894
3895 if (remove_left == 0)
3896 {
3897 if (data.digests_saved != data.digests_done)
3898 {
3899 data.digests_saved = data.digests_done;
3900
3901 save_hash ();
3902 }
3903
3904 remove_left = data.remove_timer;
3905 }
3906 }
3907
3908 if (status_check == 1)
3909 {
3910 status_left--;
3911
3912 if (status_left == 0)
3913 {
3914 //hc_thread_mutex_lock (mux_display);
3915
3916 if (data.quiet == 0) clear_prompt ();
3917
3918 if (data.quiet == 0) log_info ("");
3919
3920 status_display ();
3921
3922 if (data.quiet == 0) log_info ("");
3923
3924 //hc_thread_mutex_unlock (mux_display);
3925
3926 status_left = data.status_timer;
3927 }
3928 }
3929 }
3930
3931 #ifdef HAVE_HWMON
3932 myfree (fan_speed_chgd);
3933
3934 myfree (temp_diff_old);
3935 myfree (temp_diff_sum);
3936 #endif
3937
3938 p = NULL;
3939
3940 return (p);
3941 }
3942
3943 static void *thread_outfile_remove (void *p)
3944 {
3945 // some hash-dependent constants
3946 char *outfile_dir = data.outfile_check_directory;
3947 uint dgst_size = data.dgst_size;
3948 uint isSalted = data.isSalted;
3949 uint esalt_size = data.esalt_size;
3950 uint hash_mode = data.hash_mode;
3951
3952 uint outfile_check_timer = data.outfile_check_timer;
3953
3954 char separator = data.separator;
3955
3956 // some hash-dependent functions
3957 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3958 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3959
3960 // buffers
3961 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3962
3963 hash_buf.digest = mymalloc (dgst_size);
3964
3965 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3966
3967 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3968
3969 uint digest_buf[64] = { 0 };
3970
3971 outfile_data_t *out_info = NULL;
3972
3973 char **out_files = NULL;
3974
3975 time_t folder_mtime = 0;
3976
3977 int out_cnt = 0;
3978
3979 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3980
3981 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3982 {
3983 hc_sleep (1);
3984
3985 if (data.devices_status != STATUS_RUNNING) continue;
3986
3987 check_left--;
3988
3989 if (check_left == 0)
3990 {
3991 struct stat outfile_check_stat;
3992
3993 if (stat (outfile_dir, &outfile_check_stat) == 0)
3994 {
3995 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3996
3997 if (is_dir == 1)
3998 {
3999 if (outfile_check_stat.st_mtime > folder_mtime)
4000 {
4001 char **out_files_new = scan_directory (outfile_dir);
4002
4003 int out_cnt_new = count_dictionaries (out_files_new);
4004
4005 outfile_data_t *out_info_new = NULL;
4006
4007 if (out_cnt_new > 0)
4008 {
4009 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4010
4011 for (int i = 0; i < out_cnt_new; i++)
4012 {
4013 out_info_new[i].file_name = out_files_new[i];
4014
4015 // check if there are files that we have seen/checked before (and not changed)
4016
4017 for (int j = 0; j < out_cnt; j++)
4018 {
4019 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4020 {
4021 struct stat outfile_stat;
4022
4023 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4024 {
4025 if (outfile_stat.st_ctime == out_info[j].ctime)
4026 {
4027 out_info_new[i].ctime = out_info[j].ctime;
4028 out_info_new[i].seek = out_info[j].seek;
4029 }
4030 }
4031 }
4032 }
4033 }
4034 }
4035
4036 local_free (out_info);
4037 local_free (out_files);
4038
4039 out_files = out_files_new;
4040 out_cnt = out_cnt_new;
4041 out_info = out_info_new;
4042
4043 folder_mtime = outfile_check_stat.st_mtime;
4044 }
4045
4046 for (int j = 0; j < out_cnt; j++)
4047 {
4048 FILE *fp = fopen (out_info[j].file_name, "rb");
4049
4050 if (fp != NULL)
4051 {
4052 //hc_thread_mutex_lock (mux_display);
4053
4054 #ifdef _POSIX
4055 struct stat outfile_stat;
4056
4057 fstat (fileno (fp), &outfile_stat);
4058 #endif
4059
4060 #ifdef _WIN
4061 struct stat64 outfile_stat;
4062
4063 _fstat64 (fileno (fp), &outfile_stat);
4064 #endif
4065
4066 if (outfile_stat.st_ctime > out_info[j].ctime)
4067 {
4068 out_info[j].ctime = outfile_stat.st_ctime;
4069 out_info[j].seek = 0;
4070 }
4071
4072 fseek (fp, out_info[j].seek, SEEK_SET);
4073
4074 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4075
4076 while (!feof (fp))
4077 {
4078 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4079
4080 if (ptr == NULL) break;
4081
4082 int line_len = strlen (line_buf);
4083
4084 if (line_len <= 0) continue;
4085
4086 int iter = MAX_CUT_TRIES;
4087
4088 for (uint i = line_len - 1; i && iter; i--, line_len--)
4089 {
4090 if (line_buf[i] != separator) continue;
4091
4092 int parser_status = PARSER_OK;
4093
4094 if ((hash_mode != 2500) && (hash_mode != 6800))
4095 {
4096 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4097 }
4098
4099 uint found = 0;
4100
4101 if (parser_status == PARSER_OK)
4102 {
4103 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4104 {
4105 if (data.salts_shown[salt_pos] == 1) continue;
4106
4107 salt_t *salt_buf = &data.salts_buf[salt_pos];
4108
4109 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4110 {
4111 uint idx = salt_buf->digests_offset + digest_pos;
4112
4113 if (data.digests_shown[idx] == 1) continue;
4114
4115 uint cracked = 0;
4116
4117 if (hash_mode == 6800)
4118 {
4119 if (i == salt_buf->salt_len)
4120 {
4121 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4122 }
4123 }
4124 else if (hash_mode == 2500)
4125 {
4126 // BSSID : MAC1 : MAC2 (:plain)
4127 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4128 {
4129 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4130
4131 if (!cracked) continue;
4132
4133 // now compare MAC1 and MAC2 too, since we have this additional info
4134 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4135 char *mac2_pos = mac1_pos + 12 + 1;
4136
4137 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4138 wpa_t *wpa = &wpas[salt_pos];
4139
4140 // compare hex string(s) vs binary MAC address(es)
4141
4142 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4143 {
4144 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4145 {
4146 cracked = 0;
4147
4148 break;
4149 }
4150 }
4151
4152 // early skip ;)
4153 if (!cracked) continue;
4154
4155 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4156 {
4157 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4158 {
4159 cracked = 0;
4160
4161 break;
4162 }
4163 }
4164 }
4165 }
4166 else
4167 {
4168 char *digests_buf_ptr = (char *) data.digests_buf;
4169
4170 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4171
4172 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4173 }
4174
4175 if (cracked == 1)
4176 {
4177 found = 1;
4178
4179 data.digests_shown[idx] = 1;
4180
4181 data.digests_done++;
4182
4183 salt_buf->digests_done++;
4184
4185 if (salt_buf->digests_done == salt_buf->digests_cnt)
4186 {
4187 data.salts_shown[salt_pos] = 1;
4188
4189 data.salts_done++;
4190
4191 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4192 }
4193 }
4194 }
4195
4196 if (data.devices_status == STATUS_CRACKED) break;
4197 }
4198 }
4199
4200 if (found) break;
4201
4202 if (data.devices_status == STATUS_CRACKED) break;
4203
4204 iter--;
4205 }
4206
4207 if (data.devices_status == STATUS_CRACKED) break;
4208 }
4209
4210 myfree (line_buf);
4211
4212 out_info[j].seek = ftell (fp);
4213
4214 //hc_thread_mutex_unlock (mux_display);
4215
4216 fclose (fp);
4217 }
4218 }
4219 }
4220 }
4221
4222 check_left = outfile_check_timer;
4223 }
4224 }
4225
4226 if (esalt_size) local_free (hash_buf.esalt);
4227
4228 if (isSalted) local_free (hash_buf.salt);
4229
4230 local_free (hash_buf.digest);
4231
4232 local_free (out_info);
4233
4234 local_free (out_files);
4235
4236 p = NULL;
4237
4238 return (p);
4239 }
4240
4241 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4242 {
4243 if (device_param->pws_cnt < device_param->kernel_power)
4244 {
4245 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4246
4247 u8 *ptr = (u8 *) pw->i;
4248
4249 memcpy (ptr, pw_buf, pw_len);
4250
4251 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4252
4253 pw->pw_len = pw_len;
4254
4255 device_param->pws_cnt++;
4256 }
4257 else
4258 {
4259 fprintf (stderr, "BUG pw_add()!!\n");
4260
4261 return;
4262 }
4263 }
4264
4265 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4266 {
4267 hc_thread_mutex_lock (mux_dispatcher);
4268
4269 const u64 words_cur = data.words_cur;
4270 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4271
4272 device_param->words_off = words_cur;
4273
4274 const u64 words_left = words_base - words_cur;
4275
4276 if (allow_div)
4277 {
4278 if (data.kernel_power_all > words_left)
4279 {
4280 if (data.kernel_power_div == 0)
4281 {
4282 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4283 }
4284 }
4285
4286 if (data.kernel_power_div)
4287 {
4288 if (device_param->kernel_power == device_param->kernel_power_user)
4289 {
4290 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4291
4292 if (kernel_power_new < device_param->kernel_power)
4293 {
4294 device_param->kernel_power = kernel_power_new;
4295 }
4296 }
4297 }
4298 }
4299
4300 const uint kernel_power = device_param->kernel_power;
4301
4302 uint work = MIN (words_left, kernel_power);
4303
4304 work = MIN (work, max);
4305
4306 data.words_cur += work;
4307
4308 hc_thread_mutex_unlock (mux_dispatcher);
4309
4310 return work;
4311 }
4312
4313 static void *thread_calc_stdin (void *p)
4314 {
4315 hc_device_param_t *device_param = (hc_device_param_t *) p;
4316
4317 if (device_param->skipped) return NULL;
4318
4319 autotune (device_param);
4320
4321 char *buf = (char *) mymalloc (HCBUFSIZ);
4322
4323 const uint attack_kern = data.attack_kern;
4324
4325 const uint kernel_power = device_param->kernel_power;
4326
4327 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4328 {
4329 hc_thread_mutex_lock (mux_dispatcher);
4330
4331 if (feof (stdin) != 0)
4332 {
4333 hc_thread_mutex_unlock (mux_dispatcher);
4334
4335 break;
4336 }
4337
4338 uint words_cur = 0;
4339
4340 while (words_cur < kernel_power)
4341 {
4342 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4343
4344 if (line_buf == NULL) break;
4345
4346 uint line_len = in_superchop (line_buf);
4347
4348 line_len = convert_from_hex (line_buf, line_len);
4349
4350 // post-process rule engine
4351
4352 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4353 {
4354 char rule_buf_out[BLOCK_SIZE] = { 0 };
4355
4356 int rule_len_out = -1;
4357
4358 if (line_len < BLOCK_SIZE)
4359 {
4360 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4361 }
4362
4363 if (rule_len_out < 0) continue;
4364
4365 line_buf = rule_buf_out;
4366 line_len = rule_len_out;
4367 }
4368
4369 if (line_len > PW_MAX)
4370 {
4371 continue;
4372 }
4373
4374 if (attack_kern == ATTACK_KERN_STRAIGHT)
4375 {
4376 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4377 {
4378 hc_thread_mutex_lock (mux_counter);
4379
4380 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4381 {
4382 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4383 }
4384
4385 hc_thread_mutex_unlock (mux_counter);
4386
4387 continue;
4388 }
4389 }
4390 else if (attack_kern == ATTACK_KERN_COMBI)
4391 {
4392 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4393 // since we still need to combine the plains
4394
4395 if (line_len > data.pw_max)
4396 {
4397 hc_thread_mutex_lock (mux_counter);
4398
4399 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4400 {
4401 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4402 }
4403
4404 hc_thread_mutex_unlock (mux_counter);
4405
4406 continue;
4407 }
4408 }
4409
4410 pw_add (device_param, (u8 *) line_buf, line_len);
4411
4412 words_cur++;
4413
4414 if (data.devices_status == STATUS_CRACKED) break;
4415 if (data.devices_status == STATUS_ABORTED) break;
4416 if (data.devices_status == STATUS_QUIT) break;
4417 if (data.devices_status == STATUS_BYPASS) break;
4418 }
4419
4420 hc_thread_mutex_unlock (mux_dispatcher);
4421
4422 if (data.devices_status == STATUS_CRACKED) break;
4423 if (data.devices_status == STATUS_ABORTED) break;
4424 if (data.devices_status == STATUS_QUIT) break;
4425 if (data.devices_status == STATUS_BYPASS) break;
4426
4427 // flush
4428
4429 const uint pws_cnt = device_param->pws_cnt;
4430
4431 if (pws_cnt)
4432 {
4433 run_copy (device_param, pws_cnt);
4434
4435 run_cracker (device_param, pws_cnt);
4436
4437 device_param->pws_cnt = 0;
4438
4439 /*
4440 still required?
4441 if (attack_kern == ATTACK_KERN_STRAIGHT)
4442 {
4443 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4444 }
4445 else if (attack_kern == ATTACK_KERN_COMBI)
4446 {
4447 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4448 }
4449 */
4450 }
4451 }
4452
4453 device_param->kernel_accel = 0;
4454 device_param->kernel_loops = 0;
4455
4456 myfree (buf);
4457
4458 return NULL;
4459 }
4460
4461 static void *thread_calc (void *p)
4462 {
4463 hc_device_param_t *device_param = (hc_device_param_t *) p;
4464
4465 if (device_param->skipped) return NULL;
4466
4467 autotune (device_param);
4468
4469 const uint attack_mode = data.attack_mode;
4470 const uint attack_kern = data.attack_kern;
4471
4472 if (attack_mode == ATTACK_MODE_BF)
4473 {
4474 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4475 {
4476 const uint work = get_work (device_param, -1, true);
4477
4478 if (work == 0) break;
4479
4480 const u64 words_off = device_param->words_off;
4481 const u64 words_fin = words_off + work;
4482
4483 const uint pws_cnt = work;
4484
4485 device_param->pws_cnt = pws_cnt;
4486
4487 if (pws_cnt)
4488 {
4489 run_copy (device_param, pws_cnt);
4490
4491 run_cracker (device_param, pws_cnt);
4492
4493 device_param->pws_cnt = 0;
4494
4495 /*
4496 still required?
4497 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4498 */
4499 }
4500
4501 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4502
4503 if (data.devices_status == STATUS_CRACKED) break;
4504 if (data.devices_status == STATUS_ABORTED) break;
4505 if (data.devices_status == STATUS_QUIT) break;
4506 if (data.devices_status == STATUS_BYPASS) break;
4507
4508 if (data.benchmark == 1) break;
4509
4510 device_param->words_done = words_fin;
4511 }
4512 }
4513 else
4514 {
4515 const uint segment_size = data.segment_size;
4516
4517 char *dictfile = data.dictfile;
4518
4519 if (attack_mode == ATTACK_MODE_COMBI)
4520 {
4521 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4522 {
4523 dictfile = data.dictfile2;
4524 }
4525 }
4526
4527 FILE *fd = fopen (dictfile, "rb");
4528
4529 if (fd == NULL)
4530 {
4531 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4532
4533 return NULL;
4534 }
4535
4536 if (attack_mode == ATTACK_MODE_COMBI)
4537 {
4538 const uint combs_mode = data.combs_mode;
4539
4540 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4541 {
4542 const char *dictfilec = data.dictfile2;
4543
4544 FILE *combs_fp = fopen (dictfilec, "rb");
4545
4546 if (combs_fp == NULL)
4547 {
4548 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4549
4550 fclose (fd);
4551
4552 return NULL;
4553 }
4554
4555 device_param->combs_fp = combs_fp;
4556 }
4557 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4558 {
4559 const char *dictfilec = data.dictfile;
4560
4561 FILE *combs_fp = fopen (dictfilec, "rb");
4562
4563 if (combs_fp == NULL)
4564 {
4565 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4566
4567 fclose (fd);
4568
4569 return NULL;
4570 }
4571
4572 device_param->combs_fp = combs_fp;
4573 }
4574 }
4575
4576 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4577
4578 wl_data->buf = (char *) mymalloc (segment_size);
4579 wl_data->avail = segment_size;
4580 wl_data->incr = segment_size;
4581 wl_data->cnt = 0;
4582 wl_data->pos = 0;
4583
4584 u64 words_cur = 0;
4585
4586 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4587 {
4588 u64 words_off = 0;
4589 u64 words_fin = 0;
4590
4591 bool allow_div = true;
4592
4593 u64 max = -1;
4594
4595 while (max)
4596 {
4597 const uint work = get_work (device_param, max, allow_div);
4598
4599 allow_div = false;
4600
4601 if (work == 0) break;
4602
4603 words_off = device_param->words_off;
4604 words_fin = words_off + work;
4605
4606 char *line_buf;
4607 uint line_len;
4608
4609 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4610
4611 max = 0;
4612
4613 for ( ; words_cur < words_fin; words_cur++)
4614 {
4615 get_next_word (wl_data, fd, &line_buf, &line_len);
4616
4617 line_len = convert_from_hex (line_buf, line_len);
4618
4619 // post-process rule engine
4620
4621 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4622 {
4623 char rule_buf_out[BLOCK_SIZE] = { 0 };
4624
4625 int rule_len_out = -1;
4626
4627 if (line_len < BLOCK_SIZE)
4628 {
4629 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4630 }
4631
4632 if (rule_len_out < 0) continue;
4633
4634 line_buf = rule_buf_out;
4635 line_len = rule_len_out;
4636 }
4637
4638 if (attack_kern == ATTACK_KERN_STRAIGHT)
4639 {
4640 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4641 {
4642 max++;
4643
4644 hc_thread_mutex_lock (mux_counter);
4645
4646 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4647 {
4648 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4649 }
4650
4651 hc_thread_mutex_unlock (mux_counter);
4652
4653 continue;
4654 }
4655 }
4656 else if (attack_kern == ATTACK_KERN_COMBI)
4657 {
4658 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4659 // since we still need to combine the plains
4660
4661 if (line_len > data.pw_max)
4662 {
4663 max++;
4664
4665 hc_thread_mutex_lock (mux_counter);
4666
4667 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4668 {
4669 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4670 }
4671
4672 hc_thread_mutex_unlock (mux_counter);
4673
4674 continue;
4675 }
4676 }
4677
4678 pw_add (device_param, (u8 *) line_buf, line_len);
4679
4680 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4681
4682 if (data.devices_status == STATUS_CRACKED) break;
4683 if (data.devices_status == STATUS_ABORTED) break;
4684 if (data.devices_status == STATUS_QUIT) break;
4685 if (data.devices_status == STATUS_BYPASS) break;
4686 }
4687
4688 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4689
4690 if (data.devices_status == STATUS_CRACKED) break;
4691 if (data.devices_status == STATUS_ABORTED) break;
4692 if (data.devices_status == STATUS_QUIT) break;
4693 if (data.devices_status == STATUS_BYPASS) break;
4694 }
4695
4696 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4697
4698 if (data.devices_status == STATUS_CRACKED) break;
4699 if (data.devices_status == STATUS_ABORTED) break;
4700 if (data.devices_status == STATUS_QUIT) break;
4701 if (data.devices_status == STATUS_BYPASS) break;
4702
4703 //
4704 // flush
4705 //
4706
4707 const uint pws_cnt = device_param->pws_cnt;
4708
4709 if (pws_cnt)
4710 {
4711 run_copy (device_param, pws_cnt);
4712
4713 run_cracker (device_param, pws_cnt);
4714
4715 device_param->pws_cnt = 0;
4716
4717 /*
4718 still required?
4719 if (attack_kern == ATTACK_KERN_STRAIGHT)
4720 {
4721 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4722 }
4723 else if (attack_kern == ATTACK_KERN_COMBI)
4724 {
4725 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4726 }
4727 */
4728 }
4729
4730 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4731
4732 if (data.devices_status == STATUS_CRACKED) break;
4733 if (data.devices_status == STATUS_ABORTED) break;
4734 if (data.devices_status == STATUS_QUIT) break;
4735 if (data.devices_status == STATUS_BYPASS) break;
4736
4737 if (words_fin == 0) break;
4738
4739 device_param->words_done = words_fin;
4740 }
4741
4742 if (attack_mode == ATTACK_MODE_COMBI)
4743 {
4744 fclose (device_param->combs_fp);
4745 }
4746
4747 free (wl_data->buf);
4748 free (wl_data);
4749
4750 fclose (fd);
4751 }
4752
4753 device_param->kernel_accel = 0;
4754 device_param->kernel_loops = 0;
4755
4756 return NULL;
4757 }
4758
4759 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4760 {
4761 if (!device_param)
4762 {
4763 log_error ("ERROR: %s : Invalid argument", __func__);
4764
4765 exit (-1);
4766 }
4767
4768 salt_t *salt_buf = &data.salts_buf[salt_pos];
4769
4770 device_param->kernel_params_buf32[24] = salt_pos;
4771 device_param->kernel_params_buf32[27] = 1;
4772 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4773 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4774 device_param->kernel_params_buf32[30] = 0;
4775 device_param->kernel_params_buf32[31] = 1;
4776
4777 char *dictfile_old = data.dictfile;
4778
4779 const char *weak_hash_check = "weak-hash-check";
4780
4781 data.dictfile = (char *) weak_hash_check;
4782
4783 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4784
4785 data.kernel_rules_buf[0].cmds[0] = 0;
4786
4787 /**
4788 * run the kernel
4789 */
4790
4791 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4792 {
4793 run_kernel (KERN_RUN_1, device_param, 1, false);
4794 }
4795 else
4796 {
4797 run_kernel (KERN_RUN_1, device_param, 1, false);
4798
4799 uint loop_step = 16;
4800
4801 const uint iter = salt_buf->salt_iter;
4802
4803 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4804 {
4805 uint loop_left = iter - loop_pos;
4806
4807 loop_left = MIN (loop_left, loop_step);
4808
4809 device_param->kernel_params_buf32[25] = loop_pos;
4810 device_param->kernel_params_buf32[26] = loop_left;
4811
4812 run_kernel (KERN_RUN_2, device_param, 1, false);
4813 }
4814
4815 run_kernel (KERN_RUN_3, device_param, 1, false);
4816 }
4817
4818 /**
4819 * result
4820 */
4821
4822 check_cracked (device_param, salt_pos);
4823
4824 /**
4825 * cleanup
4826 */
4827
4828 device_param->kernel_params_buf32[24] = 0;
4829 device_param->kernel_params_buf32[25] = 0;
4830 device_param->kernel_params_buf32[26] = 0;
4831 device_param->kernel_params_buf32[27] = 0;
4832 device_param->kernel_params_buf32[28] = 0;
4833 device_param->kernel_params_buf32[29] = 0;
4834 device_param->kernel_params_buf32[30] = 0;
4835 device_param->kernel_params_buf32[31] = 0;
4836
4837 data.dictfile = dictfile_old;
4838
4839 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4840 }
4841
4842 // hlfmt hashcat
4843
4844 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4845 {
4846 if (data.username == 0)
4847 {
4848 *hashbuf_pos = line_buf;
4849 *hashbuf_len = line_len;
4850 }
4851 else
4852 {
4853 char *pos = line_buf;
4854 int len = line_len;
4855
4856 for (int i = 0; i < line_len; i++, pos++, len--)
4857 {
4858 if (line_buf[i] == data.separator)
4859 {
4860 pos++;
4861
4862 len--;
4863
4864 break;
4865 }
4866 }
4867
4868 *hashbuf_pos = pos;
4869 *hashbuf_len = len;
4870 }
4871 }
4872
4873 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4874 {
4875 char *pos = NULL;
4876 int len = 0;
4877
4878 int sep_cnt = 0;
4879
4880 for (int i = 0; i < line_len; i++)
4881 {
4882 if (line_buf[i] == data.separator)
4883 {
4884 sep_cnt++;
4885
4886 continue;
4887 }
4888
4889 if (sep_cnt == 0)
4890 {
4891 if (pos == NULL) pos = line_buf + i;
4892
4893 len++;
4894 }
4895 }
4896
4897 *userbuf_pos = pos;
4898 *userbuf_len = len;
4899 }
4900
4901 // hlfmt pwdump
4902
4903 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4904 {
4905 int sep_cnt = 0;
4906
4907 int sep2_len = 0;
4908 int sep3_len = 0;
4909
4910 for (int i = 0; i < line_len; i++)
4911 {
4912 if (line_buf[i] == ':')
4913 {
4914 sep_cnt++;
4915
4916 continue;
4917 }
4918
4919 if (sep_cnt == 2) sep2_len++;
4920 if (sep_cnt == 3) sep3_len++;
4921 }
4922
4923 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4924
4925 return 0;
4926 }
4927
4928 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4929 {
4930 char *pos = NULL;
4931 int len = 0;
4932
4933 int sep_cnt = 0;
4934
4935 for (int i = 0; i < line_len; i++)
4936 {
4937 if (line_buf[i] == ':')
4938 {
4939 sep_cnt++;
4940
4941 continue;
4942 }
4943
4944 if (data.hash_mode == 1000)
4945 {
4946 if (sep_cnt == 3)
4947 {
4948 if (pos == NULL) pos = line_buf + i;
4949
4950 len++;
4951 }
4952 }
4953 else if (data.hash_mode == 3000)
4954 {
4955 if (sep_cnt == 2)
4956 {
4957 if (pos == NULL) pos = line_buf + i;
4958
4959 len++;
4960 }
4961 }
4962 }
4963
4964 *hashbuf_pos = pos;
4965 *hashbuf_len = len;
4966 }
4967
4968 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4969 {
4970 char *pos = NULL;
4971 int len = 0;
4972
4973 int sep_cnt = 0;
4974
4975 for (int i = 0; i < line_len; i++)
4976 {
4977 if (line_buf[i] == ':')
4978 {
4979 sep_cnt++;
4980
4981 continue;
4982 }
4983
4984 if (sep_cnt == 0)
4985 {
4986 if (pos == NULL) pos = line_buf + i;
4987
4988 len++;
4989 }
4990 }
4991
4992 *userbuf_pos = pos;
4993 *userbuf_len = len;
4994 }
4995
4996 // hlfmt passwd
4997
4998 static int hlfmt_detect_passwd (char *line_buf, int line_len)
4999 {
5000 int sep_cnt = 0;
5001
5002 char sep5_first = 0;
5003 char sep6_first = 0;
5004
5005 for (int i = 0; i < line_len; i++)
5006 {
5007 if (line_buf[i] == ':')
5008 {
5009 sep_cnt++;
5010
5011 continue;
5012 }
5013
5014 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5015 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5016 }
5017
5018 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5019
5020 return 0;
5021 }
5022
5023 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5024 {
5025 char *pos = NULL;
5026 int len = 0;
5027
5028 int sep_cnt = 0;
5029
5030 for (int i = 0; i < line_len; i++)
5031 {
5032 if (line_buf[i] == ':')
5033 {
5034 sep_cnt++;
5035
5036 continue;
5037 }
5038
5039 if (sep_cnt == 1)
5040 {
5041 if (pos == NULL) pos = line_buf + i;
5042
5043 len++;
5044 }
5045 }
5046
5047 *hashbuf_pos = pos;
5048 *hashbuf_len = len;
5049 }
5050
5051 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5052 {
5053 char *pos = NULL;
5054 int len = 0;
5055
5056 int sep_cnt = 0;
5057
5058 for (int i = 0; i < line_len; i++)
5059 {
5060 if (line_buf[i] == ':')
5061 {
5062 sep_cnt++;
5063
5064 continue;
5065 }
5066
5067 if (sep_cnt == 0)
5068 {
5069 if (pos == NULL) pos = line_buf + i;
5070
5071 len++;
5072 }
5073 }
5074
5075 *userbuf_pos = pos;
5076 *userbuf_len = len;
5077 }
5078
5079 // hlfmt shadow
5080
5081 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5082 {
5083 int sep_cnt = 0;
5084
5085 for (int i = 0; i < line_len; i++)
5086 {
5087 if (line_buf[i] == ':') sep_cnt++;
5088 }
5089
5090 if (sep_cnt == 8) return 1;
5091
5092 return 0;
5093 }
5094
5095 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5096 {
5097 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5098 }
5099
5100 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5101 {
5102 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5103 }
5104
5105 // hlfmt main
5106
5107 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5108 {
5109 switch (hashfile_format)
5110 {
5111 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5112 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5113 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5114 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5115 }
5116 }
5117
5118 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5119 {
5120 switch (hashfile_format)
5121 {
5122 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5123 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5124 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5125 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5126 }
5127 }
5128
5129 char *strhlfmt (const uint hashfile_format)
5130 {
5131 switch (hashfile_format)
5132 {
5133 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5134 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5135 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5136 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5137 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5138 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5139 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5140 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5141 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5142 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5143 }
5144
5145 return ((char *) "Unknown");
5146 }
5147
5148 static uint hlfmt_detect (FILE *fp, uint max_check)
5149 {
5150 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5151
5152 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5153 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5154
5155 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5156
5157 uint num_check = 0;
5158
5159 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5160
5161 while (!feof (fp))
5162 {
5163 int line_len = fgetl (fp, line_buf);
5164
5165 if (line_len == 0) continue;
5166
5167 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5168 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5169 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5170
5171 if (num_check == max_check) break;
5172
5173 num_check++;
5174 }
5175
5176 myfree (line_buf);
5177
5178 uint hashlist_format = HLFMT_HASHCAT;
5179
5180 for (int i = 1; i < HLFMTS_CNT; i++)
5181 {
5182 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5183
5184 hashlist_format = i;
5185 }
5186
5187 free (formats_cnt);
5188
5189 return hashlist_format;
5190 }
5191
5192 /**
5193 * some further helper function
5194 */
5195
5196 // wrapper around mymalloc for ADL
5197
5198 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5199 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5200 {
5201 return mymalloc (iSize);
5202 }
5203 #endif
5204
5205 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)
5206 {
5207 u64 collisions = 0;
5208
5209 const uint dgst_pos0 = data.dgst_pos0;
5210 const uint dgst_pos1 = data.dgst_pos1;
5211 const uint dgst_pos2 = data.dgst_pos2;
5212 const uint dgst_pos3 = data.dgst_pos3;
5213
5214 memset (bitmap_a, 0, bitmap_size);
5215 memset (bitmap_b, 0, bitmap_size);
5216 memset (bitmap_c, 0, bitmap_size);
5217 memset (bitmap_d, 0, bitmap_size);
5218
5219 for (uint i = 0; i < digests_cnt; i++)
5220 {
5221 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5222
5223 uint *digest_ptr = (uint *) digests_buf_ptr;
5224
5225 digests_buf_ptr += dgst_size;
5226
5227 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5228 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5229 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5230 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5231
5232 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5233 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5234 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5235 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5236
5237 if (bitmap_a[idx0] & val0) collisions++;
5238 if (bitmap_b[idx1] & val1) collisions++;
5239 if (bitmap_c[idx2] & val2) collisions++;
5240 if (bitmap_d[idx3] & val3) collisions++;
5241
5242 bitmap_a[idx0] |= val0;
5243 bitmap_b[idx1] |= val1;
5244 bitmap_c[idx2] |= val2;
5245 bitmap_d[idx3] |= val3;
5246
5247 if (collisions >= collisions_max) return 0x7fffffff;
5248 }
5249
5250 return collisions;
5251 }
5252
5253 /**
5254 * main
5255 */
5256
5257 int main (int argc, char **argv)
5258 {
5259 /**
5260 * To help users a bit
5261 */
5262
5263 char *compute = getenv ("COMPUTE");
5264
5265 if (compute)
5266 {
5267 static char display[100];
5268
5269 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5270
5271 putenv (display);
5272 }
5273 else
5274 {
5275 if (getenv ("DISPLAY") == NULL)
5276 putenv ((char *) "DISPLAY=:0");
5277 }
5278
5279 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5280 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5281
5282 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5283 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5284
5285 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5286 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5287
5288 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5289 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5290
5291 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5292 putenv ((char *) "POCL_KERNEL_CACHE=0");
5293
5294 umask (077);
5295
5296 /**
5297 * Real init
5298 */
5299
5300 memset (&data, 0, sizeof (hc_global_data_t));
5301
5302 time_t proc_start;
5303
5304 time (&proc_start);
5305
5306 data.proc_start = proc_start;
5307
5308 int myargc = argc;
5309 char **myargv = argv;
5310
5311 hc_thread_mutex_init (mux_dispatcher);
5312 hc_thread_mutex_init (mux_counter);
5313 hc_thread_mutex_init (mux_display);
5314 hc_thread_mutex_init (mux_adl);
5315
5316 /**
5317 * commandline parameters
5318 */
5319
5320 uint usage = USAGE;
5321 uint version = VERSION;
5322 uint quiet = QUIET;
5323 uint benchmark = BENCHMARK;
5324 uint show = SHOW;
5325 uint left = LEFT;
5326 uint username = USERNAME;
5327 uint remove = REMOVE;
5328 uint remove_timer = REMOVE_TIMER;
5329 u64 skip = SKIP;
5330 u64 limit = LIMIT;
5331 uint keyspace = KEYSPACE;
5332 uint potfile_disable = POTFILE_DISABLE;
5333 char *potfile_path = NULL;
5334 uint debug_mode = DEBUG_MODE;
5335 char *debug_file = NULL;
5336 char *induction_dir = NULL;
5337 char *outfile_check_dir = NULL;
5338 uint force = FORCE;
5339 uint runtime = RUNTIME;
5340 uint hash_mode = HASH_MODE;
5341 uint attack_mode = ATTACK_MODE;
5342 uint markov_disable = MARKOV_DISABLE;
5343 uint markov_classic = MARKOV_CLASSIC;
5344 uint markov_threshold = MARKOV_THRESHOLD;
5345 char *markov_hcstat = NULL;
5346 char *outfile = NULL;
5347 uint outfile_format = OUTFILE_FORMAT;
5348 uint outfile_autohex = OUTFILE_AUTOHEX;
5349 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5350 uint restore = RESTORE;
5351 uint restore_timer = RESTORE_TIMER;
5352 uint restore_disable = RESTORE_DISABLE;
5353 uint status = STATUS;
5354 uint status_timer = STATUS_TIMER;
5355 uint status_automate = STATUS_AUTOMATE;
5356 uint loopback = LOOPBACK;
5357 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5358 char *session = NULL;
5359 uint hex_charset = HEX_CHARSET;
5360 uint hex_salt = HEX_SALT;
5361 uint hex_wordlist = HEX_WORDLIST;
5362 uint rp_gen = RP_GEN;
5363 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5364 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5365 uint rp_gen_seed = RP_GEN_SEED;
5366 char *rule_buf_l = (char *) RULE_BUF_L;
5367 char *rule_buf_r = (char *) RULE_BUF_R;
5368 uint increment = INCREMENT;
5369 uint increment_min = INCREMENT_MIN;
5370 uint increment_max = INCREMENT_MAX;
5371 char *cpu_affinity = NULL;
5372 OCL_PTR *ocl = NULL;
5373 char *opencl_devices = NULL;
5374 char *opencl_platforms = NULL;
5375 char *opencl_device_types = NULL;
5376 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5377 char *truecrypt_keyfiles = NULL;
5378 char *veracrypt_keyfiles = NULL;
5379 uint veracrypt_pim = 0;
5380 uint workload_profile = WORKLOAD_PROFILE;
5381 uint kernel_accel = KERNEL_ACCEL;
5382 uint kernel_loops = KERNEL_LOOPS;
5383 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5384 #ifdef HAVE_HWMON
5385 uint gpu_temp_abort = GPU_TEMP_ABORT;
5386 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5387 #ifdef HAVE_ADL
5388 uint powertune_enable = POWERTUNE_ENABLE;
5389 #endif
5390 #endif
5391 uint logfile_disable = LOGFILE_DISABLE;
5392 uint segment_size = SEGMENT_SIZE;
5393 uint scrypt_tmto = SCRYPT_TMTO;
5394 char separator = SEPARATOR;
5395 uint bitmap_min = BITMAP_MIN;
5396 uint bitmap_max = BITMAP_MAX;
5397 char *custom_charset_1 = NULL;
5398 char *custom_charset_2 = NULL;
5399 char *custom_charset_3 = NULL;
5400 char *custom_charset_4 = NULL;
5401
5402 #define IDX_HELP 'h'
5403 #define IDX_VERSION 'V'
5404 #define IDX_VERSION_LOWER 'v'
5405 #define IDX_QUIET 0xff02
5406 #define IDX_SHOW 0xff03
5407 #define IDX_LEFT 0xff04
5408 #define IDX_REMOVE 0xff05
5409 #define IDX_REMOVE_TIMER 0xff37
5410 #define IDX_SKIP 's'
5411 #define IDX_LIMIT 'l'
5412 #define IDX_KEYSPACE 0xff35
5413 #define IDX_POTFILE_DISABLE 0xff06
5414 #define IDX_POTFILE_PATH 0xffe0
5415 #define IDX_DEBUG_MODE 0xff43
5416 #define IDX_DEBUG_FILE 0xff44
5417 #define IDX_INDUCTION_DIR 0xff46
5418 #define IDX_OUTFILE_CHECK_DIR 0xff47
5419 #define IDX_USERNAME 0xff07
5420 #define IDX_FORCE 0xff08
5421 #define IDX_RUNTIME 0xff09
5422 #define IDX_BENCHMARK 'b'
5423 #define IDX_HASH_MODE 'm'
5424 #define IDX_ATTACK_MODE 'a'
5425 #define IDX_RP_FILE 'r'
5426 #define IDX_RP_GEN 'g'
5427 #define IDX_RP_GEN_FUNC_MIN 0xff10
5428 #define IDX_RP_GEN_FUNC_MAX 0xff11
5429 #define IDX_RP_GEN_SEED 0xff34
5430 #define IDX_RULE_BUF_L 'j'
5431 #define IDX_RULE_BUF_R 'k'
5432 #define IDX_INCREMENT 'i'
5433 #define IDX_INCREMENT_MIN 0xff12
5434 #define IDX_INCREMENT_MAX 0xff13
5435 #define IDX_OUTFILE 'o'
5436 #define IDX_OUTFILE_FORMAT 0xff14
5437 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5438 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5439 #define IDX_RESTORE 0xff15
5440 #define IDX_RESTORE_DISABLE 0xff27
5441 #define IDX_STATUS 0xff17
5442 #define IDX_STATUS_TIMER 0xff18
5443 #define IDX_STATUS_AUTOMATE 0xff50
5444 #define IDX_LOOPBACK 0xff38
5445 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5446 #define IDX_SESSION 0xff19
5447 #define IDX_HEX_CHARSET 0xff20
5448 #define IDX_HEX_SALT 0xff21
5449 #define IDX_HEX_WORDLIST 0xff40
5450 #define IDX_MARKOV_DISABLE 0xff22
5451 #define IDX_MARKOV_CLASSIC 0xff23
5452 #define IDX_MARKOV_THRESHOLD 't'
5453 #define IDX_MARKOV_HCSTAT 0xff24
5454 #define IDX_CPU_AFFINITY 0xff25
5455 #define IDX_OPENCL_DEVICES 'd'
5456 #define IDX_OPENCL_PLATFORMS 0xff72
5457 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5458 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5459 #define IDX_WORKLOAD_PROFILE 'w'
5460 #define IDX_KERNEL_ACCEL 'n'
5461 #define IDX_KERNEL_LOOPS 'u'
5462 #define IDX_GPU_TEMP_DISABLE 0xff29
5463 #define IDX_GPU_TEMP_ABORT 0xff30
5464 #define IDX_GPU_TEMP_RETAIN 0xff31
5465 #define IDX_POWERTUNE_ENABLE 0xff41
5466 #define IDX_LOGFILE_DISABLE 0xff51
5467 #define IDX_TRUECRYPT_KEYFILES 0xff52
5468 #define IDX_VERACRYPT_KEYFILES 0xff53
5469 #define IDX_VERACRYPT_PIM 0xff54
5470 #define IDX_SCRYPT_TMTO 0xff61
5471 #define IDX_SEGMENT_SIZE 'c'
5472 #define IDX_SEPARATOR 'p'
5473 #define IDX_BITMAP_MIN 0xff70
5474 #define IDX_BITMAP_MAX 0xff71
5475 #define IDX_CUSTOM_CHARSET_1 '1'
5476 #define IDX_CUSTOM_CHARSET_2 '2'
5477 #define IDX_CUSTOM_CHARSET_3 '3'
5478 #define IDX_CUSTOM_CHARSET_4 '4'
5479
5480 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5481
5482 struct option long_options[] =
5483 {
5484 {"help", no_argument, 0, IDX_HELP},
5485 {"version", no_argument, 0, IDX_VERSION},
5486 {"quiet", no_argument, 0, IDX_QUIET},
5487 {"show", no_argument, 0, IDX_SHOW},
5488 {"left", no_argument, 0, IDX_LEFT},
5489 {"username", no_argument, 0, IDX_USERNAME},
5490 {"remove", no_argument, 0, IDX_REMOVE},
5491 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5492 {"skip", required_argument, 0, IDX_SKIP},
5493 {"limit", required_argument, 0, IDX_LIMIT},
5494 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5495 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5496 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5497 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5498 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5499 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5500 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5501 {"force", no_argument, 0, IDX_FORCE},
5502 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5503 {"restore", no_argument, 0, IDX_RESTORE},
5504 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5505 {"status", no_argument, 0, IDX_STATUS},
5506 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5507 {"status-automate", no_argument, 0, IDX_STATUS_AUTOMATE},
5508 {"loopback", no_argument, 0, IDX_LOOPBACK},
5509 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5510 {"session", required_argument, 0, IDX_SESSION},
5511 {"runtime", required_argument, 0, IDX_RUNTIME},
5512 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5513 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5514 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5515 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5516 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5517 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5518 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5519 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5520 {"rules-file", required_argument, 0, IDX_RP_FILE},
5521 {"outfile", required_argument, 0, IDX_OUTFILE},
5522 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5523 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5524 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5525 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5526 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5527 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5528 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5529 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5530 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5531 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5532 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5533 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5534 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5535 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5536 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5537 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5538 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5539 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5540 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5541 #ifdef HAVE_HWMON
5542 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5543 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5544 #ifdef HAVE_ADL
5545 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5546 #endif
5547 #endif // HAVE_HWMON
5548 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5549 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5550 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5551 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5552 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5553 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5554 {"seperator", required_argument, 0, IDX_SEPARATOR},
5555 {"separator", required_argument, 0, IDX_SEPARATOR},
5556 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5557 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5558 {"increment", no_argument, 0, IDX_INCREMENT},
5559 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5560 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5561 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5562 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5563 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5564 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5565 {0, 0, 0, 0}
5566 };
5567
5568 uint rp_files_cnt = 0;
5569
5570 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5571
5572 int option_index = 0;
5573 int c = -1;
5574
5575 optind = 1;
5576 optopt = 0;
5577
5578 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5579 {
5580 switch (c)
5581 {
5582 case IDX_HELP: usage = 1; break;
5583 case IDX_VERSION:
5584 case IDX_VERSION_LOWER: version = 1; break;
5585 case IDX_RESTORE: restore = 1; break;
5586 case IDX_SESSION: session = optarg; break;
5587 case IDX_SHOW: show = 1; break;
5588 case IDX_LEFT: left = 1; break;
5589 case '?': return (-1);
5590 }
5591 }
5592
5593 if (optopt != 0)
5594 {
5595 log_error ("ERROR: Invalid argument specified");
5596
5597 return (-1);
5598 }
5599
5600 /**
5601 * exit functions
5602 */
5603
5604 if (version)
5605 {
5606 log_info ("%s", VERSION_TAG);
5607
5608 return (0);
5609 }
5610
5611 if (usage)
5612 {
5613 usage_big_print (PROGNAME);
5614
5615 return (0);
5616 }
5617
5618 /**
5619 * session needs to be set, always!
5620 */
5621
5622 if (session == NULL) session = (char *) PROGNAME;
5623
5624 /**
5625 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5626 */
5627
5628 char *exec_path = get_exec_path ();
5629
5630 #ifdef LINUX
5631
5632 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5633 char *resolved_exec_path = realpath (exec_path, NULL);
5634
5635 char *install_dir = get_install_dir (resolved_exec_path);
5636 char *profile_dir = NULL;
5637 char *session_dir = NULL;
5638 char *shared_dir = NULL;
5639
5640 if (strcmp (install_dir, resolved_install_folder) == 0)
5641 {
5642 struct passwd *pw = getpwuid (getuid ());
5643
5644 const char *homedir = pw->pw_dir;
5645
5646 profile_dir = get_profile_dir (homedir);
5647 session_dir = get_session_dir (profile_dir);
5648 shared_dir = strdup (SHARED_FOLDER);
5649
5650 mkdir (profile_dir, 0700);
5651 mkdir (session_dir, 0700);
5652 }
5653 else
5654 {
5655 profile_dir = install_dir;
5656 session_dir = install_dir;
5657 shared_dir = install_dir;
5658 }
5659
5660 myfree (resolved_install_folder);
5661 myfree (resolved_exec_path);
5662
5663 #else
5664
5665 char *install_dir = get_install_dir (exec_path);
5666 char *profile_dir = install_dir;
5667 char *session_dir = install_dir;
5668 char *shared_dir = install_dir;
5669
5670 #endif
5671
5672 data.install_dir = install_dir;
5673 data.profile_dir = profile_dir;
5674 data.session_dir = session_dir;
5675 data.shared_dir = shared_dir;
5676
5677 myfree (exec_path);
5678
5679 /**
5680 * kernel cache, we need to make sure folder exist
5681 */
5682
5683 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5684
5685 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5686
5687 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5688
5689 mkdir (kernels_folder, 0700);
5690
5691 myfree (kernels_folder);
5692
5693 /**
5694 * session
5695 */
5696
5697 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5698
5699 data.session = session;
5700
5701 char *eff_restore_file = (char *) mymalloc (session_size);
5702 char *new_restore_file = (char *) mymalloc (session_size);
5703
5704 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5705 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5706
5707 data.eff_restore_file = eff_restore_file;
5708 data.new_restore_file = new_restore_file;
5709
5710 if (((show == 1) || (left == 1)) && (restore == 1))
5711 {
5712 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5713 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5714
5715 return (-1);
5716 }
5717
5718 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5719 if ((show == 1) || (left == 1))
5720 {
5721 restore_disable = 1;
5722
5723 restore = 0;
5724 }
5725
5726 data.restore_disable = restore_disable;
5727
5728 restore_data_t *rd = init_restore (argc, argv);
5729
5730 data.rd = rd;
5731
5732 /**
5733 * restore file
5734 */
5735
5736 if (restore == 1)
5737 {
5738 read_restore (eff_restore_file, rd);
5739
5740 if (rd->version_bin < RESTORE_MIN)
5741 {
5742 log_error ("ERROR: Incompatible restore-file version");
5743
5744 return (-1);
5745 }
5746
5747 myargc = rd->argc;
5748 myargv = rd->argv;
5749
5750 #ifdef _POSIX
5751 rd->pid = getpid ();
5752 #elif _WIN
5753 rd->pid = GetCurrentProcessId ();
5754 #endif
5755 }
5756
5757 uint hash_mode_chgd = 0;
5758 uint runtime_chgd = 0;
5759 uint kernel_loops_chgd = 0;
5760 uint kernel_accel_chgd = 0;
5761 uint attack_mode_chgd = 0;
5762 uint outfile_format_chgd = 0;
5763 uint rp_gen_seed_chgd = 0;
5764 uint remove_timer_chgd = 0;
5765 uint increment_min_chgd = 0;
5766 uint increment_max_chgd = 0;
5767 uint workload_profile_chgd = 0;
5768 uint opencl_vector_width_chgd = 0;
5769
5770 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5771 uint gpu_temp_retain_chgd = 0;
5772 uint gpu_temp_abort_chgd = 0;
5773 #endif
5774
5775 optind = 1;
5776 optopt = 0;
5777 option_index = 0;
5778
5779 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5780 {
5781 switch (c)
5782 {
5783 //case IDX_HELP: usage = 1; break;
5784 //case IDX_VERSION: version = 1; break;
5785 //case IDX_RESTORE: restore = 1; break;
5786 case IDX_QUIET: quiet = 1; break;
5787 //case IDX_SHOW: show = 1; break;
5788 case IDX_SHOW: break;
5789 //case IDX_LEFT: left = 1; break;
5790 case IDX_LEFT: break;
5791 case IDX_USERNAME: username = 1; break;
5792 case IDX_REMOVE: remove = 1; break;
5793 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5794 remove_timer_chgd = 1; break;
5795 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5796 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5797 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5798 case IDX_DEBUG_FILE: debug_file = optarg; break;
5799 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5800 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5801 case IDX_FORCE: force = 1; break;
5802 case IDX_SKIP: skip = atoll (optarg); break;
5803 case IDX_LIMIT: limit = atoll (optarg); break;
5804 case IDX_KEYSPACE: keyspace = 1; break;
5805 case IDX_BENCHMARK: benchmark = 1; break;
5806 case IDX_RESTORE: break;
5807 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5808 case IDX_STATUS: status = 1; break;
5809 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5810 case IDX_STATUS_AUTOMATE: status_automate = 1; break;
5811 case IDX_LOOPBACK: loopback = 1; break;
5812 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5813 //case IDX_SESSION: session = optarg; break;
5814 case IDX_SESSION: break;
5815 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5816 hash_mode_chgd = 1; break;
5817 case IDX_RUNTIME: runtime = atoi (optarg);
5818 runtime_chgd = 1; break;
5819 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5820 attack_mode_chgd = 1; break;
5821 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5822 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5823 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5824 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5825 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5826 rp_gen_seed_chgd = 1; break;
5827 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5828 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5829 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5830 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5831 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5832 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5833 case IDX_OUTFILE: outfile = optarg; break;
5834 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5835 outfile_format_chgd = 1; break;
5836 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
5837 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
5838 case IDX_HEX_CHARSET: hex_charset = 1; break;
5839 case IDX_HEX_SALT: hex_salt = 1; break;
5840 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5841 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5842 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5843 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5844 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
5845 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
5846 opencl_vector_width_chgd = 1; break;
5847 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5848 workload_profile_chgd = 1; break;
5849 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5850 kernel_accel_chgd = 1; break;
5851 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5852 kernel_loops_chgd = 1; break;
5853 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5854 #ifdef HAVE_HWMON
5855 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5856 #ifdef HAVE_ADL
5857 gpu_temp_abort_chgd = 1;
5858 #endif
5859 break;
5860 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5861 #ifdef HAVE_ADL
5862 gpu_temp_retain_chgd = 1;
5863 #endif
5864 break;
5865 #ifdef HAVE_ADL
5866 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5867 #endif
5868 #endif // HAVE_HWMON
5869 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5870 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5871 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
5872 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
5873 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5874 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5875 case IDX_SEPARATOR: separator = optarg[0]; break;
5876 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5877 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5878 case IDX_INCREMENT: increment = 1; break;
5879 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5880 increment_min_chgd = 1; break;
5881 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5882 increment_max_chgd = 1; break;
5883 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5884 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5885 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5886 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5887
5888 default:
5889 log_error ("ERROR: Invalid argument specified");
5890 return (-1);
5891 }
5892 }
5893
5894 if (optopt != 0)
5895 {
5896 log_error ("ERROR: Invalid argument specified");
5897
5898 return (-1);
5899 }
5900
5901 /**
5902 * Inform user things getting started,
5903 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5904 * - we do not need to check algorithm_pos
5905 */
5906
5907 if (quiet == 0)
5908 {
5909 if (benchmark == 1)
5910 {
5911 if (status_automate == 0)
5912 {
5913 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5914 log_info ("");
5915 }
5916 else
5917 {
5918 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
5919 }
5920 }
5921 else if (restore == 1)
5922 {
5923 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5924 log_info ("");
5925 }
5926 else
5927 {
5928 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5929 log_info ("");
5930 }
5931 }
5932
5933 /**
5934 * sanity check
5935 */
5936
5937 if (attack_mode > 7)
5938 {
5939 log_error ("ERROR: Invalid attack-mode specified");
5940
5941 return (-1);
5942 }
5943
5944 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5945 {
5946 log_error ("ERROR: Invalid runtime specified");
5947
5948 return (-1);
5949 }
5950
5951 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
5952 {
5953 log_error ("ERROR: Invalid hash-type specified");
5954
5955 return (-1);
5956 }
5957
5958 // renamed hash modes
5959
5960 if (hash_mode_chgd)
5961 {
5962 int n = -1;
5963
5964 switch (hash_mode)
5965 {
5966 case 123: n = 124;
5967 break;
5968 }
5969
5970 if (n >= 0)
5971 {
5972 log_error ("Old -m specified, use -m %d instead", n);
5973
5974 return (-1);
5975 }
5976 }
5977
5978 if (username == 1)
5979 {
5980 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
5981 {
5982 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5983
5984 return (-1);
5985 }
5986 }
5987
5988 if (outfile_format > 16)
5989 {
5990 log_error ("ERROR: Invalid outfile-format specified");
5991
5992 return (-1);
5993 }
5994
5995 if (left == 1)
5996 {
5997 if (outfile_format_chgd == 1)
5998 {
5999 if (outfile_format > 1)
6000 {
6001 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6002
6003 return (-1);
6004 }
6005 }
6006 else
6007 {
6008 outfile_format = OUTFILE_FMT_HASH;
6009 }
6010 }
6011
6012 if (show == 1)
6013 {
6014 if (outfile_format_chgd == 1)
6015 {
6016 if ((outfile_format > 7) && (outfile_format < 16))
6017 {
6018 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6019
6020 return (-1);
6021 }
6022 }
6023 }
6024
6025 if (increment_min < INCREMENT_MIN)
6026 {
6027 log_error ("ERROR: Invalid increment-min specified");
6028
6029 return (-1);
6030 }
6031
6032 if (increment_max > INCREMENT_MAX)
6033 {
6034 log_error ("ERROR: Invalid increment-max specified");
6035
6036 return (-1);
6037 }
6038
6039 if (increment_min > increment_max)
6040 {
6041 log_error ("ERROR: Invalid increment-min specified");
6042
6043 return (-1);
6044 }
6045
6046 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6047 {
6048 log_error ("ERROR: increment is not allowed in attack-mode 0");
6049
6050 return (-1);
6051 }
6052
6053 if ((increment == 0) && (increment_min_chgd == 1))
6054 {
6055 log_error ("ERROR: increment-min is only supported together with increment switch");
6056
6057 return (-1);
6058 }
6059
6060 if ((increment == 0) && (increment_max_chgd == 1))
6061 {
6062 log_error ("ERROR: increment-max is only supported together with increment switch");
6063
6064 return (-1);
6065 }
6066
6067 if (rp_files_cnt && rp_gen)
6068 {
6069 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6070
6071 return (-1);
6072 }
6073
6074 if (rp_files_cnt || rp_gen)
6075 {
6076 if (attack_mode != ATTACK_MODE_STRAIGHT)
6077 {
6078 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6079
6080 return (-1);
6081 }
6082 }
6083
6084 if (rp_gen_func_min > rp_gen_func_max)
6085 {
6086 log_error ("ERROR: Invalid rp-gen-func-min specified");
6087
6088 return (-1);
6089 }
6090
6091 if (kernel_accel_chgd == 1)
6092 {
6093 if (force == 0)
6094 {
6095 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6096 log_info ("Please consider using the option -w instead");
6097 log_info ("You can use --force to override this but do not post error reports if you do so");
6098 log_info ("");
6099
6100 return (-1);
6101 }
6102
6103 if (kernel_accel < 1)
6104 {
6105 log_error ("ERROR: Invalid kernel-accel specified");
6106
6107 return (-1);
6108 }
6109
6110 if (kernel_accel > 1024)
6111 {
6112 log_error ("ERROR: Invalid kernel-accel specified");
6113
6114 return (-1);
6115 }
6116 }
6117
6118 if (kernel_loops_chgd == 1)
6119 {
6120 if (force == 0)
6121 {
6122 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6123 log_info ("Please consider using the option -w instead");
6124 log_info ("You can use --force to override this but do not post error reports if you do so");
6125 log_info ("");
6126
6127 return (-1);
6128 }
6129
6130 if (kernel_loops < 1)
6131 {
6132 log_error ("ERROR: Invalid kernel-loops specified");
6133
6134 return (-1);
6135 }
6136
6137 if (kernel_loops > 1024)
6138 {
6139 log_error ("ERROR: Invalid kernel-loops specified");
6140
6141 return (-1);
6142 }
6143 }
6144
6145 if ((workload_profile < 1) || (workload_profile > 4))
6146 {
6147 log_error ("ERROR: workload-profile %i not available", workload_profile);
6148
6149 return (-1);
6150 }
6151
6152 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6153 {
6154 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6155
6156 return (-1);
6157 }
6158
6159 if (show == 1 || left == 1)
6160 {
6161 attack_mode = ATTACK_MODE_NONE;
6162
6163 if (remove == 1)
6164 {
6165 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6166
6167 return (-1);
6168 }
6169
6170 if (potfile_disable == 1)
6171 {
6172 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6173
6174 return (-1);
6175 }
6176 }
6177
6178 uint attack_kern = ATTACK_KERN_NONE;
6179
6180 switch (attack_mode)
6181 {
6182 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6183 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6184 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6185 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6186 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6187 }
6188
6189 if (benchmark == 0)
6190 {
6191 if (keyspace == 1)
6192 {
6193 int num_additional_params = 1;
6194
6195 if (attack_kern == ATTACK_KERN_COMBI)
6196 {
6197 num_additional_params = 2;
6198 }
6199
6200 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6201
6202 if (keyspace_wordlist_specified == 0) optind--;
6203 }
6204
6205 if (attack_kern == ATTACK_KERN_NONE)
6206 {
6207 if ((optind + 1) != myargc)
6208 {
6209 usage_mini_print (myargv[0]);
6210
6211 return (-1);
6212 }
6213 }
6214 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6215 {
6216 if ((optind + 1) > myargc)
6217 {
6218 usage_mini_print (myargv[0]);
6219
6220 return (-1);
6221 }
6222 }
6223 else if (attack_kern == ATTACK_KERN_COMBI)
6224 {
6225 if ((optind + 3) != myargc)
6226 {
6227 usage_mini_print (myargv[0]);
6228
6229 return (-1);
6230 }
6231 }
6232 else if (attack_kern == ATTACK_KERN_BF)
6233 {
6234 if ((optind + 1) > myargc)
6235 {
6236 usage_mini_print (myargv[0]);
6237
6238 return (-1);
6239 }
6240 }
6241 else
6242 {
6243 usage_mini_print (myargv[0]);
6244
6245 return (-1);
6246 }
6247 }
6248 else
6249 {
6250 if (myargv[optind] != 0)
6251 {
6252 log_error ("ERROR: Invalid argument for benchmark mode specified");
6253
6254 return (-1);
6255 }
6256
6257 if (attack_mode_chgd == 1)
6258 {
6259 if (attack_mode != ATTACK_MODE_BF)
6260 {
6261 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6262
6263 return (-1);
6264 }
6265 }
6266 }
6267
6268 if (skip != 0 && limit != 0)
6269 {
6270 limit += skip;
6271 }
6272
6273 if (keyspace == 1)
6274 {
6275 if (show == 1)
6276 {
6277 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6278
6279 return (-1);
6280 }
6281 else if (left == 1)
6282 {
6283 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6284
6285 return (-1);
6286 }
6287
6288 potfile_disable = 1;
6289
6290 restore_disable = 1;
6291
6292 restore = 0;
6293
6294 weak_hash_threshold = 0;
6295
6296 quiet = 1;
6297 }
6298
6299 if (remove_timer_chgd == 1)
6300 {
6301 if (remove == 0)
6302 {
6303 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6304
6305 return (-1);
6306 }
6307
6308 if (remove_timer < 1)
6309 {
6310 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6311
6312 return (-1);
6313 }
6314 }
6315
6316 if (loopback == 1)
6317 {
6318 if (attack_mode == ATTACK_MODE_STRAIGHT)
6319 {
6320 if ((rp_files_cnt == 0) && (rp_gen == 0))
6321 {
6322 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6323
6324 return (-1);
6325 }
6326 }
6327 else
6328 {
6329 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6330
6331 return (-1);
6332 }
6333 }
6334
6335 if (debug_mode > 0)
6336 {
6337 if (attack_mode != ATTACK_MODE_STRAIGHT)
6338 {
6339 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6340
6341 return (-1);
6342 }
6343
6344 if ((rp_files_cnt == 0) && (rp_gen == 0))
6345 {
6346 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6347
6348 return (-1);
6349 }
6350 }
6351
6352 if (debug_mode > 4)
6353 {
6354 log_error ("ERROR: Invalid debug-mode specified");
6355
6356 return (-1);
6357 }
6358
6359 if (debug_file != NULL)
6360 {
6361 if (debug_mode < 1)
6362 {
6363 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6364
6365 return (-1);
6366 }
6367 }
6368
6369 if (induction_dir != NULL)
6370 {
6371 if (attack_mode == ATTACK_MODE_BF)
6372 {
6373 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6374
6375 return (-1);
6376 }
6377 }
6378
6379 if (attack_mode != ATTACK_MODE_STRAIGHT)
6380 {
6381 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6382 {
6383 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6384
6385 return (-1);
6386 }
6387
6388 weak_hash_threshold = 0;
6389 }
6390
6391 /**
6392 * induction directory
6393 */
6394
6395 char *induction_directory = NULL;
6396
6397 if (attack_mode != ATTACK_MODE_BF)
6398 {
6399 if (induction_dir == NULL)
6400 {
6401 induction_directory = (char *) mymalloc (session_size);
6402
6403 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6404
6405 // create induction folder if it does not already exist
6406
6407 if (keyspace == 0)
6408 {
6409 if (rmdir (induction_directory) == -1)
6410 {
6411 if (errno == ENOENT)
6412 {
6413 // good, we can ignore
6414 }
6415 else if (errno == ENOTEMPTY)
6416 {
6417 char *induction_directory_mv = (char *) mymalloc (session_size);
6418
6419 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6420
6421 if (rename (induction_directory, induction_directory_mv) != 0)
6422 {
6423 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6424
6425 return (-1);
6426 }
6427 }
6428 else
6429 {
6430 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6431
6432 return (-1);
6433 }
6434 }
6435
6436 if (mkdir (induction_directory, 0700) == -1)
6437 {
6438 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6439
6440 return (-1);
6441 }
6442 }
6443 }
6444 else
6445 {
6446 induction_directory = induction_dir;
6447 }
6448 }
6449
6450 data.induction_directory = induction_directory;
6451
6452 /**
6453 * loopback
6454 */
6455
6456 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6457
6458 char *loopback_file = (char *) mymalloc (loopback_size);
6459
6460 /**
6461 * tuning db
6462 */
6463
6464 char tuning_db_file[256] = { 0 };
6465
6466 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6467
6468 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6469
6470 /**
6471 * outfile-check directory
6472 */
6473
6474 char *outfile_check_directory = NULL;
6475
6476 if (outfile_check_dir == NULL)
6477 {
6478 outfile_check_directory = (char *) mymalloc (session_size);
6479
6480 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6481 }
6482 else
6483 {
6484 outfile_check_directory = outfile_check_dir;
6485 }
6486
6487 data.outfile_check_directory = outfile_check_directory;
6488
6489 if (keyspace == 0)
6490 {
6491 struct stat outfile_check_stat;
6492
6493 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6494 {
6495 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6496
6497 if (is_dir == 0)
6498 {
6499 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6500
6501 return (-1);
6502 }
6503 }
6504 else if (outfile_check_dir == NULL)
6505 {
6506 if (mkdir (outfile_check_directory, 0700) == -1)
6507 {
6508 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6509
6510 return (-1);
6511 }
6512 }
6513 }
6514
6515 /**
6516 * special other stuff
6517 */
6518
6519 if (hash_mode == 9710)
6520 {
6521 outfile_format = 5;
6522 outfile_format_chgd = 1;
6523 }
6524
6525 if (hash_mode == 9810)
6526 {
6527 outfile_format = 5;
6528 outfile_format_chgd = 1;
6529 }
6530
6531 if (hash_mode == 10410)
6532 {
6533 outfile_format = 5;
6534 outfile_format_chgd = 1;
6535 }
6536
6537 /**
6538 * store stuff
6539 */
6540
6541 data.hash_mode = hash_mode;
6542 data.restore = restore;
6543 data.restore_timer = restore_timer;
6544 data.restore_disable = restore_disable;
6545 data.status = status;
6546 data.status_timer = status_timer;
6547 data.status_automate = status_automate;
6548 data.loopback = loopback;
6549 data.runtime = runtime;
6550 data.remove = remove;
6551 data.remove_timer = remove_timer;
6552 data.debug_mode = debug_mode;
6553 data.debug_file = debug_file;
6554 data.username = username;
6555 data.quiet = quiet;
6556 data.outfile = outfile;
6557 data.outfile_format = outfile_format;
6558 data.outfile_autohex = outfile_autohex;
6559 data.hex_charset = hex_charset;
6560 data.hex_salt = hex_salt;
6561 data.hex_wordlist = hex_wordlist;
6562 data.separator = separator;
6563 data.rp_files = rp_files;
6564 data.rp_files_cnt = rp_files_cnt;
6565 data.rp_gen = rp_gen;
6566 data.rp_gen_seed = rp_gen_seed;
6567 data.force = force;
6568 data.benchmark = benchmark;
6569 data.skip = skip;
6570 data.limit = limit;
6571 #ifdef HAVE_HWMON
6572 #ifdef HAVE_ADL
6573 data.powertune_enable = powertune_enable;
6574 #endif
6575 #endif
6576 data.logfile_disable = logfile_disable;
6577 data.truecrypt_keyfiles = truecrypt_keyfiles;
6578 data.veracrypt_keyfiles = veracrypt_keyfiles;
6579 data.veracrypt_pim = veracrypt_pim;
6580 data.scrypt_tmto = scrypt_tmto;
6581 data.workload_profile = workload_profile;
6582
6583 /**
6584 * cpu affinity
6585 */
6586
6587 if (cpu_affinity)
6588 {
6589 set_cpu_affinity (cpu_affinity);
6590 }
6591
6592 if (rp_gen_seed_chgd == 0)
6593 {
6594 srand (proc_start);
6595 }
6596 else
6597 {
6598 srand (rp_gen_seed);
6599 }
6600
6601 /**
6602 * logfile init
6603 */
6604
6605 if (logfile_disable == 0)
6606 {
6607 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6608
6609 char *logfile = (char *) mymalloc (logfile_size);
6610
6611 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6612
6613 data.logfile = logfile;
6614
6615 char *topid = logfile_generate_topid ();
6616
6617 data.topid = topid;
6618 }
6619
6620 // logfile_append() checks for logfile_disable internally to make it easier from here
6621
6622 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6623 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6624 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6625 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6626 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6627 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6628 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6629 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6630 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6631 #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));
6632
6633 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6634 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6635 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6636 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6637 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6638 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6639 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6640 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6641
6642 logfile_top_msg ("START");
6643
6644 logfile_top_uint (attack_mode);
6645 logfile_top_uint (attack_kern);
6646 logfile_top_uint (benchmark);
6647 logfile_top_uint (bitmap_min);
6648 logfile_top_uint (bitmap_max);
6649 logfile_top_uint (debug_mode);
6650 logfile_top_uint (force);
6651 logfile_top_uint (kernel_accel);
6652 logfile_top_uint (kernel_loops);
6653 logfile_top_uint (gpu_temp_disable);
6654 #ifdef HAVE_HWMON
6655 logfile_top_uint (gpu_temp_abort);
6656 logfile_top_uint (gpu_temp_retain);
6657 #endif
6658 logfile_top_uint (hash_mode);
6659 logfile_top_uint (hex_charset);
6660 logfile_top_uint (hex_salt);
6661 logfile_top_uint (hex_wordlist);
6662 logfile_top_uint (increment);
6663 logfile_top_uint (increment_max);
6664 logfile_top_uint (increment_min);
6665 logfile_top_uint (keyspace);
6666 logfile_top_uint (left);
6667 logfile_top_uint (logfile_disable);
6668 logfile_top_uint (loopback);
6669 logfile_top_uint (markov_classic);
6670 logfile_top_uint (markov_disable);
6671 logfile_top_uint (markov_threshold);
6672 logfile_top_uint (outfile_autohex);
6673 logfile_top_uint (outfile_check_timer);
6674 logfile_top_uint (outfile_format);
6675 logfile_top_uint (potfile_disable);
6676 logfile_top_string (potfile_path);
6677 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6678 logfile_top_uint (powertune_enable);
6679 #endif
6680 logfile_top_uint (scrypt_tmto);
6681 logfile_top_uint (quiet);
6682 logfile_top_uint (remove);
6683 logfile_top_uint (remove_timer);
6684 logfile_top_uint (restore);
6685 logfile_top_uint (restore_disable);
6686 logfile_top_uint (restore_timer);
6687 logfile_top_uint (rp_gen);
6688 logfile_top_uint (rp_gen_func_max);
6689 logfile_top_uint (rp_gen_func_min);
6690 logfile_top_uint (rp_gen_seed);
6691 logfile_top_uint (runtime);
6692 logfile_top_uint (segment_size);
6693 logfile_top_uint (show);
6694 logfile_top_uint (status);
6695 logfile_top_uint (status_automate);
6696 logfile_top_uint (status_timer);
6697 logfile_top_uint (usage);
6698 logfile_top_uint (username);
6699 logfile_top_uint (version);
6700 logfile_top_uint (weak_hash_threshold);
6701 logfile_top_uint (workload_profile);
6702 logfile_top_uint64 (limit);
6703 logfile_top_uint64 (skip);
6704 logfile_top_char (separator);
6705 logfile_top_string (cpu_affinity);
6706 logfile_top_string (custom_charset_1);
6707 logfile_top_string (custom_charset_2);
6708 logfile_top_string (custom_charset_3);
6709 logfile_top_string (custom_charset_4);
6710 logfile_top_string (debug_file);
6711 logfile_top_string (opencl_devices);
6712 logfile_top_string (opencl_platforms);
6713 logfile_top_string (opencl_device_types);
6714 logfile_top_uint (opencl_vector_width);
6715 logfile_top_string (induction_dir);
6716 logfile_top_string (markov_hcstat);
6717 logfile_top_string (outfile);
6718 logfile_top_string (outfile_check_dir);
6719 logfile_top_string (rule_buf_l);
6720 logfile_top_string (rule_buf_r);
6721 logfile_top_string (session);
6722 logfile_top_string (truecrypt_keyfiles);
6723 logfile_top_string (veracrypt_keyfiles);
6724 logfile_top_uint (veracrypt_pim);
6725
6726 /**
6727 * Init OpenCL library loader
6728 */
6729
6730 if (keyspace == 0)
6731 {
6732 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6733
6734 ocl_init (ocl);
6735
6736 data.ocl = ocl;
6737 }
6738
6739 /**
6740 * OpenCL platform selection
6741 */
6742
6743 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6744
6745 /**
6746 * OpenCL device selection
6747 */
6748
6749 u32 devices_filter = setup_devices_filter (opencl_devices);
6750
6751 /**
6752 * OpenCL device type selection
6753 */
6754
6755 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6756
6757 /**
6758 * benchmark
6759 */
6760
6761 if (benchmark == 1)
6762 {
6763 /**
6764 * disable useless stuff for benchmark
6765 */
6766
6767 status_timer = 0;
6768 restore_timer = 0;
6769 restore_disable = 1;
6770 potfile_disable = 1;
6771 weak_hash_threshold = 0;
6772 gpu_temp_disable = 1;
6773
6774 data.status_timer = status_timer;
6775 data.restore_timer = restore_timer;
6776 data.restore_disable = restore_disable;
6777
6778 /**
6779 * force attack mode to be bruteforce
6780 */
6781
6782 attack_mode = ATTACK_MODE_BF;
6783 attack_kern = ATTACK_KERN_BF;
6784
6785 if (workload_profile_chgd == 0)
6786 {
6787 workload_profile = 3;
6788
6789 data.workload_profile = workload_profile;
6790 }
6791 }
6792
6793 /**
6794 * config
6795 */
6796
6797 uint hash_type = 0;
6798 uint salt_type = 0;
6799 uint attack_exec = 0;
6800 uint opts_type = 0;
6801 uint kern_type = 0;
6802 uint dgst_size = 0;
6803 uint esalt_size = 0;
6804 uint opti_type = 0;
6805 uint dgst_pos0 = -1;
6806 uint dgst_pos1 = -1;
6807 uint dgst_pos2 = -1;
6808 uint dgst_pos3 = -1;
6809
6810 int (*parse_func) (char *, uint, hash_t *);
6811 int (*sort_by_digest) (const void *, const void *);
6812
6813 uint algorithm_pos = 0;
6814 uint algorithm_max = 1;
6815
6816 uint *algorithms = default_benchmark_algorithms;
6817
6818 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6819
6820 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6821 {
6822 /*
6823 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6824 * the following algos are skipped entirely
6825 */
6826
6827 if (algorithm_pos > 0)
6828 {
6829 local_free (rd);
6830
6831 rd = init_restore (argc, argv);
6832
6833 data.rd = rd;
6834 }
6835
6836 /**
6837 * update hash_mode in case of multihash benchmark
6838 */
6839
6840 if (benchmark == 1)
6841 {
6842 if (hash_mode_chgd == 0)
6843 {
6844 hash_mode = algorithms[algorithm_pos];
6845
6846 data.hash_mode = hash_mode;
6847 }
6848
6849 quiet = 1;
6850
6851 data.quiet = quiet;
6852 }
6853
6854 switch (hash_mode)
6855 {
6856 case 0: hash_type = HASH_TYPE_MD5;
6857 salt_type = SALT_TYPE_NONE;
6858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6859 opts_type = OPTS_TYPE_PT_GENERATE_LE
6860 | OPTS_TYPE_PT_ADD80
6861 | OPTS_TYPE_PT_ADDBITS14;
6862 kern_type = KERN_TYPE_MD5;
6863 dgst_size = DGST_SIZE_4_4;
6864 parse_func = md5_parse_hash;
6865 sort_by_digest = sort_by_digest_4_4;
6866 opti_type = OPTI_TYPE_ZERO_BYTE
6867 | OPTI_TYPE_PRECOMPUTE_INIT
6868 | OPTI_TYPE_PRECOMPUTE_MERKLE
6869 | OPTI_TYPE_MEET_IN_MIDDLE
6870 | OPTI_TYPE_EARLY_SKIP
6871 | OPTI_TYPE_NOT_ITERATED
6872 | OPTI_TYPE_NOT_SALTED
6873 | OPTI_TYPE_RAW_HASH;
6874 dgst_pos0 = 0;
6875 dgst_pos1 = 3;
6876 dgst_pos2 = 2;
6877 dgst_pos3 = 1;
6878 break;
6879
6880 case 10: hash_type = HASH_TYPE_MD5;
6881 salt_type = SALT_TYPE_INTERN;
6882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6883 opts_type = OPTS_TYPE_PT_GENERATE_LE
6884 | OPTS_TYPE_ST_ADD80
6885 | OPTS_TYPE_ST_ADDBITS14;
6886 kern_type = KERN_TYPE_MD5_PWSLT;
6887 dgst_size = DGST_SIZE_4_4;
6888 parse_func = md5s_parse_hash;
6889 sort_by_digest = sort_by_digest_4_4;
6890 opti_type = OPTI_TYPE_ZERO_BYTE
6891 | OPTI_TYPE_PRECOMPUTE_INIT
6892 | OPTI_TYPE_PRECOMPUTE_MERKLE
6893 | OPTI_TYPE_MEET_IN_MIDDLE
6894 | OPTI_TYPE_EARLY_SKIP
6895 | OPTI_TYPE_NOT_ITERATED
6896 | OPTI_TYPE_APPENDED_SALT
6897 | OPTI_TYPE_RAW_HASH;
6898 dgst_pos0 = 0;
6899 dgst_pos1 = 3;
6900 dgst_pos2 = 2;
6901 dgst_pos3 = 1;
6902 break;
6903
6904 case 11: hash_type = HASH_TYPE_MD5;
6905 salt_type = SALT_TYPE_INTERN;
6906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6907 opts_type = OPTS_TYPE_PT_GENERATE_LE
6908 | OPTS_TYPE_ST_ADD80
6909 | OPTS_TYPE_ST_ADDBITS14;
6910 kern_type = KERN_TYPE_MD5_PWSLT;
6911 dgst_size = DGST_SIZE_4_4;
6912 parse_func = joomla_parse_hash;
6913 sort_by_digest = sort_by_digest_4_4;
6914 opti_type = OPTI_TYPE_ZERO_BYTE
6915 | OPTI_TYPE_PRECOMPUTE_INIT
6916 | OPTI_TYPE_PRECOMPUTE_MERKLE
6917 | OPTI_TYPE_MEET_IN_MIDDLE
6918 | OPTI_TYPE_EARLY_SKIP
6919 | OPTI_TYPE_NOT_ITERATED
6920 | OPTI_TYPE_APPENDED_SALT
6921 | OPTI_TYPE_RAW_HASH;
6922 dgst_pos0 = 0;
6923 dgst_pos1 = 3;
6924 dgst_pos2 = 2;
6925 dgst_pos3 = 1;
6926 break;
6927
6928 case 12: hash_type = HASH_TYPE_MD5;
6929 salt_type = SALT_TYPE_INTERN;
6930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6931 opts_type = OPTS_TYPE_PT_GENERATE_LE
6932 | OPTS_TYPE_ST_ADD80
6933 | OPTS_TYPE_ST_ADDBITS14;
6934 kern_type = KERN_TYPE_MD5_PWSLT;
6935 dgst_size = DGST_SIZE_4_4;
6936 parse_func = postgresql_parse_hash;
6937 sort_by_digest = sort_by_digest_4_4;
6938 opti_type = OPTI_TYPE_ZERO_BYTE
6939 | OPTI_TYPE_PRECOMPUTE_INIT
6940 | OPTI_TYPE_PRECOMPUTE_MERKLE
6941 | OPTI_TYPE_MEET_IN_MIDDLE
6942 | OPTI_TYPE_EARLY_SKIP
6943 | OPTI_TYPE_NOT_ITERATED
6944 | OPTI_TYPE_APPENDED_SALT
6945 | OPTI_TYPE_RAW_HASH;
6946 dgst_pos0 = 0;
6947 dgst_pos1 = 3;
6948 dgst_pos2 = 2;
6949 dgst_pos3 = 1;
6950 break;
6951
6952 case 20: hash_type = HASH_TYPE_MD5;
6953 salt_type = SALT_TYPE_INTERN;
6954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6955 opts_type = OPTS_TYPE_PT_GENERATE_LE
6956 | OPTS_TYPE_PT_ADD80
6957 | OPTS_TYPE_PT_ADDBITS14;
6958 kern_type = KERN_TYPE_MD5_SLTPW;
6959 dgst_size = DGST_SIZE_4_4;
6960 parse_func = md5s_parse_hash;
6961 sort_by_digest = sort_by_digest_4_4;
6962 opti_type = OPTI_TYPE_ZERO_BYTE
6963 | OPTI_TYPE_PRECOMPUTE_INIT
6964 | OPTI_TYPE_PRECOMPUTE_MERKLE
6965 | OPTI_TYPE_EARLY_SKIP
6966 | OPTI_TYPE_NOT_ITERATED
6967 | OPTI_TYPE_PREPENDED_SALT
6968 | OPTI_TYPE_RAW_HASH;
6969 dgst_pos0 = 0;
6970 dgst_pos1 = 3;
6971 dgst_pos2 = 2;
6972 dgst_pos3 = 1;
6973 break;
6974
6975 case 21: hash_type = HASH_TYPE_MD5;
6976 salt_type = SALT_TYPE_INTERN;
6977 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6978 opts_type = OPTS_TYPE_PT_GENERATE_LE
6979 | OPTS_TYPE_PT_ADD80
6980 | OPTS_TYPE_PT_ADDBITS14;
6981 kern_type = KERN_TYPE_MD5_SLTPW;
6982 dgst_size = DGST_SIZE_4_4;
6983 parse_func = osc_parse_hash;
6984 sort_by_digest = sort_by_digest_4_4;
6985 opti_type = OPTI_TYPE_ZERO_BYTE
6986 | OPTI_TYPE_PRECOMPUTE_INIT
6987 | OPTI_TYPE_PRECOMPUTE_MERKLE
6988 | OPTI_TYPE_EARLY_SKIP
6989 | OPTI_TYPE_NOT_ITERATED
6990 | OPTI_TYPE_PREPENDED_SALT
6991 | OPTI_TYPE_RAW_HASH;
6992 dgst_pos0 = 0;
6993 dgst_pos1 = 3;
6994 dgst_pos2 = 2;
6995 dgst_pos3 = 1;
6996 break;
6997
6998 case 22: hash_type = HASH_TYPE_MD5;
6999 salt_type = SALT_TYPE_EMBEDDED;
7000 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7001 opts_type = OPTS_TYPE_PT_GENERATE_LE
7002 | OPTS_TYPE_PT_ADD80
7003 | OPTS_TYPE_PT_ADDBITS14;
7004 kern_type = KERN_TYPE_MD5_SLTPW;
7005 dgst_size = DGST_SIZE_4_4;
7006 parse_func = netscreen_parse_hash;
7007 sort_by_digest = sort_by_digest_4_4;
7008 opti_type = OPTI_TYPE_ZERO_BYTE
7009 | OPTI_TYPE_PRECOMPUTE_INIT
7010 | OPTI_TYPE_PRECOMPUTE_MERKLE
7011 | OPTI_TYPE_EARLY_SKIP
7012 | OPTI_TYPE_NOT_ITERATED
7013 | OPTI_TYPE_PREPENDED_SALT
7014 | OPTI_TYPE_RAW_HASH;
7015 dgst_pos0 = 0;
7016 dgst_pos1 = 3;
7017 dgst_pos2 = 2;
7018 dgst_pos3 = 1;
7019 break;
7020
7021 case 23: hash_type = HASH_TYPE_MD5;
7022 salt_type = SALT_TYPE_EMBEDDED;
7023 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7024 opts_type = OPTS_TYPE_PT_GENERATE_LE
7025 | OPTS_TYPE_PT_ADD80
7026 | OPTS_TYPE_PT_ADDBITS14;
7027 kern_type = KERN_TYPE_MD5_SLTPW;
7028 dgst_size = DGST_SIZE_4_4;
7029 parse_func = skype_parse_hash;
7030 sort_by_digest = sort_by_digest_4_4;
7031 opti_type = OPTI_TYPE_ZERO_BYTE
7032 | OPTI_TYPE_PRECOMPUTE_INIT
7033 | OPTI_TYPE_PRECOMPUTE_MERKLE
7034 | OPTI_TYPE_EARLY_SKIP
7035 | OPTI_TYPE_NOT_ITERATED
7036 | OPTI_TYPE_PREPENDED_SALT
7037 | OPTI_TYPE_RAW_HASH;
7038 dgst_pos0 = 0;
7039 dgst_pos1 = 3;
7040 dgst_pos2 = 2;
7041 dgst_pos3 = 1;
7042 break;
7043
7044 case 30: hash_type = HASH_TYPE_MD5;
7045 salt_type = SALT_TYPE_INTERN;
7046 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7047 opts_type = OPTS_TYPE_PT_GENERATE_LE
7048 | OPTS_TYPE_PT_UNICODE
7049 | OPTS_TYPE_ST_ADD80
7050 | OPTS_TYPE_ST_ADDBITS14;
7051 kern_type = KERN_TYPE_MD5_PWUSLT;
7052 dgst_size = DGST_SIZE_4_4;
7053 parse_func = md5s_parse_hash;
7054 sort_by_digest = sort_by_digest_4_4;
7055 opti_type = OPTI_TYPE_ZERO_BYTE
7056 | OPTI_TYPE_PRECOMPUTE_INIT
7057 | OPTI_TYPE_PRECOMPUTE_MERKLE
7058 | OPTI_TYPE_MEET_IN_MIDDLE
7059 | OPTI_TYPE_EARLY_SKIP
7060 | OPTI_TYPE_NOT_ITERATED
7061 | OPTI_TYPE_APPENDED_SALT
7062 | OPTI_TYPE_RAW_HASH;
7063 dgst_pos0 = 0;
7064 dgst_pos1 = 3;
7065 dgst_pos2 = 2;
7066 dgst_pos3 = 1;
7067 break;
7068
7069 case 40: hash_type = HASH_TYPE_MD5;
7070 salt_type = SALT_TYPE_INTERN;
7071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7072 opts_type = OPTS_TYPE_PT_GENERATE_LE
7073 | OPTS_TYPE_PT_ADD80
7074 | OPTS_TYPE_PT_ADDBITS14
7075 | OPTS_TYPE_PT_UNICODE;
7076 kern_type = KERN_TYPE_MD5_SLTPWU;
7077 dgst_size = DGST_SIZE_4_4;
7078 parse_func = md5s_parse_hash;
7079 sort_by_digest = sort_by_digest_4_4;
7080 opti_type = OPTI_TYPE_ZERO_BYTE
7081 | OPTI_TYPE_PRECOMPUTE_INIT
7082 | OPTI_TYPE_PRECOMPUTE_MERKLE
7083 | OPTI_TYPE_EARLY_SKIP
7084 | OPTI_TYPE_NOT_ITERATED
7085 | OPTI_TYPE_PREPENDED_SALT
7086 | OPTI_TYPE_RAW_HASH;
7087 dgst_pos0 = 0;
7088 dgst_pos1 = 3;
7089 dgst_pos2 = 2;
7090 dgst_pos3 = 1;
7091 break;
7092
7093 case 50: hash_type = HASH_TYPE_MD5;
7094 salt_type = SALT_TYPE_INTERN;
7095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7096 opts_type = OPTS_TYPE_PT_GENERATE_LE
7097 | OPTS_TYPE_ST_ADD80
7098 | OPTS_TYPE_ST_ADDBITS14;
7099 kern_type = KERN_TYPE_HMACMD5_PW;
7100 dgst_size = DGST_SIZE_4_4;
7101 parse_func = hmacmd5_parse_hash;
7102 sort_by_digest = sort_by_digest_4_4;
7103 opti_type = OPTI_TYPE_ZERO_BYTE
7104 | OPTI_TYPE_NOT_ITERATED;
7105 dgst_pos0 = 0;
7106 dgst_pos1 = 3;
7107 dgst_pos2 = 2;
7108 dgst_pos3 = 1;
7109 break;
7110
7111 case 60: hash_type = HASH_TYPE_MD5;
7112 salt_type = SALT_TYPE_INTERN;
7113 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7114 opts_type = OPTS_TYPE_PT_GENERATE_LE
7115 | OPTS_TYPE_PT_ADD80
7116 | OPTS_TYPE_PT_ADDBITS14;
7117 kern_type = KERN_TYPE_HMACMD5_SLT;
7118 dgst_size = DGST_SIZE_4_4;
7119 parse_func = hmacmd5_parse_hash;
7120 sort_by_digest = sort_by_digest_4_4;
7121 opti_type = OPTI_TYPE_ZERO_BYTE
7122 | OPTI_TYPE_NOT_ITERATED;
7123 dgst_pos0 = 0;
7124 dgst_pos1 = 3;
7125 dgst_pos2 = 2;
7126 dgst_pos3 = 1;
7127 break;
7128
7129 case 100: hash_type = HASH_TYPE_SHA1;
7130 salt_type = SALT_TYPE_NONE;
7131 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7132 opts_type = OPTS_TYPE_PT_GENERATE_BE
7133 | OPTS_TYPE_PT_ADD80
7134 | OPTS_TYPE_PT_ADDBITS15;
7135 kern_type = KERN_TYPE_SHA1;
7136 dgst_size = DGST_SIZE_4_5;
7137 parse_func = sha1_parse_hash;
7138 sort_by_digest = sort_by_digest_4_5;
7139 opti_type = OPTI_TYPE_ZERO_BYTE
7140 | OPTI_TYPE_PRECOMPUTE_INIT
7141 | OPTI_TYPE_PRECOMPUTE_MERKLE
7142 | OPTI_TYPE_EARLY_SKIP
7143 | OPTI_TYPE_NOT_ITERATED
7144 | OPTI_TYPE_NOT_SALTED
7145 | OPTI_TYPE_RAW_HASH;
7146 dgst_pos0 = 3;
7147 dgst_pos1 = 4;
7148 dgst_pos2 = 2;
7149 dgst_pos3 = 1;
7150 break;
7151
7152 case 101: hash_type = HASH_TYPE_SHA1;
7153 salt_type = SALT_TYPE_NONE;
7154 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7155 opts_type = OPTS_TYPE_PT_GENERATE_BE
7156 | OPTS_TYPE_PT_ADD80
7157 | OPTS_TYPE_PT_ADDBITS15;
7158 kern_type = KERN_TYPE_SHA1;
7159 dgst_size = DGST_SIZE_4_5;
7160 parse_func = sha1b64_parse_hash;
7161 sort_by_digest = sort_by_digest_4_5;
7162 opti_type = OPTI_TYPE_ZERO_BYTE
7163 | OPTI_TYPE_PRECOMPUTE_INIT
7164 | OPTI_TYPE_PRECOMPUTE_MERKLE
7165 | OPTI_TYPE_EARLY_SKIP
7166 | OPTI_TYPE_NOT_ITERATED
7167 | OPTI_TYPE_NOT_SALTED
7168 | OPTI_TYPE_RAW_HASH;
7169 dgst_pos0 = 3;
7170 dgst_pos1 = 4;
7171 dgst_pos2 = 2;
7172 dgst_pos3 = 1;
7173 break;
7174
7175 case 110: hash_type = HASH_TYPE_SHA1;
7176 salt_type = SALT_TYPE_INTERN;
7177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7178 opts_type = OPTS_TYPE_PT_GENERATE_BE
7179 | OPTS_TYPE_ST_ADD80
7180 | OPTS_TYPE_ST_ADDBITS15;
7181 kern_type = KERN_TYPE_SHA1_PWSLT;
7182 dgst_size = DGST_SIZE_4_5;
7183 parse_func = sha1s_parse_hash;
7184 sort_by_digest = sort_by_digest_4_5;
7185 opti_type = OPTI_TYPE_ZERO_BYTE
7186 | OPTI_TYPE_PRECOMPUTE_INIT
7187 | OPTI_TYPE_PRECOMPUTE_MERKLE
7188 | OPTI_TYPE_EARLY_SKIP
7189 | OPTI_TYPE_NOT_ITERATED
7190 | OPTI_TYPE_APPENDED_SALT
7191 | OPTI_TYPE_RAW_HASH;
7192 dgst_pos0 = 3;
7193 dgst_pos1 = 4;
7194 dgst_pos2 = 2;
7195 dgst_pos3 = 1;
7196 break;
7197
7198 case 111: hash_type = HASH_TYPE_SHA1;
7199 salt_type = SALT_TYPE_EMBEDDED;
7200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7201 opts_type = OPTS_TYPE_PT_GENERATE_BE
7202 | OPTS_TYPE_ST_ADD80
7203 | OPTS_TYPE_ST_ADDBITS15;
7204 kern_type = KERN_TYPE_SHA1_PWSLT;
7205 dgst_size = DGST_SIZE_4_5;
7206 parse_func = sha1b64s_parse_hash;
7207 sort_by_digest = sort_by_digest_4_5;
7208 opti_type = OPTI_TYPE_ZERO_BYTE
7209 | OPTI_TYPE_PRECOMPUTE_INIT
7210 | OPTI_TYPE_PRECOMPUTE_MERKLE
7211 | OPTI_TYPE_EARLY_SKIP
7212 | OPTI_TYPE_NOT_ITERATED
7213 | OPTI_TYPE_APPENDED_SALT
7214 | OPTI_TYPE_RAW_HASH;
7215 dgst_pos0 = 3;
7216 dgst_pos1 = 4;
7217 dgst_pos2 = 2;
7218 dgst_pos3 = 1;
7219 break;
7220
7221 case 112: hash_type = HASH_TYPE_SHA1;
7222 salt_type = SALT_TYPE_INTERN;
7223 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7224 opts_type = OPTS_TYPE_PT_GENERATE_BE
7225 | OPTS_TYPE_ST_ADD80
7226 | OPTS_TYPE_ST_ADDBITS15
7227 | OPTS_TYPE_ST_HEX;
7228 kern_type = KERN_TYPE_SHA1_PWSLT;
7229 dgst_size = DGST_SIZE_4_5;
7230 parse_func = oracles_parse_hash;
7231 sort_by_digest = sort_by_digest_4_5;
7232 opti_type = OPTI_TYPE_ZERO_BYTE
7233 | OPTI_TYPE_PRECOMPUTE_INIT
7234 | OPTI_TYPE_PRECOMPUTE_MERKLE
7235 | OPTI_TYPE_EARLY_SKIP
7236 | OPTI_TYPE_NOT_ITERATED
7237 | OPTI_TYPE_APPENDED_SALT
7238 | OPTI_TYPE_RAW_HASH;
7239 dgst_pos0 = 3;
7240 dgst_pos1 = 4;
7241 dgst_pos2 = 2;
7242 dgst_pos3 = 1;
7243 break;
7244
7245 case 120: hash_type = HASH_TYPE_SHA1;
7246 salt_type = SALT_TYPE_INTERN;
7247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7248 opts_type = OPTS_TYPE_PT_GENERATE_BE
7249 | OPTS_TYPE_PT_ADD80
7250 | OPTS_TYPE_PT_ADDBITS15;
7251 kern_type = KERN_TYPE_SHA1_SLTPW;
7252 dgst_size = DGST_SIZE_4_5;
7253 parse_func = sha1s_parse_hash;
7254 sort_by_digest = sort_by_digest_4_5;
7255 opti_type = OPTI_TYPE_ZERO_BYTE
7256 | OPTI_TYPE_PRECOMPUTE_INIT
7257 | OPTI_TYPE_PRECOMPUTE_MERKLE
7258 | OPTI_TYPE_EARLY_SKIP
7259 | OPTI_TYPE_NOT_ITERATED
7260 | OPTI_TYPE_PREPENDED_SALT
7261 | OPTI_TYPE_RAW_HASH;
7262 dgst_pos0 = 3;
7263 dgst_pos1 = 4;
7264 dgst_pos2 = 2;
7265 dgst_pos3 = 1;
7266 break;
7267
7268 case 121: hash_type = HASH_TYPE_SHA1;
7269 salt_type = SALT_TYPE_INTERN;
7270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7271 opts_type = OPTS_TYPE_PT_GENERATE_BE
7272 | OPTS_TYPE_PT_ADD80
7273 | OPTS_TYPE_PT_ADDBITS15
7274 | OPTS_TYPE_ST_LOWER;
7275 kern_type = KERN_TYPE_SHA1_SLTPW;
7276 dgst_size = DGST_SIZE_4_5;
7277 parse_func = smf_parse_hash;
7278 sort_by_digest = sort_by_digest_4_5;
7279 opti_type = OPTI_TYPE_ZERO_BYTE
7280 | OPTI_TYPE_PRECOMPUTE_INIT
7281 | OPTI_TYPE_PRECOMPUTE_MERKLE
7282 | OPTI_TYPE_EARLY_SKIP
7283 | OPTI_TYPE_NOT_ITERATED
7284 | OPTI_TYPE_PREPENDED_SALT
7285 | OPTI_TYPE_RAW_HASH;
7286 dgst_pos0 = 3;
7287 dgst_pos1 = 4;
7288 dgst_pos2 = 2;
7289 dgst_pos3 = 1;
7290 break;
7291
7292 case 122: hash_type = HASH_TYPE_SHA1;
7293 salt_type = SALT_TYPE_EMBEDDED;
7294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7295 opts_type = OPTS_TYPE_PT_GENERATE_BE
7296 | OPTS_TYPE_PT_ADD80
7297 | OPTS_TYPE_PT_ADDBITS15
7298 | OPTS_TYPE_ST_HEX;
7299 kern_type = KERN_TYPE_SHA1_SLTPW;
7300 dgst_size = DGST_SIZE_4_5;
7301 parse_func = osx1_parse_hash;
7302 sort_by_digest = sort_by_digest_4_5;
7303 opti_type = OPTI_TYPE_ZERO_BYTE
7304 | OPTI_TYPE_PRECOMPUTE_INIT
7305 | OPTI_TYPE_PRECOMPUTE_MERKLE
7306 | OPTI_TYPE_EARLY_SKIP
7307 | OPTI_TYPE_NOT_ITERATED
7308 | OPTI_TYPE_PREPENDED_SALT
7309 | OPTI_TYPE_RAW_HASH;
7310 dgst_pos0 = 3;
7311 dgst_pos1 = 4;
7312 dgst_pos2 = 2;
7313 dgst_pos3 = 1;
7314 break;
7315
7316 case 124: hash_type = HASH_TYPE_SHA1;
7317 salt_type = SALT_TYPE_EMBEDDED;
7318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7319 opts_type = OPTS_TYPE_PT_GENERATE_BE
7320 | OPTS_TYPE_PT_ADD80
7321 | OPTS_TYPE_PT_ADDBITS15;
7322 kern_type = KERN_TYPE_SHA1_SLTPW;
7323 dgst_size = DGST_SIZE_4_5;
7324 parse_func = djangosha1_parse_hash;
7325 sort_by_digest = sort_by_digest_4_5;
7326 opti_type = OPTI_TYPE_ZERO_BYTE
7327 | OPTI_TYPE_PRECOMPUTE_INIT
7328 | OPTI_TYPE_PRECOMPUTE_MERKLE
7329 | OPTI_TYPE_EARLY_SKIP
7330 | OPTI_TYPE_NOT_ITERATED
7331 | OPTI_TYPE_PREPENDED_SALT
7332 | OPTI_TYPE_RAW_HASH;
7333 dgst_pos0 = 3;
7334 dgst_pos1 = 4;
7335 dgst_pos2 = 2;
7336 dgst_pos3 = 1;
7337 break;
7338
7339 case 125: hash_type = HASH_TYPE_SHA1;
7340 salt_type = SALT_TYPE_EMBEDDED;
7341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7342 opts_type = OPTS_TYPE_PT_GENERATE_BE
7343 | OPTS_TYPE_PT_ADD80
7344 | OPTS_TYPE_PT_ADDBITS15
7345 | OPTS_TYPE_ST_HEX;
7346 kern_type = KERN_TYPE_SHA1_SLTPW;
7347 dgst_size = DGST_SIZE_4_5;
7348 parse_func = arubaos_parse_hash;
7349 sort_by_digest = sort_by_digest_4_5;
7350 opti_type = OPTI_TYPE_ZERO_BYTE
7351 | OPTI_TYPE_PRECOMPUTE_INIT
7352 | OPTI_TYPE_PRECOMPUTE_MERKLE
7353 | OPTI_TYPE_EARLY_SKIP
7354 | OPTI_TYPE_NOT_ITERATED
7355 | OPTI_TYPE_PREPENDED_SALT
7356 | OPTI_TYPE_RAW_HASH;
7357 dgst_pos0 = 3;
7358 dgst_pos1 = 4;
7359 dgst_pos2 = 2;
7360 dgst_pos3 = 1;
7361 break;
7362
7363 case 130: hash_type = HASH_TYPE_SHA1;
7364 salt_type = SALT_TYPE_INTERN;
7365 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7366 opts_type = OPTS_TYPE_PT_GENERATE_BE
7367 | OPTS_TYPE_PT_UNICODE
7368 | OPTS_TYPE_ST_ADD80
7369 | OPTS_TYPE_ST_ADDBITS15;
7370 kern_type = KERN_TYPE_SHA1_PWUSLT;
7371 dgst_size = DGST_SIZE_4_5;
7372 parse_func = sha1s_parse_hash;
7373 sort_by_digest = sort_by_digest_4_5;
7374 opti_type = OPTI_TYPE_ZERO_BYTE
7375 | OPTI_TYPE_PRECOMPUTE_INIT
7376 | OPTI_TYPE_PRECOMPUTE_MERKLE
7377 | OPTI_TYPE_EARLY_SKIP
7378 | OPTI_TYPE_NOT_ITERATED
7379 | OPTI_TYPE_APPENDED_SALT
7380 | OPTI_TYPE_RAW_HASH;
7381 dgst_pos0 = 3;
7382 dgst_pos1 = 4;
7383 dgst_pos2 = 2;
7384 dgst_pos3 = 1;
7385 break;
7386
7387 case 131: hash_type = HASH_TYPE_SHA1;
7388 salt_type = SALT_TYPE_EMBEDDED;
7389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7390 opts_type = OPTS_TYPE_PT_GENERATE_BE
7391 | OPTS_TYPE_PT_UNICODE
7392 | OPTS_TYPE_PT_UPPER
7393 | OPTS_TYPE_ST_ADD80
7394 | OPTS_TYPE_ST_ADDBITS15
7395 | OPTS_TYPE_ST_HEX;
7396 kern_type = KERN_TYPE_SHA1_PWUSLT;
7397 dgst_size = DGST_SIZE_4_5;
7398 parse_func = mssql2000_parse_hash;
7399 sort_by_digest = sort_by_digest_4_5;
7400 opti_type = OPTI_TYPE_ZERO_BYTE
7401 | OPTI_TYPE_PRECOMPUTE_INIT
7402 | OPTI_TYPE_PRECOMPUTE_MERKLE
7403 | OPTI_TYPE_EARLY_SKIP
7404 | OPTI_TYPE_NOT_ITERATED
7405 | OPTI_TYPE_APPENDED_SALT
7406 | OPTI_TYPE_RAW_HASH;
7407 dgst_pos0 = 3;
7408 dgst_pos1 = 4;
7409 dgst_pos2 = 2;
7410 dgst_pos3 = 1;
7411 break;
7412
7413 case 132: hash_type = HASH_TYPE_SHA1;
7414 salt_type = SALT_TYPE_EMBEDDED;
7415 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7416 opts_type = OPTS_TYPE_PT_GENERATE_BE
7417 | OPTS_TYPE_PT_UNICODE
7418 | OPTS_TYPE_ST_ADD80
7419 | OPTS_TYPE_ST_ADDBITS15
7420 | OPTS_TYPE_ST_HEX;
7421 kern_type = KERN_TYPE_SHA1_PWUSLT;
7422 dgst_size = DGST_SIZE_4_5;
7423 parse_func = mssql2005_parse_hash;
7424 sort_by_digest = sort_by_digest_4_5;
7425 opti_type = OPTI_TYPE_ZERO_BYTE
7426 | OPTI_TYPE_PRECOMPUTE_INIT
7427 | OPTI_TYPE_PRECOMPUTE_MERKLE
7428 | OPTI_TYPE_EARLY_SKIP
7429 | OPTI_TYPE_NOT_ITERATED
7430 | OPTI_TYPE_APPENDED_SALT
7431 | OPTI_TYPE_RAW_HASH;
7432 dgst_pos0 = 3;
7433 dgst_pos1 = 4;
7434 dgst_pos2 = 2;
7435 dgst_pos3 = 1;
7436 break;
7437
7438 case 133: hash_type = HASH_TYPE_SHA1;
7439 salt_type = SALT_TYPE_EMBEDDED;
7440 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7441 opts_type = OPTS_TYPE_PT_GENERATE_BE
7442 | OPTS_TYPE_PT_UNICODE
7443 | OPTS_TYPE_ST_ADD80
7444 | OPTS_TYPE_ST_ADDBITS15;
7445 kern_type = KERN_TYPE_SHA1_PWUSLT;
7446 dgst_size = DGST_SIZE_4_5;
7447 parse_func = peoplesoft_parse_hash;
7448 sort_by_digest = sort_by_digest_4_5;
7449 opti_type = OPTI_TYPE_ZERO_BYTE
7450 | OPTI_TYPE_PRECOMPUTE_INIT
7451 | OPTI_TYPE_PRECOMPUTE_MERKLE
7452 | OPTI_TYPE_EARLY_SKIP
7453 | OPTI_TYPE_NOT_ITERATED
7454 | OPTI_TYPE_APPENDED_SALT
7455 | OPTI_TYPE_RAW_HASH;
7456 dgst_pos0 = 3;
7457 dgst_pos1 = 4;
7458 dgst_pos2 = 2;
7459 dgst_pos3 = 1;
7460 break;
7461
7462 case 140: hash_type = HASH_TYPE_SHA1;
7463 salt_type = SALT_TYPE_INTERN;
7464 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7465 opts_type = OPTS_TYPE_PT_GENERATE_BE
7466 | OPTS_TYPE_PT_ADD80
7467 | OPTS_TYPE_PT_ADDBITS15
7468 | OPTS_TYPE_PT_UNICODE;
7469 kern_type = KERN_TYPE_SHA1_SLTPWU;
7470 dgst_size = DGST_SIZE_4_5;
7471 parse_func = sha1s_parse_hash;
7472 sort_by_digest = sort_by_digest_4_5;
7473 opti_type = OPTI_TYPE_ZERO_BYTE
7474 | OPTI_TYPE_PRECOMPUTE_INIT
7475 | OPTI_TYPE_PRECOMPUTE_MERKLE
7476 | OPTI_TYPE_EARLY_SKIP
7477 | OPTI_TYPE_NOT_ITERATED
7478 | OPTI_TYPE_PREPENDED_SALT
7479 | OPTI_TYPE_RAW_HASH;
7480 dgst_pos0 = 3;
7481 dgst_pos1 = 4;
7482 dgst_pos2 = 2;
7483 dgst_pos3 = 1;
7484 break;
7485
7486 case 141: hash_type = HASH_TYPE_SHA1;
7487 salt_type = SALT_TYPE_EMBEDDED;
7488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7489 opts_type = OPTS_TYPE_PT_GENERATE_BE
7490 | OPTS_TYPE_PT_ADD80
7491 | OPTS_TYPE_PT_ADDBITS15
7492 | OPTS_TYPE_PT_UNICODE
7493 | OPTS_TYPE_ST_BASE64;
7494 kern_type = KERN_TYPE_SHA1_SLTPWU;
7495 dgst_size = DGST_SIZE_4_5;
7496 parse_func = episerver_parse_hash;
7497 sort_by_digest = sort_by_digest_4_5;
7498 opti_type = OPTI_TYPE_ZERO_BYTE
7499 | OPTI_TYPE_PRECOMPUTE_INIT
7500 | OPTI_TYPE_PRECOMPUTE_MERKLE
7501 | OPTI_TYPE_EARLY_SKIP
7502 | OPTI_TYPE_NOT_ITERATED
7503 | OPTI_TYPE_PREPENDED_SALT
7504 | OPTI_TYPE_RAW_HASH;
7505 dgst_pos0 = 3;
7506 dgst_pos1 = 4;
7507 dgst_pos2 = 2;
7508 dgst_pos3 = 1;
7509 break;
7510
7511 case 150: hash_type = HASH_TYPE_SHA1;
7512 salt_type = SALT_TYPE_INTERN;
7513 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7514 opts_type = OPTS_TYPE_PT_GENERATE_BE
7515 | OPTS_TYPE_ST_ADD80
7516 | OPTS_TYPE_ST_ADDBITS15;
7517 kern_type = KERN_TYPE_HMACSHA1_PW;
7518 dgst_size = DGST_SIZE_4_5;
7519 parse_func = hmacsha1_parse_hash;
7520 sort_by_digest = sort_by_digest_4_5;
7521 opti_type = OPTI_TYPE_ZERO_BYTE
7522 | OPTI_TYPE_NOT_ITERATED;
7523 dgst_pos0 = 3;
7524 dgst_pos1 = 4;
7525 dgst_pos2 = 2;
7526 dgst_pos3 = 1;
7527 break;
7528
7529 case 160: hash_type = HASH_TYPE_SHA1;
7530 salt_type = SALT_TYPE_INTERN;
7531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7532 opts_type = OPTS_TYPE_PT_GENERATE_BE
7533 | OPTS_TYPE_PT_ADD80
7534 | OPTS_TYPE_PT_ADDBITS15;
7535 kern_type = KERN_TYPE_HMACSHA1_SLT;
7536 dgst_size = DGST_SIZE_4_5;
7537 parse_func = hmacsha1_parse_hash;
7538 sort_by_digest = sort_by_digest_4_5;
7539 opti_type = OPTI_TYPE_ZERO_BYTE
7540 | OPTI_TYPE_NOT_ITERATED;
7541 dgst_pos0 = 3;
7542 dgst_pos1 = 4;
7543 dgst_pos2 = 2;
7544 dgst_pos3 = 1;
7545 break;
7546
7547 case 190: hash_type = HASH_TYPE_SHA1;
7548 salt_type = SALT_TYPE_NONE;
7549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7550 opts_type = OPTS_TYPE_PT_GENERATE_BE
7551 | OPTS_TYPE_PT_ADD80
7552 | OPTS_TYPE_PT_ADDBITS15;
7553 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7554 dgst_size = DGST_SIZE_4_5;
7555 parse_func = sha1linkedin_parse_hash;
7556 sort_by_digest = sort_by_digest_4_5;
7557 opti_type = OPTI_TYPE_ZERO_BYTE
7558 | OPTI_TYPE_PRECOMPUTE_INIT
7559 | OPTI_TYPE_EARLY_SKIP
7560 | OPTI_TYPE_NOT_ITERATED
7561 | OPTI_TYPE_NOT_SALTED;
7562 dgst_pos0 = 0;
7563 dgst_pos1 = 4;
7564 dgst_pos2 = 3;
7565 dgst_pos3 = 2;
7566 break;
7567
7568 case 200: hash_type = HASH_TYPE_MYSQL;
7569 salt_type = SALT_TYPE_NONE;
7570 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7571 opts_type = 0;
7572 kern_type = KERN_TYPE_MYSQL;
7573 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7574 parse_func = mysql323_parse_hash;
7575 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7576 opti_type = OPTI_TYPE_ZERO_BYTE;
7577 dgst_pos0 = 0;
7578 dgst_pos1 = 1;
7579 dgst_pos2 = 2;
7580 dgst_pos3 = 3;
7581 break;
7582
7583 case 300: hash_type = HASH_TYPE_SHA1;
7584 salt_type = SALT_TYPE_NONE;
7585 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7586 opts_type = OPTS_TYPE_PT_GENERATE_BE
7587 | OPTS_TYPE_PT_ADD80
7588 | OPTS_TYPE_PT_ADDBITS15;
7589 kern_type = KERN_TYPE_MYSQL41;
7590 dgst_size = DGST_SIZE_4_5;
7591 parse_func = sha1_parse_hash;
7592 sort_by_digest = sort_by_digest_4_5;
7593 opti_type = OPTI_TYPE_ZERO_BYTE
7594 | OPTI_TYPE_PRECOMPUTE_INIT
7595 | OPTI_TYPE_PRECOMPUTE_MERKLE
7596 | OPTI_TYPE_EARLY_SKIP
7597 | OPTI_TYPE_NOT_ITERATED
7598 | OPTI_TYPE_NOT_SALTED;
7599 dgst_pos0 = 3;
7600 dgst_pos1 = 4;
7601 dgst_pos2 = 2;
7602 dgst_pos3 = 1;
7603 break;
7604
7605 case 400: hash_type = HASH_TYPE_MD5;
7606 salt_type = SALT_TYPE_EMBEDDED;
7607 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7608 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7609 kern_type = KERN_TYPE_PHPASS;
7610 dgst_size = DGST_SIZE_4_4;
7611 parse_func = phpass_parse_hash;
7612 sort_by_digest = sort_by_digest_4_4;
7613 opti_type = OPTI_TYPE_ZERO_BYTE
7614 | OPTI_TYPE_SLOW_HASH_SIMD;
7615 dgst_pos0 = 0;
7616 dgst_pos1 = 1;
7617 dgst_pos2 = 2;
7618 dgst_pos3 = 3;
7619 break;
7620
7621 case 500: hash_type = HASH_TYPE_MD5;
7622 salt_type = SALT_TYPE_EMBEDDED;
7623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7624 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7625 kern_type = KERN_TYPE_MD5CRYPT;
7626 dgst_size = DGST_SIZE_4_4;
7627 parse_func = md5crypt_parse_hash;
7628 sort_by_digest = sort_by_digest_4_4;
7629 opti_type = OPTI_TYPE_ZERO_BYTE;
7630 dgst_pos0 = 0;
7631 dgst_pos1 = 1;
7632 dgst_pos2 = 2;
7633 dgst_pos3 = 3;
7634 break;
7635
7636 case 501: hash_type = HASH_TYPE_MD5;
7637 salt_type = SALT_TYPE_EMBEDDED;
7638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7639 opts_type = OPTS_TYPE_PT_GENERATE_LE
7640 | OPTS_TYPE_HASH_COPY;
7641 kern_type = KERN_TYPE_MD5CRYPT;
7642 dgst_size = DGST_SIZE_4_4;
7643 parse_func = juniper_parse_hash;
7644 sort_by_digest = sort_by_digest_4_4;
7645 opti_type = OPTI_TYPE_ZERO_BYTE;
7646 dgst_pos0 = 0;
7647 dgst_pos1 = 1;
7648 dgst_pos2 = 2;
7649 dgst_pos3 = 3;
7650 break;
7651
7652 case 900: hash_type = HASH_TYPE_MD4;
7653 salt_type = SALT_TYPE_NONE;
7654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7655 opts_type = OPTS_TYPE_PT_GENERATE_LE
7656 | OPTS_TYPE_PT_ADD80
7657 | OPTS_TYPE_PT_ADDBITS14;
7658 kern_type = KERN_TYPE_MD4;
7659 dgst_size = DGST_SIZE_4_4;
7660 parse_func = md4_parse_hash;
7661 sort_by_digest = sort_by_digest_4_4;
7662 opti_type = OPTI_TYPE_ZERO_BYTE
7663 | OPTI_TYPE_PRECOMPUTE_INIT
7664 | OPTI_TYPE_PRECOMPUTE_MERKLE
7665 | OPTI_TYPE_MEET_IN_MIDDLE
7666 | OPTI_TYPE_EARLY_SKIP
7667 | OPTI_TYPE_NOT_ITERATED
7668 | OPTI_TYPE_NOT_SALTED
7669 | OPTI_TYPE_RAW_HASH;
7670 dgst_pos0 = 0;
7671 dgst_pos1 = 3;
7672 dgst_pos2 = 2;
7673 dgst_pos3 = 1;
7674 break;
7675
7676 case 1000: hash_type = HASH_TYPE_MD4;
7677 salt_type = SALT_TYPE_NONE;
7678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7679 opts_type = OPTS_TYPE_PT_GENERATE_LE
7680 | OPTS_TYPE_PT_ADD80
7681 | OPTS_TYPE_PT_ADDBITS14
7682 | OPTS_TYPE_PT_UNICODE;
7683 kern_type = KERN_TYPE_MD4_PWU;
7684 dgst_size = DGST_SIZE_4_4;
7685 parse_func = md4_parse_hash;
7686 sort_by_digest = sort_by_digest_4_4;
7687 opti_type = OPTI_TYPE_ZERO_BYTE
7688 | OPTI_TYPE_PRECOMPUTE_INIT
7689 | OPTI_TYPE_PRECOMPUTE_MERKLE
7690 | OPTI_TYPE_MEET_IN_MIDDLE
7691 | OPTI_TYPE_EARLY_SKIP
7692 | OPTI_TYPE_NOT_ITERATED
7693 | OPTI_TYPE_NOT_SALTED
7694 | OPTI_TYPE_RAW_HASH;
7695 dgst_pos0 = 0;
7696 dgst_pos1 = 3;
7697 dgst_pos2 = 2;
7698 dgst_pos3 = 1;
7699 break;
7700
7701 case 1100: hash_type = HASH_TYPE_MD4;
7702 salt_type = SALT_TYPE_INTERN;
7703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7704 opts_type = OPTS_TYPE_PT_GENERATE_LE
7705 | OPTS_TYPE_PT_ADD80
7706 | OPTS_TYPE_PT_ADDBITS14
7707 | OPTS_TYPE_PT_UNICODE
7708 | OPTS_TYPE_ST_ADD80
7709 | OPTS_TYPE_ST_UNICODE
7710 | OPTS_TYPE_ST_LOWER;
7711 kern_type = KERN_TYPE_MD44_PWUSLT;
7712 dgst_size = DGST_SIZE_4_4;
7713 parse_func = dcc_parse_hash;
7714 sort_by_digest = sort_by_digest_4_4;
7715 opti_type = OPTI_TYPE_ZERO_BYTE
7716 | OPTI_TYPE_PRECOMPUTE_INIT
7717 | OPTI_TYPE_PRECOMPUTE_MERKLE
7718 | OPTI_TYPE_EARLY_SKIP
7719 | OPTI_TYPE_NOT_ITERATED;
7720 dgst_pos0 = 0;
7721 dgst_pos1 = 3;
7722 dgst_pos2 = 2;
7723 dgst_pos3 = 1;
7724 break;
7725
7726 case 1400: hash_type = HASH_TYPE_SHA256;
7727 salt_type = SALT_TYPE_NONE;
7728 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7729 opts_type = OPTS_TYPE_PT_GENERATE_BE
7730 | OPTS_TYPE_PT_ADD80
7731 | OPTS_TYPE_PT_ADDBITS15;
7732 kern_type = KERN_TYPE_SHA256;
7733 dgst_size = DGST_SIZE_4_8;
7734 parse_func = sha256_parse_hash;
7735 sort_by_digest = sort_by_digest_4_8;
7736 opti_type = OPTI_TYPE_ZERO_BYTE
7737 | OPTI_TYPE_PRECOMPUTE_INIT
7738 | OPTI_TYPE_PRECOMPUTE_MERKLE
7739 | OPTI_TYPE_EARLY_SKIP
7740 | OPTI_TYPE_NOT_ITERATED
7741 | OPTI_TYPE_NOT_SALTED
7742 | OPTI_TYPE_RAW_HASH;
7743 dgst_pos0 = 3;
7744 dgst_pos1 = 7;
7745 dgst_pos2 = 2;
7746 dgst_pos3 = 6;
7747 break;
7748
7749 case 1410: hash_type = HASH_TYPE_SHA256;
7750 salt_type = SALT_TYPE_INTERN;
7751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7752 opts_type = OPTS_TYPE_PT_GENERATE_BE
7753 | OPTS_TYPE_ST_ADD80
7754 | OPTS_TYPE_ST_ADDBITS15;
7755 kern_type = KERN_TYPE_SHA256_PWSLT;
7756 dgst_size = DGST_SIZE_4_8;
7757 parse_func = sha256s_parse_hash;
7758 sort_by_digest = sort_by_digest_4_8;
7759 opti_type = OPTI_TYPE_ZERO_BYTE
7760 | OPTI_TYPE_PRECOMPUTE_INIT
7761 | OPTI_TYPE_PRECOMPUTE_MERKLE
7762 | OPTI_TYPE_EARLY_SKIP
7763 | OPTI_TYPE_NOT_ITERATED
7764 | OPTI_TYPE_APPENDED_SALT
7765 | OPTI_TYPE_RAW_HASH;
7766 dgst_pos0 = 3;
7767 dgst_pos1 = 7;
7768 dgst_pos2 = 2;
7769 dgst_pos3 = 6;
7770 break;
7771
7772 case 1420: hash_type = HASH_TYPE_SHA256;
7773 salt_type = SALT_TYPE_INTERN;
7774 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7775 opts_type = OPTS_TYPE_PT_GENERATE_BE
7776 | OPTS_TYPE_PT_ADD80
7777 | OPTS_TYPE_PT_ADDBITS15;
7778 kern_type = KERN_TYPE_SHA256_SLTPW;
7779 dgst_size = DGST_SIZE_4_8;
7780 parse_func = sha256s_parse_hash;
7781 sort_by_digest = sort_by_digest_4_8;
7782 opti_type = OPTI_TYPE_ZERO_BYTE
7783 | OPTI_TYPE_PRECOMPUTE_INIT
7784 | OPTI_TYPE_PRECOMPUTE_MERKLE
7785 | OPTI_TYPE_EARLY_SKIP
7786 | OPTI_TYPE_NOT_ITERATED
7787 | OPTI_TYPE_PREPENDED_SALT
7788 | OPTI_TYPE_RAW_HASH;
7789 dgst_pos0 = 3;
7790 dgst_pos1 = 7;
7791 dgst_pos2 = 2;
7792 dgst_pos3 = 6;
7793 break;
7794
7795 case 1421: hash_type = HASH_TYPE_SHA256;
7796 salt_type = SALT_TYPE_EMBEDDED;
7797 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7798 opts_type = OPTS_TYPE_PT_GENERATE_BE
7799 | OPTS_TYPE_PT_ADD80
7800 | OPTS_TYPE_PT_ADDBITS15;
7801 kern_type = KERN_TYPE_SHA256_SLTPW;
7802 dgst_size = DGST_SIZE_4_8;
7803 parse_func = hmailserver_parse_hash;
7804 sort_by_digest = sort_by_digest_4_8;
7805 opti_type = OPTI_TYPE_ZERO_BYTE
7806 | OPTI_TYPE_PRECOMPUTE_INIT
7807 | OPTI_TYPE_PRECOMPUTE_MERKLE
7808 | OPTI_TYPE_EARLY_SKIP
7809 | OPTI_TYPE_NOT_ITERATED
7810 | OPTI_TYPE_PREPENDED_SALT
7811 | OPTI_TYPE_RAW_HASH;
7812 dgst_pos0 = 3;
7813 dgst_pos1 = 7;
7814 dgst_pos2 = 2;
7815 dgst_pos3 = 6;
7816 break;
7817
7818 case 1430: hash_type = HASH_TYPE_SHA256;
7819 salt_type = SALT_TYPE_INTERN;
7820 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7821 opts_type = OPTS_TYPE_PT_GENERATE_BE
7822 | OPTS_TYPE_PT_UNICODE
7823 | OPTS_TYPE_ST_ADD80
7824 | OPTS_TYPE_ST_ADDBITS15;
7825 kern_type = KERN_TYPE_SHA256_PWUSLT;
7826 dgst_size = DGST_SIZE_4_8;
7827 parse_func = sha256s_parse_hash;
7828 sort_by_digest = sort_by_digest_4_8;
7829 opti_type = OPTI_TYPE_ZERO_BYTE
7830 | OPTI_TYPE_PRECOMPUTE_INIT
7831 | OPTI_TYPE_PRECOMPUTE_MERKLE
7832 | OPTI_TYPE_EARLY_SKIP
7833 | OPTI_TYPE_NOT_ITERATED
7834 | OPTI_TYPE_APPENDED_SALT
7835 | OPTI_TYPE_RAW_HASH;
7836 dgst_pos0 = 3;
7837 dgst_pos1 = 7;
7838 dgst_pos2 = 2;
7839 dgst_pos3 = 6;
7840 break;
7841
7842 case 1440: hash_type = HASH_TYPE_SHA256;
7843 salt_type = SALT_TYPE_INTERN;
7844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7845 opts_type = OPTS_TYPE_PT_GENERATE_BE
7846 | OPTS_TYPE_PT_ADD80
7847 | OPTS_TYPE_PT_ADDBITS15
7848 | OPTS_TYPE_PT_UNICODE;
7849 kern_type = KERN_TYPE_SHA256_SLTPWU;
7850 dgst_size = DGST_SIZE_4_8;
7851 parse_func = sha256s_parse_hash;
7852 sort_by_digest = sort_by_digest_4_8;
7853 opti_type = OPTI_TYPE_ZERO_BYTE
7854 | OPTI_TYPE_PRECOMPUTE_INIT
7855 | OPTI_TYPE_PRECOMPUTE_MERKLE
7856 | OPTI_TYPE_EARLY_SKIP
7857 | OPTI_TYPE_NOT_ITERATED
7858 | OPTI_TYPE_PREPENDED_SALT
7859 | OPTI_TYPE_RAW_HASH;
7860 dgst_pos0 = 3;
7861 dgst_pos1 = 7;
7862 dgst_pos2 = 2;
7863 dgst_pos3 = 6;
7864 break;
7865
7866 case 1441: hash_type = HASH_TYPE_SHA256;
7867 salt_type = SALT_TYPE_EMBEDDED;
7868 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7869 opts_type = OPTS_TYPE_PT_GENERATE_BE
7870 | OPTS_TYPE_PT_ADD80
7871 | OPTS_TYPE_PT_ADDBITS15
7872 | OPTS_TYPE_PT_UNICODE
7873 | OPTS_TYPE_ST_BASE64;
7874 kern_type = KERN_TYPE_SHA256_SLTPWU;
7875 dgst_size = DGST_SIZE_4_8;
7876 parse_func = episerver4_parse_hash;
7877 sort_by_digest = sort_by_digest_4_8;
7878 opti_type = OPTI_TYPE_ZERO_BYTE
7879 | OPTI_TYPE_PRECOMPUTE_INIT
7880 | OPTI_TYPE_PRECOMPUTE_MERKLE
7881 | OPTI_TYPE_EARLY_SKIP
7882 | OPTI_TYPE_NOT_ITERATED
7883 | OPTI_TYPE_PREPENDED_SALT
7884 | OPTI_TYPE_RAW_HASH;
7885 dgst_pos0 = 3;
7886 dgst_pos1 = 7;
7887 dgst_pos2 = 2;
7888 dgst_pos3 = 6;
7889 break;
7890
7891 case 1450: hash_type = HASH_TYPE_SHA256;
7892 salt_type = SALT_TYPE_INTERN;
7893 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7894 opts_type = OPTS_TYPE_PT_GENERATE_BE
7895 | OPTS_TYPE_ST_ADD80;
7896 kern_type = KERN_TYPE_HMACSHA256_PW;
7897 dgst_size = DGST_SIZE_4_8;
7898 parse_func = hmacsha256_parse_hash;
7899 sort_by_digest = sort_by_digest_4_8;
7900 opti_type = OPTI_TYPE_ZERO_BYTE
7901 | OPTI_TYPE_NOT_ITERATED;
7902 dgst_pos0 = 3;
7903 dgst_pos1 = 7;
7904 dgst_pos2 = 2;
7905 dgst_pos3 = 6;
7906 break;
7907
7908 case 1460: hash_type = HASH_TYPE_SHA256;
7909 salt_type = SALT_TYPE_INTERN;
7910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7911 opts_type = OPTS_TYPE_PT_GENERATE_BE
7912 | OPTS_TYPE_PT_ADD80
7913 | OPTS_TYPE_PT_ADDBITS15;
7914 kern_type = KERN_TYPE_HMACSHA256_SLT;
7915 dgst_size = DGST_SIZE_4_8;
7916 parse_func = hmacsha256_parse_hash;
7917 sort_by_digest = sort_by_digest_4_8;
7918 opti_type = OPTI_TYPE_ZERO_BYTE
7919 | OPTI_TYPE_NOT_ITERATED;
7920 dgst_pos0 = 3;
7921 dgst_pos1 = 7;
7922 dgst_pos2 = 2;
7923 dgst_pos3 = 6;
7924 break;
7925
7926 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7927 salt_type = SALT_TYPE_EMBEDDED;
7928 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7929 opts_type = OPTS_TYPE_PT_GENERATE_LE
7930 | OPTS_TYPE_PT_BITSLICE;
7931 kern_type = KERN_TYPE_DESCRYPT;
7932 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7933 parse_func = descrypt_parse_hash;
7934 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7935 opti_type = OPTI_TYPE_ZERO_BYTE
7936 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7937 dgst_pos0 = 0;
7938 dgst_pos1 = 1;
7939 dgst_pos2 = 2;
7940 dgst_pos3 = 3;
7941 break;
7942
7943 case 1600: hash_type = HASH_TYPE_MD5;
7944 salt_type = SALT_TYPE_EMBEDDED;
7945 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7946 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7947 kern_type = KERN_TYPE_APR1CRYPT;
7948 dgst_size = DGST_SIZE_4_4;
7949 parse_func = md5apr1_parse_hash;
7950 sort_by_digest = sort_by_digest_4_4;
7951 opti_type = OPTI_TYPE_ZERO_BYTE;
7952 dgst_pos0 = 0;
7953 dgst_pos1 = 1;
7954 dgst_pos2 = 2;
7955 dgst_pos3 = 3;
7956 break;
7957
7958 case 1700: hash_type = HASH_TYPE_SHA512;
7959 salt_type = SALT_TYPE_NONE;
7960 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7961 opts_type = OPTS_TYPE_PT_GENERATE_BE
7962 | OPTS_TYPE_PT_ADD80
7963 | OPTS_TYPE_PT_ADDBITS15;
7964 kern_type = KERN_TYPE_SHA512;
7965 dgst_size = DGST_SIZE_8_8;
7966 parse_func = sha512_parse_hash;
7967 sort_by_digest = sort_by_digest_8_8;
7968 opti_type = OPTI_TYPE_ZERO_BYTE
7969 | OPTI_TYPE_PRECOMPUTE_INIT
7970 | OPTI_TYPE_PRECOMPUTE_MERKLE
7971 | OPTI_TYPE_EARLY_SKIP
7972 | OPTI_TYPE_NOT_ITERATED
7973 | OPTI_TYPE_NOT_SALTED
7974 | OPTI_TYPE_USES_BITS_64
7975 | OPTI_TYPE_RAW_HASH;
7976 dgst_pos0 = 14;
7977 dgst_pos1 = 15;
7978 dgst_pos2 = 6;
7979 dgst_pos3 = 7;
7980 break;
7981
7982 case 1710: hash_type = HASH_TYPE_SHA512;
7983 salt_type = SALT_TYPE_INTERN;
7984 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7985 opts_type = OPTS_TYPE_PT_GENERATE_BE
7986 | OPTS_TYPE_ST_ADD80
7987 | OPTS_TYPE_ST_ADDBITS15;
7988 kern_type = KERN_TYPE_SHA512_PWSLT;
7989 dgst_size = DGST_SIZE_8_8;
7990 parse_func = sha512s_parse_hash;
7991 sort_by_digest = sort_by_digest_8_8;
7992 opti_type = OPTI_TYPE_ZERO_BYTE
7993 | OPTI_TYPE_PRECOMPUTE_INIT
7994 | OPTI_TYPE_PRECOMPUTE_MERKLE
7995 | OPTI_TYPE_EARLY_SKIP
7996 | OPTI_TYPE_NOT_ITERATED
7997 | OPTI_TYPE_APPENDED_SALT
7998 | OPTI_TYPE_USES_BITS_64
7999 | OPTI_TYPE_RAW_HASH;
8000 dgst_pos0 = 14;
8001 dgst_pos1 = 15;
8002 dgst_pos2 = 6;
8003 dgst_pos3 = 7;
8004 break;
8005
8006 case 1711: hash_type = HASH_TYPE_SHA512;
8007 salt_type = SALT_TYPE_EMBEDDED;
8008 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8009 opts_type = OPTS_TYPE_PT_GENERATE_BE
8010 | OPTS_TYPE_ST_ADD80
8011 | OPTS_TYPE_ST_ADDBITS15;
8012 kern_type = KERN_TYPE_SHA512_PWSLT;
8013 dgst_size = DGST_SIZE_8_8;
8014 parse_func = sha512b64s_parse_hash;
8015 sort_by_digest = sort_by_digest_8_8;
8016 opti_type = OPTI_TYPE_ZERO_BYTE
8017 | OPTI_TYPE_PRECOMPUTE_INIT
8018 | OPTI_TYPE_PRECOMPUTE_MERKLE
8019 | OPTI_TYPE_EARLY_SKIP
8020 | OPTI_TYPE_NOT_ITERATED
8021 | OPTI_TYPE_APPENDED_SALT
8022 | OPTI_TYPE_USES_BITS_64
8023 | OPTI_TYPE_RAW_HASH;
8024 dgst_pos0 = 14;
8025 dgst_pos1 = 15;
8026 dgst_pos2 = 6;
8027 dgst_pos3 = 7;
8028 break;
8029
8030 case 1720: hash_type = HASH_TYPE_SHA512;
8031 salt_type = SALT_TYPE_INTERN;
8032 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8033 opts_type = OPTS_TYPE_PT_GENERATE_BE
8034 | OPTS_TYPE_PT_ADD80
8035 | OPTS_TYPE_PT_ADDBITS15;
8036 kern_type = KERN_TYPE_SHA512_SLTPW;
8037 dgst_size = DGST_SIZE_8_8;
8038 parse_func = sha512s_parse_hash;
8039 sort_by_digest = sort_by_digest_8_8;
8040 opti_type = OPTI_TYPE_ZERO_BYTE
8041 | OPTI_TYPE_PRECOMPUTE_INIT
8042 | OPTI_TYPE_PRECOMPUTE_MERKLE
8043 | OPTI_TYPE_EARLY_SKIP
8044 | OPTI_TYPE_NOT_ITERATED
8045 | OPTI_TYPE_PREPENDED_SALT
8046 | OPTI_TYPE_USES_BITS_64
8047 | OPTI_TYPE_RAW_HASH;
8048 dgst_pos0 = 14;
8049 dgst_pos1 = 15;
8050 dgst_pos2 = 6;
8051 dgst_pos3 = 7;
8052 break;
8053
8054 case 1722: hash_type = HASH_TYPE_SHA512;
8055 salt_type = SALT_TYPE_EMBEDDED;
8056 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8057 opts_type = OPTS_TYPE_PT_GENERATE_BE
8058 | OPTS_TYPE_PT_ADD80
8059 | OPTS_TYPE_PT_ADDBITS15
8060 | OPTS_TYPE_ST_HEX;
8061 kern_type = KERN_TYPE_SHA512_SLTPW;
8062 dgst_size = DGST_SIZE_8_8;
8063 parse_func = osx512_parse_hash;
8064 sort_by_digest = sort_by_digest_8_8;
8065 opti_type = OPTI_TYPE_ZERO_BYTE
8066 | OPTI_TYPE_PRECOMPUTE_INIT
8067 | OPTI_TYPE_PRECOMPUTE_MERKLE
8068 | OPTI_TYPE_EARLY_SKIP
8069 | OPTI_TYPE_NOT_ITERATED
8070 | OPTI_TYPE_PREPENDED_SALT
8071 | OPTI_TYPE_USES_BITS_64
8072 | OPTI_TYPE_RAW_HASH;
8073 dgst_pos0 = 14;
8074 dgst_pos1 = 15;
8075 dgst_pos2 = 6;
8076 dgst_pos3 = 7;
8077 break;
8078
8079 case 1730: hash_type = HASH_TYPE_SHA512;
8080 salt_type = SALT_TYPE_INTERN;
8081 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8082 opts_type = OPTS_TYPE_PT_GENERATE_BE
8083 | OPTS_TYPE_PT_UNICODE
8084 | OPTS_TYPE_ST_ADD80
8085 | OPTS_TYPE_ST_ADDBITS15;
8086 kern_type = KERN_TYPE_SHA512_PWSLTU;
8087 dgst_size = DGST_SIZE_8_8;
8088 parse_func = sha512s_parse_hash;
8089 sort_by_digest = sort_by_digest_8_8;
8090 opti_type = OPTI_TYPE_ZERO_BYTE
8091 | OPTI_TYPE_PRECOMPUTE_INIT
8092 | OPTI_TYPE_PRECOMPUTE_MERKLE
8093 | OPTI_TYPE_EARLY_SKIP
8094 | OPTI_TYPE_NOT_ITERATED
8095 | OPTI_TYPE_APPENDED_SALT
8096 | OPTI_TYPE_USES_BITS_64
8097 | OPTI_TYPE_RAW_HASH;
8098 dgst_pos0 = 14;
8099 dgst_pos1 = 15;
8100 dgst_pos2 = 6;
8101 dgst_pos3 = 7;
8102 break;
8103
8104 case 1731: hash_type = HASH_TYPE_SHA512;
8105 salt_type = SALT_TYPE_EMBEDDED;
8106 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8107 opts_type = OPTS_TYPE_PT_GENERATE_BE
8108 | OPTS_TYPE_PT_UNICODE
8109 | OPTS_TYPE_ST_ADD80
8110 | OPTS_TYPE_ST_ADDBITS15
8111 | OPTS_TYPE_ST_HEX;
8112 kern_type = KERN_TYPE_SHA512_PWSLTU;
8113 dgst_size = DGST_SIZE_8_8;
8114 parse_func = mssql2012_parse_hash;
8115 sort_by_digest = sort_by_digest_8_8;
8116 opti_type = OPTI_TYPE_ZERO_BYTE
8117 | OPTI_TYPE_PRECOMPUTE_INIT
8118 | OPTI_TYPE_PRECOMPUTE_MERKLE
8119 | OPTI_TYPE_EARLY_SKIP
8120 | OPTI_TYPE_NOT_ITERATED
8121 | OPTI_TYPE_APPENDED_SALT
8122 | OPTI_TYPE_USES_BITS_64
8123 | OPTI_TYPE_RAW_HASH;
8124 dgst_pos0 = 14;
8125 dgst_pos1 = 15;
8126 dgst_pos2 = 6;
8127 dgst_pos3 = 7;
8128 break;
8129
8130 case 1740: hash_type = HASH_TYPE_SHA512;
8131 salt_type = SALT_TYPE_INTERN;
8132 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8133 opts_type = OPTS_TYPE_PT_GENERATE_BE
8134 | OPTS_TYPE_PT_ADD80
8135 | OPTS_TYPE_PT_ADDBITS15
8136 | OPTS_TYPE_PT_UNICODE;
8137 kern_type = KERN_TYPE_SHA512_SLTPWU;
8138 dgst_size = DGST_SIZE_8_8;
8139 parse_func = sha512s_parse_hash;
8140 sort_by_digest = sort_by_digest_8_8;
8141 opti_type = OPTI_TYPE_ZERO_BYTE
8142 | OPTI_TYPE_PRECOMPUTE_INIT
8143 | OPTI_TYPE_PRECOMPUTE_MERKLE
8144 | OPTI_TYPE_EARLY_SKIP
8145 | OPTI_TYPE_NOT_ITERATED
8146 | OPTI_TYPE_PREPENDED_SALT
8147 | OPTI_TYPE_USES_BITS_64
8148 | OPTI_TYPE_RAW_HASH;
8149 dgst_pos0 = 14;
8150 dgst_pos1 = 15;
8151 dgst_pos2 = 6;
8152 dgst_pos3 = 7;
8153 break;
8154
8155 case 1750: hash_type = HASH_TYPE_SHA512;
8156 salt_type = SALT_TYPE_INTERN;
8157 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8158 opts_type = OPTS_TYPE_PT_GENERATE_BE
8159 | OPTS_TYPE_ST_ADD80;
8160 kern_type = KERN_TYPE_HMACSHA512_PW;
8161 dgst_size = DGST_SIZE_8_8;
8162 parse_func = hmacsha512_parse_hash;
8163 sort_by_digest = sort_by_digest_8_8;
8164 opti_type = OPTI_TYPE_ZERO_BYTE
8165 | OPTI_TYPE_USES_BITS_64
8166 | OPTI_TYPE_NOT_ITERATED;
8167 dgst_pos0 = 14;
8168 dgst_pos1 = 15;
8169 dgst_pos2 = 6;
8170 dgst_pos3 = 7;
8171 break;
8172
8173 case 1760: hash_type = HASH_TYPE_SHA512;
8174 salt_type = SALT_TYPE_INTERN;
8175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8176 opts_type = OPTS_TYPE_PT_GENERATE_BE
8177 | OPTS_TYPE_PT_ADD80
8178 | OPTS_TYPE_PT_ADDBITS15;
8179 kern_type = KERN_TYPE_HMACSHA512_SLT;
8180 dgst_size = DGST_SIZE_8_8;
8181 parse_func = hmacsha512_parse_hash;
8182 sort_by_digest = sort_by_digest_8_8;
8183 opti_type = OPTI_TYPE_ZERO_BYTE
8184 | OPTI_TYPE_USES_BITS_64
8185 | OPTI_TYPE_NOT_ITERATED;
8186 dgst_pos0 = 14;
8187 dgst_pos1 = 15;
8188 dgst_pos2 = 6;
8189 dgst_pos3 = 7;
8190 break;
8191
8192 case 1800: hash_type = HASH_TYPE_SHA512;
8193 salt_type = SALT_TYPE_EMBEDDED;
8194 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8195 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8196 kern_type = KERN_TYPE_SHA512CRYPT;
8197 dgst_size = DGST_SIZE_8_8;
8198 parse_func = sha512crypt_parse_hash;
8199 sort_by_digest = sort_by_digest_8_8;
8200 opti_type = OPTI_TYPE_ZERO_BYTE
8201 | OPTI_TYPE_USES_BITS_64;
8202 dgst_pos0 = 0;
8203 dgst_pos1 = 1;
8204 dgst_pos2 = 2;
8205 dgst_pos3 = 3;
8206 break;
8207
8208 case 2100: hash_type = HASH_TYPE_DCC2;
8209 salt_type = SALT_TYPE_EMBEDDED;
8210 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8211 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8212 | OPTS_TYPE_ST_LOWER
8213 | OPTS_TYPE_ST_UNICODE;
8214 kern_type = KERN_TYPE_DCC2;
8215 dgst_size = DGST_SIZE_4_4;
8216 parse_func = dcc2_parse_hash;
8217 sort_by_digest = sort_by_digest_4_4;
8218 opti_type = OPTI_TYPE_ZERO_BYTE
8219 | OPTI_TYPE_SLOW_HASH_SIMD;
8220 dgst_pos0 = 0;
8221 dgst_pos1 = 1;
8222 dgst_pos2 = 2;
8223 dgst_pos3 = 3;
8224 break;
8225
8226 case 2400: hash_type = HASH_TYPE_MD5;
8227 salt_type = SALT_TYPE_NONE;
8228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8229 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8230 kern_type = KERN_TYPE_MD5PIX;
8231 dgst_size = DGST_SIZE_4_4;
8232 parse_func = md5pix_parse_hash;
8233 sort_by_digest = sort_by_digest_4_4;
8234 opti_type = OPTI_TYPE_ZERO_BYTE
8235 | OPTI_TYPE_PRECOMPUTE_INIT
8236 | OPTI_TYPE_PRECOMPUTE_MERKLE
8237 | OPTI_TYPE_EARLY_SKIP
8238 | OPTI_TYPE_NOT_ITERATED
8239 | OPTI_TYPE_NOT_SALTED;
8240 dgst_pos0 = 0;
8241 dgst_pos1 = 3;
8242 dgst_pos2 = 2;
8243 dgst_pos3 = 1;
8244 break;
8245
8246 case 2410: hash_type = HASH_TYPE_MD5;
8247 salt_type = SALT_TYPE_INTERN;
8248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8249 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8250 kern_type = KERN_TYPE_MD5ASA;
8251 dgst_size = DGST_SIZE_4_4;
8252 parse_func = md5asa_parse_hash;
8253 sort_by_digest = sort_by_digest_4_4;
8254 opti_type = OPTI_TYPE_ZERO_BYTE
8255 | OPTI_TYPE_PRECOMPUTE_INIT
8256 | OPTI_TYPE_PRECOMPUTE_MERKLE
8257 | OPTI_TYPE_EARLY_SKIP
8258 | OPTI_TYPE_NOT_ITERATED;
8259 dgst_pos0 = 0;
8260 dgst_pos1 = 3;
8261 dgst_pos2 = 2;
8262 dgst_pos3 = 1;
8263 break;
8264
8265 case 2500: hash_type = HASH_TYPE_WPA;
8266 salt_type = SALT_TYPE_EMBEDDED;
8267 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8268 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8269 kern_type = KERN_TYPE_WPA;
8270 dgst_size = DGST_SIZE_4_4;
8271 parse_func = wpa_parse_hash;
8272 sort_by_digest = sort_by_digest_4_4;
8273 opti_type = OPTI_TYPE_ZERO_BYTE
8274 | OPTI_TYPE_SLOW_HASH_SIMD;
8275 dgst_pos0 = 0;
8276 dgst_pos1 = 1;
8277 dgst_pos2 = 2;
8278 dgst_pos3 = 3;
8279 break;
8280
8281 case 2600: hash_type = HASH_TYPE_MD5;
8282 salt_type = SALT_TYPE_VIRTUAL;
8283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8284 opts_type = OPTS_TYPE_PT_GENERATE_LE
8285 | OPTS_TYPE_PT_ADD80
8286 | OPTS_TYPE_PT_ADDBITS14
8287 | OPTS_TYPE_ST_ADD80;
8288 kern_type = KERN_TYPE_MD55_PWSLT1;
8289 dgst_size = DGST_SIZE_4_4;
8290 parse_func = md5md5_parse_hash;
8291 sort_by_digest = sort_by_digest_4_4;
8292 opti_type = OPTI_TYPE_ZERO_BYTE
8293 | OPTI_TYPE_PRECOMPUTE_INIT
8294 | OPTI_TYPE_PRECOMPUTE_MERKLE
8295 | OPTI_TYPE_EARLY_SKIP;
8296 dgst_pos0 = 0;
8297 dgst_pos1 = 3;
8298 dgst_pos2 = 2;
8299 dgst_pos3 = 1;
8300 break;
8301
8302 case 2611: hash_type = HASH_TYPE_MD5;
8303 salt_type = SALT_TYPE_INTERN;
8304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8305 opts_type = OPTS_TYPE_PT_GENERATE_LE
8306 | OPTS_TYPE_PT_ADD80
8307 | OPTS_TYPE_PT_ADDBITS14
8308 | OPTS_TYPE_ST_ADD80;
8309 kern_type = KERN_TYPE_MD55_PWSLT1;
8310 dgst_size = DGST_SIZE_4_4;
8311 parse_func = vb3_parse_hash;
8312 sort_by_digest = sort_by_digest_4_4;
8313 opti_type = OPTI_TYPE_ZERO_BYTE
8314 | OPTI_TYPE_PRECOMPUTE_INIT
8315 | OPTI_TYPE_PRECOMPUTE_MERKLE
8316 | OPTI_TYPE_EARLY_SKIP;
8317 dgst_pos0 = 0;
8318 dgst_pos1 = 3;
8319 dgst_pos2 = 2;
8320 dgst_pos3 = 1;
8321 break;
8322
8323 case 2612: hash_type = HASH_TYPE_MD5;
8324 salt_type = SALT_TYPE_EMBEDDED;
8325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8326 opts_type = OPTS_TYPE_PT_GENERATE_LE
8327 | OPTS_TYPE_PT_ADD80
8328 | OPTS_TYPE_PT_ADDBITS14
8329 | OPTS_TYPE_ST_ADD80
8330 | OPTS_TYPE_ST_HEX;
8331 kern_type = KERN_TYPE_MD55_PWSLT1;
8332 dgst_size = DGST_SIZE_4_4;
8333 parse_func = phps_parse_hash;
8334 sort_by_digest = sort_by_digest_4_4;
8335 opti_type = OPTI_TYPE_ZERO_BYTE
8336 | OPTI_TYPE_PRECOMPUTE_INIT
8337 | OPTI_TYPE_PRECOMPUTE_MERKLE
8338 | OPTI_TYPE_EARLY_SKIP;
8339 dgst_pos0 = 0;
8340 dgst_pos1 = 3;
8341 dgst_pos2 = 2;
8342 dgst_pos3 = 1;
8343 break;
8344
8345 case 2711: hash_type = HASH_TYPE_MD5;
8346 salt_type = SALT_TYPE_INTERN;
8347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8348 opts_type = OPTS_TYPE_PT_GENERATE_LE
8349 | OPTS_TYPE_PT_ADD80
8350 | OPTS_TYPE_PT_ADDBITS14
8351 | OPTS_TYPE_ST_ADD80;
8352 kern_type = KERN_TYPE_MD55_PWSLT2;
8353 dgst_size = DGST_SIZE_4_4;
8354 parse_func = vb30_parse_hash;
8355 sort_by_digest = sort_by_digest_4_4;
8356 opti_type = OPTI_TYPE_ZERO_BYTE
8357 | OPTI_TYPE_PRECOMPUTE_INIT
8358 | OPTI_TYPE_EARLY_SKIP;
8359 dgst_pos0 = 0;
8360 dgst_pos1 = 3;
8361 dgst_pos2 = 2;
8362 dgst_pos3 = 1;
8363 break;
8364
8365 case 2811: hash_type = HASH_TYPE_MD5;
8366 salt_type = SALT_TYPE_INTERN;
8367 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8368 opts_type = OPTS_TYPE_PT_GENERATE_LE
8369 | OPTS_TYPE_PT_ADD80
8370 | OPTS_TYPE_PT_ADDBITS14;
8371 kern_type = KERN_TYPE_MD55_SLTPW;
8372 dgst_size = DGST_SIZE_4_4;
8373 parse_func = ipb2_parse_hash;
8374 sort_by_digest = sort_by_digest_4_4;
8375 opti_type = OPTI_TYPE_ZERO_BYTE
8376 | OPTI_TYPE_PRECOMPUTE_INIT
8377 | OPTI_TYPE_EARLY_SKIP;
8378 dgst_pos0 = 0;
8379 dgst_pos1 = 3;
8380 dgst_pos2 = 2;
8381 dgst_pos3 = 1;
8382 break;
8383
8384 case 3000: hash_type = HASH_TYPE_LM;
8385 salt_type = SALT_TYPE_NONE;
8386 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8387 opts_type = OPTS_TYPE_PT_GENERATE_LE
8388 | OPTS_TYPE_PT_UPPER
8389 | OPTS_TYPE_PT_BITSLICE;
8390 kern_type = KERN_TYPE_LM;
8391 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8392 parse_func = lm_parse_hash;
8393 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8394 opti_type = OPTI_TYPE_ZERO_BYTE
8395 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8396 dgst_pos0 = 0;
8397 dgst_pos1 = 1;
8398 dgst_pos2 = 2;
8399 dgst_pos3 = 3;
8400 break;
8401
8402 case 3100: hash_type = HASH_TYPE_ORACLEH;
8403 salt_type = SALT_TYPE_INTERN;
8404 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8405 opts_type = OPTS_TYPE_PT_GENERATE_LE
8406 | OPTS_TYPE_PT_UPPER
8407 | OPTS_TYPE_ST_UPPER;
8408 kern_type = KERN_TYPE_ORACLEH;
8409 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8410 parse_func = oracleh_parse_hash;
8411 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8412 opti_type = OPTI_TYPE_ZERO_BYTE;
8413 dgst_pos0 = 0;
8414 dgst_pos1 = 1;
8415 dgst_pos2 = 2;
8416 dgst_pos3 = 3;
8417 break;
8418
8419 case 3200: hash_type = HASH_TYPE_BCRYPT;
8420 salt_type = SALT_TYPE_EMBEDDED;
8421 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8422 opts_type = OPTS_TYPE_PT_GENERATE_LE
8423 | OPTS_TYPE_ST_GENERATE_LE;
8424 kern_type = KERN_TYPE_BCRYPT;
8425 dgst_size = DGST_SIZE_4_6;
8426 parse_func = bcrypt_parse_hash;
8427 sort_by_digest = sort_by_digest_4_6;
8428 opti_type = OPTI_TYPE_ZERO_BYTE;
8429 dgst_pos0 = 0;
8430 dgst_pos1 = 1;
8431 dgst_pos2 = 2;
8432 dgst_pos3 = 3;
8433 break;
8434
8435 case 3710: hash_type = HASH_TYPE_MD5;
8436 salt_type = SALT_TYPE_INTERN;
8437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8438 opts_type = OPTS_TYPE_PT_GENERATE_LE
8439 | OPTS_TYPE_PT_ADD80
8440 | OPTS_TYPE_PT_ADDBITS14;
8441 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8442 dgst_size = DGST_SIZE_4_4;
8443 parse_func = md5s_parse_hash;
8444 sort_by_digest = sort_by_digest_4_4;
8445 opti_type = OPTI_TYPE_ZERO_BYTE
8446 | OPTI_TYPE_PRECOMPUTE_INIT
8447 | OPTI_TYPE_PRECOMPUTE_MERKLE
8448 | OPTI_TYPE_EARLY_SKIP;
8449 dgst_pos0 = 0;
8450 dgst_pos1 = 3;
8451 dgst_pos2 = 2;
8452 dgst_pos3 = 1;
8453 break;
8454
8455 case 3711: hash_type = HASH_TYPE_MD5;
8456 salt_type = SALT_TYPE_EMBEDDED;
8457 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8458 opts_type = OPTS_TYPE_PT_GENERATE_LE
8459 | OPTS_TYPE_PT_ADD80
8460 | OPTS_TYPE_PT_ADDBITS14;
8461 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8462 dgst_size = DGST_SIZE_4_4;
8463 parse_func = mediawiki_b_parse_hash;
8464 sort_by_digest = sort_by_digest_4_4;
8465 opti_type = OPTI_TYPE_ZERO_BYTE
8466 | OPTI_TYPE_PRECOMPUTE_INIT
8467 | OPTI_TYPE_PRECOMPUTE_MERKLE
8468 | OPTI_TYPE_EARLY_SKIP;
8469 dgst_pos0 = 0;
8470 dgst_pos1 = 3;
8471 dgst_pos2 = 2;
8472 dgst_pos3 = 1;
8473 break;
8474
8475 case 3800: hash_type = HASH_TYPE_MD5;
8476 salt_type = SALT_TYPE_INTERN;
8477 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8478 opts_type = OPTS_TYPE_PT_GENERATE_LE
8479 | OPTS_TYPE_ST_ADDBITS14;
8480 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8481 dgst_size = DGST_SIZE_4_4;
8482 parse_func = md5s_parse_hash;
8483 sort_by_digest = sort_by_digest_4_4;
8484 opti_type = OPTI_TYPE_ZERO_BYTE
8485 | OPTI_TYPE_PRECOMPUTE_INIT
8486 | OPTI_TYPE_PRECOMPUTE_MERKLE
8487 | OPTI_TYPE_EARLY_SKIP
8488 | OPTI_TYPE_NOT_ITERATED
8489 | OPTI_TYPE_RAW_HASH;
8490 dgst_pos0 = 0;
8491 dgst_pos1 = 3;
8492 dgst_pos2 = 2;
8493 dgst_pos3 = 1;
8494 break;
8495
8496 case 4300: hash_type = HASH_TYPE_MD5;
8497 salt_type = SALT_TYPE_VIRTUAL;
8498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8499 opts_type = OPTS_TYPE_PT_GENERATE_LE
8500 | OPTS_TYPE_PT_ADD80
8501 | OPTS_TYPE_PT_ADDBITS14
8502 | OPTS_TYPE_ST_ADD80;
8503 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8504 dgst_size = DGST_SIZE_4_4;
8505 parse_func = md5md5_parse_hash;
8506 sort_by_digest = sort_by_digest_4_4;
8507 opti_type = OPTI_TYPE_ZERO_BYTE
8508 | OPTI_TYPE_PRECOMPUTE_INIT
8509 | OPTI_TYPE_PRECOMPUTE_MERKLE
8510 | OPTI_TYPE_EARLY_SKIP;
8511 dgst_pos0 = 0;
8512 dgst_pos1 = 3;
8513 dgst_pos2 = 2;
8514 dgst_pos3 = 1;
8515 break;
8516
8517
8518 case 4400: hash_type = HASH_TYPE_MD5;
8519 salt_type = SALT_TYPE_NONE;
8520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8521 opts_type = OPTS_TYPE_PT_GENERATE_BE
8522 | OPTS_TYPE_PT_ADD80
8523 | OPTS_TYPE_PT_ADDBITS15;
8524 kern_type = KERN_TYPE_MD5_SHA1;
8525 dgst_size = DGST_SIZE_4_4;
8526 parse_func = md5_parse_hash;
8527 sort_by_digest = sort_by_digest_4_4;
8528 opti_type = OPTI_TYPE_ZERO_BYTE
8529 | OPTI_TYPE_PRECOMPUTE_INIT
8530 | OPTI_TYPE_PRECOMPUTE_MERKLE
8531 | OPTI_TYPE_EARLY_SKIP
8532 | OPTI_TYPE_NOT_ITERATED
8533 | OPTI_TYPE_NOT_SALTED
8534 | OPTI_TYPE_RAW_HASH;
8535 dgst_pos0 = 0;
8536 dgst_pos1 = 3;
8537 dgst_pos2 = 2;
8538 dgst_pos3 = 1;
8539 break;
8540
8541 case 4500: hash_type = HASH_TYPE_SHA1;
8542 salt_type = SALT_TYPE_NONE;
8543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8544 opts_type = OPTS_TYPE_PT_GENERATE_BE
8545 | OPTS_TYPE_PT_ADD80
8546 | OPTS_TYPE_PT_ADDBITS15;
8547 kern_type = KERN_TYPE_SHA11;
8548 dgst_size = DGST_SIZE_4_5;
8549 parse_func = sha1_parse_hash;
8550 sort_by_digest = sort_by_digest_4_5;
8551 opti_type = OPTI_TYPE_ZERO_BYTE
8552 | OPTI_TYPE_PRECOMPUTE_INIT
8553 | OPTI_TYPE_PRECOMPUTE_MERKLE
8554 | OPTI_TYPE_EARLY_SKIP
8555 | OPTI_TYPE_NOT_SALTED;
8556 dgst_pos0 = 3;
8557 dgst_pos1 = 4;
8558 dgst_pos2 = 2;
8559 dgst_pos3 = 1;
8560 break;
8561
8562 case 4700: hash_type = HASH_TYPE_SHA1;
8563 salt_type = SALT_TYPE_NONE;
8564 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8565 opts_type = OPTS_TYPE_PT_GENERATE_LE
8566 | OPTS_TYPE_PT_ADD80
8567 | OPTS_TYPE_PT_ADDBITS14;
8568 kern_type = KERN_TYPE_SHA1_MD5;
8569 dgst_size = DGST_SIZE_4_5;
8570 parse_func = sha1_parse_hash;
8571 sort_by_digest = sort_by_digest_4_5;
8572 opti_type = OPTI_TYPE_ZERO_BYTE
8573 | OPTI_TYPE_PRECOMPUTE_INIT
8574 | OPTI_TYPE_PRECOMPUTE_MERKLE
8575 | OPTI_TYPE_EARLY_SKIP
8576 | OPTI_TYPE_NOT_ITERATED
8577 | OPTI_TYPE_NOT_SALTED
8578 | OPTI_TYPE_RAW_HASH;
8579 dgst_pos0 = 3;
8580 dgst_pos1 = 4;
8581 dgst_pos2 = 2;
8582 dgst_pos3 = 1;
8583 break;
8584
8585 case 4800: hash_type = HASH_TYPE_MD5;
8586 salt_type = SALT_TYPE_EMBEDDED;
8587 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8588 opts_type = OPTS_TYPE_PT_GENERATE_LE
8589 | OPTS_TYPE_PT_ADDBITS14;
8590 kern_type = KERN_TYPE_MD5_CHAP;
8591 dgst_size = DGST_SIZE_4_4;
8592 parse_func = chap_parse_hash;
8593 sort_by_digest = sort_by_digest_4_4;
8594 opti_type = OPTI_TYPE_ZERO_BYTE
8595 | OPTI_TYPE_PRECOMPUTE_INIT
8596 | OPTI_TYPE_PRECOMPUTE_MERKLE
8597 | OPTI_TYPE_MEET_IN_MIDDLE
8598 | OPTI_TYPE_EARLY_SKIP
8599 | OPTI_TYPE_NOT_ITERATED
8600 | OPTI_TYPE_RAW_HASH;
8601 dgst_pos0 = 0;
8602 dgst_pos1 = 3;
8603 dgst_pos2 = 2;
8604 dgst_pos3 = 1;
8605 break;
8606
8607 case 4900: hash_type = HASH_TYPE_SHA1;
8608 salt_type = SALT_TYPE_INTERN;
8609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8610 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8611 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8612 dgst_size = DGST_SIZE_4_5;
8613 parse_func = sha1s_parse_hash;
8614 sort_by_digest = sort_by_digest_4_5;
8615 opti_type = OPTI_TYPE_ZERO_BYTE
8616 | OPTI_TYPE_PRECOMPUTE_INIT
8617 | OPTI_TYPE_PRECOMPUTE_MERKLE
8618 | OPTI_TYPE_EARLY_SKIP;
8619 dgst_pos0 = 3;
8620 dgst_pos1 = 4;
8621 dgst_pos2 = 2;
8622 dgst_pos3 = 1;
8623 break;
8624
8625 case 5000: hash_type = HASH_TYPE_KECCAK;
8626 salt_type = SALT_TYPE_EMBEDDED;
8627 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8628 opts_type = OPTS_TYPE_PT_GENERATE_LE
8629 | OPTS_TYPE_PT_ADD01;
8630 kern_type = KERN_TYPE_KECCAK;
8631 dgst_size = DGST_SIZE_8_25;
8632 parse_func = keccak_parse_hash;
8633 sort_by_digest = sort_by_digest_8_25;
8634 opti_type = OPTI_TYPE_ZERO_BYTE
8635 | OPTI_TYPE_USES_BITS_64
8636 | OPTI_TYPE_RAW_HASH;
8637 dgst_pos0 = 2;
8638 dgst_pos1 = 3;
8639 dgst_pos2 = 4;
8640 dgst_pos3 = 5;
8641 break;
8642
8643 case 5100: hash_type = HASH_TYPE_MD5H;
8644 salt_type = SALT_TYPE_NONE;
8645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8646 opts_type = OPTS_TYPE_PT_GENERATE_LE
8647 | OPTS_TYPE_PT_ADD80
8648 | OPTS_TYPE_PT_ADDBITS14;
8649 kern_type = KERN_TYPE_MD5H;
8650 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8651 parse_func = md5half_parse_hash;
8652 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8653 opti_type = OPTI_TYPE_ZERO_BYTE
8654 | OPTI_TYPE_RAW_HASH;
8655 dgst_pos0 = 0;
8656 dgst_pos1 = 1;
8657 dgst_pos2 = 2;
8658 dgst_pos3 = 3;
8659 break;
8660
8661 case 5200: hash_type = HASH_TYPE_SHA256;
8662 salt_type = SALT_TYPE_EMBEDDED;
8663 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8664 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8665 kern_type = KERN_TYPE_PSAFE3;
8666 dgst_size = DGST_SIZE_4_8;
8667 parse_func = psafe3_parse_hash;
8668 sort_by_digest = sort_by_digest_4_8;
8669 opti_type = OPTI_TYPE_ZERO_BYTE;
8670 dgst_pos0 = 0;
8671 dgst_pos1 = 1;
8672 dgst_pos2 = 2;
8673 dgst_pos3 = 3;
8674 break;
8675
8676 case 5300: hash_type = HASH_TYPE_MD5;
8677 salt_type = SALT_TYPE_EMBEDDED;
8678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8679 opts_type = OPTS_TYPE_PT_GENERATE_LE
8680 | OPTS_TYPE_ST_ADD80;
8681 kern_type = KERN_TYPE_IKEPSK_MD5;
8682 dgst_size = DGST_SIZE_4_4;
8683 parse_func = ikepsk_md5_parse_hash;
8684 sort_by_digest = sort_by_digest_4_4;
8685 opti_type = OPTI_TYPE_ZERO_BYTE;
8686 dgst_pos0 = 0;
8687 dgst_pos1 = 3;
8688 dgst_pos2 = 2;
8689 dgst_pos3 = 1;
8690 break;
8691
8692 case 5400: hash_type = HASH_TYPE_SHA1;
8693 salt_type = SALT_TYPE_EMBEDDED;
8694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8695 opts_type = OPTS_TYPE_PT_GENERATE_BE
8696 | OPTS_TYPE_ST_ADD80;
8697 kern_type = KERN_TYPE_IKEPSK_SHA1;
8698 dgst_size = DGST_SIZE_4_5;
8699 parse_func = ikepsk_sha1_parse_hash;
8700 sort_by_digest = sort_by_digest_4_5;
8701 opti_type = OPTI_TYPE_ZERO_BYTE;
8702 dgst_pos0 = 3;
8703 dgst_pos1 = 4;
8704 dgst_pos2 = 2;
8705 dgst_pos3 = 1;
8706 break;
8707
8708 case 5500: hash_type = HASH_TYPE_NETNTLM;
8709 salt_type = SALT_TYPE_EMBEDDED;
8710 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8711 opts_type = OPTS_TYPE_PT_GENERATE_LE
8712 | OPTS_TYPE_PT_ADD80
8713 | OPTS_TYPE_PT_ADDBITS14
8714 | OPTS_TYPE_PT_UNICODE
8715 | OPTS_TYPE_ST_HEX;
8716 kern_type = KERN_TYPE_NETNTLMv1;
8717 dgst_size = DGST_SIZE_4_4;
8718 parse_func = netntlmv1_parse_hash;
8719 sort_by_digest = sort_by_digest_4_4;
8720 opti_type = OPTI_TYPE_ZERO_BYTE
8721 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8722 dgst_pos0 = 0;
8723 dgst_pos1 = 1;
8724 dgst_pos2 = 2;
8725 dgst_pos3 = 3;
8726 break;
8727
8728 case 5600: hash_type = HASH_TYPE_MD5;
8729 salt_type = SALT_TYPE_EMBEDDED;
8730 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8731 opts_type = OPTS_TYPE_PT_GENERATE_LE
8732 | OPTS_TYPE_PT_ADD80
8733 | OPTS_TYPE_PT_ADDBITS14
8734 | OPTS_TYPE_PT_UNICODE;
8735 kern_type = KERN_TYPE_NETNTLMv2;
8736 dgst_size = DGST_SIZE_4_4;
8737 parse_func = netntlmv2_parse_hash;
8738 sort_by_digest = sort_by_digest_4_4;
8739 opti_type = OPTI_TYPE_ZERO_BYTE;
8740 dgst_pos0 = 0;
8741 dgst_pos1 = 3;
8742 dgst_pos2 = 2;
8743 dgst_pos3 = 1;
8744 break;
8745
8746 case 5700: hash_type = HASH_TYPE_SHA256;
8747 salt_type = SALT_TYPE_NONE;
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 kern_type = KERN_TYPE_SHA256;
8753 dgst_size = DGST_SIZE_4_8;
8754 parse_func = cisco4_parse_hash;
8755 sort_by_digest = sort_by_digest_4_8;
8756 opti_type = OPTI_TYPE_ZERO_BYTE
8757 | OPTI_TYPE_PRECOMPUTE_INIT
8758 | OPTI_TYPE_PRECOMPUTE_MERKLE
8759 | OPTI_TYPE_EARLY_SKIP
8760 | OPTI_TYPE_NOT_ITERATED
8761 | OPTI_TYPE_NOT_SALTED
8762 | OPTI_TYPE_RAW_HASH;
8763 dgst_pos0 = 3;
8764 dgst_pos1 = 7;
8765 dgst_pos2 = 2;
8766 dgst_pos3 = 6;
8767 break;
8768
8769 case 5800: hash_type = HASH_TYPE_SHA1;
8770 salt_type = SALT_TYPE_INTERN;
8771 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8772 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8773 | OPTS_TYPE_ST_ADD80;
8774 kern_type = KERN_TYPE_ANDROIDPIN;
8775 dgst_size = DGST_SIZE_4_5;
8776 parse_func = androidpin_parse_hash;
8777 sort_by_digest = sort_by_digest_4_5;
8778 opti_type = OPTI_TYPE_ZERO_BYTE;
8779 dgst_pos0 = 0;
8780 dgst_pos1 = 1;
8781 dgst_pos2 = 2;
8782 dgst_pos3 = 3;
8783 break;
8784
8785 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8786 salt_type = SALT_TYPE_NONE;
8787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8788 opts_type = OPTS_TYPE_PT_GENERATE_LE
8789 | OPTS_TYPE_PT_ADD80;
8790 kern_type = KERN_TYPE_RIPEMD160;
8791 dgst_size = DGST_SIZE_4_5;
8792 parse_func = ripemd160_parse_hash;
8793 sort_by_digest = sort_by_digest_4_5;
8794 opti_type = OPTI_TYPE_ZERO_BYTE;
8795 dgst_pos0 = 0;
8796 dgst_pos1 = 1;
8797 dgst_pos2 = 2;
8798 dgst_pos3 = 3;
8799 break;
8800
8801 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8802 salt_type = SALT_TYPE_NONE;
8803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8804 opts_type = OPTS_TYPE_PT_GENERATE_BE
8805 | OPTS_TYPE_PT_ADD80;
8806 kern_type = KERN_TYPE_WHIRLPOOL;
8807 dgst_size = DGST_SIZE_4_16;
8808 parse_func = whirlpool_parse_hash;
8809 sort_by_digest = sort_by_digest_4_16;
8810 opti_type = OPTI_TYPE_ZERO_BYTE;
8811 dgst_pos0 = 0;
8812 dgst_pos1 = 1;
8813 dgst_pos2 = 2;
8814 dgst_pos3 = 3;
8815 break;
8816
8817 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8818 salt_type = SALT_TYPE_EMBEDDED;
8819 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8820 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8821 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8822 dgst_size = DGST_SIZE_4_5;
8823 parse_func = truecrypt_parse_hash_2k;
8824 sort_by_digest = sort_by_digest_4_5;
8825 opti_type = OPTI_TYPE_ZERO_BYTE;
8826 dgst_pos0 = 0;
8827 dgst_pos1 = 1;
8828 dgst_pos2 = 2;
8829 dgst_pos3 = 3;
8830 break;
8831
8832 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8833 salt_type = SALT_TYPE_EMBEDDED;
8834 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8835 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8836 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8837 dgst_size = DGST_SIZE_4_5;
8838 parse_func = truecrypt_parse_hash_2k;
8839 sort_by_digest = sort_by_digest_4_5;
8840 opti_type = OPTI_TYPE_ZERO_BYTE;
8841 dgst_pos0 = 0;
8842 dgst_pos1 = 1;
8843 dgst_pos2 = 2;
8844 dgst_pos3 = 3;
8845 break;
8846
8847 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8848 salt_type = SALT_TYPE_EMBEDDED;
8849 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8850 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8851 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8852 dgst_size = DGST_SIZE_4_5;
8853 parse_func = truecrypt_parse_hash_2k;
8854 sort_by_digest = sort_by_digest_4_5;
8855 opti_type = OPTI_TYPE_ZERO_BYTE;
8856 dgst_pos0 = 0;
8857 dgst_pos1 = 1;
8858 dgst_pos2 = 2;
8859 dgst_pos3 = 3;
8860 break;
8861
8862 case 6221: hash_type = HASH_TYPE_SHA512;
8863 salt_type = SALT_TYPE_EMBEDDED;
8864 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8865 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8866 kern_type = KERN_TYPE_TCSHA512_XTS512;
8867 dgst_size = DGST_SIZE_8_8;
8868 parse_func = truecrypt_parse_hash_1k;
8869 sort_by_digest = sort_by_digest_8_8;
8870 opti_type = OPTI_TYPE_ZERO_BYTE
8871 | OPTI_TYPE_USES_BITS_64;
8872 dgst_pos0 = 0;
8873 dgst_pos1 = 1;
8874 dgst_pos2 = 2;
8875 dgst_pos3 = 3;
8876 break;
8877
8878 case 6222: hash_type = HASH_TYPE_SHA512;
8879 salt_type = SALT_TYPE_EMBEDDED;
8880 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8881 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8882 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8883 dgst_size = DGST_SIZE_8_8;
8884 parse_func = truecrypt_parse_hash_1k;
8885 sort_by_digest = sort_by_digest_8_8;
8886 opti_type = OPTI_TYPE_ZERO_BYTE
8887 | OPTI_TYPE_USES_BITS_64;
8888 dgst_pos0 = 0;
8889 dgst_pos1 = 1;
8890 dgst_pos2 = 2;
8891 dgst_pos3 = 3;
8892 break;
8893
8894 case 6223: hash_type = HASH_TYPE_SHA512;
8895 salt_type = SALT_TYPE_EMBEDDED;
8896 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8897 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8898 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8899 dgst_size = DGST_SIZE_8_8;
8900 parse_func = truecrypt_parse_hash_1k;
8901 sort_by_digest = sort_by_digest_8_8;
8902 opti_type = OPTI_TYPE_ZERO_BYTE
8903 | OPTI_TYPE_USES_BITS_64;
8904 dgst_pos0 = 0;
8905 dgst_pos1 = 1;
8906 dgst_pos2 = 2;
8907 dgst_pos3 = 3;
8908 break;
8909
8910 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8911 salt_type = SALT_TYPE_EMBEDDED;
8912 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8913 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8914 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8915 dgst_size = DGST_SIZE_4_8;
8916 parse_func = truecrypt_parse_hash_1k;
8917 sort_by_digest = sort_by_digest_4_8;
8918 opti_type = OPTI_TYPE_ZERO_BYTE;
8919 dgst_pos0 = 0;
8920 dgst_pos1 = 1;
8921 dgst_pos2 = 2;
8922 dgst_pos3 = 3;
8923 break;
8924
8925 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8926 salt_type = SALT_TYPE_EMBEDDED;
8927 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8928 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8929 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8930 dgst_size = DGST_SIZE_4_8;
8931 parse_func = truecrypt_parse_hash_1k;
8932 sort_by_digest = sort_by_digest_4_8;
8933 opti_type = OPTI_TYPE_ZERO_BYTE;
8934 dgst_pos0 = 0;
8935 dgst_pos1 = 1;
8936 dgst_pos2 = 2;
8937 dgst_pos3 = 3;
8938 break;
8939
8940 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8941 salt_type = SALT_TYPE_EMBEDDED;
8942 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8943 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8944 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8945 dgst_size = DGST_SIZE_4_8;
8946 parse_func = truecrypt_parse_hash_1k;
8947 sort_by_digest = sort_by_digest_4_8;
8948 opti_type = OPTI_TYPE_ZERO_BYTE;
8949 dgst_pos0 = 0;
8950 dgst_pos1 = 1;
8951 dgst_pos2 = 2;
8952 dgst_pos3 = 3;
8953 break;
8954
8955 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8956 salt_type = SALT_TYPE_EMBEDDED;
8957 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8958 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8959 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8960 dgst_size = DGST_SIZE_4_5;
8961 parse_func = truecrypt_parse_hash_1k;
8962 sort_by_digest = sort_by_digest_4_5;
8963 opti_type = OPTI_TYPE_ZERO_BYTE;
8964 dgst_pos0 = 0;
8965 dgst_pos1 = 1;
8966 dgst_pos2 = 2;
8967 dgst_pos3 = 3;
8968 break;
8969
8970 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8971 salt_type = SALT_TYPE_EMBEDDED;
8972 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8973 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8974 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8975 dgst_size = DGST_SIZE_4_5;
8976 parse_func = truecrypt_parse_hash_1k;
8977 sort_by_digest = sort_by_digest_4_5;
8978 opti_type = OPTI_TYPE_ZERO_BYTE;
8979 dgst_pos0 = 0;
8980 dgst_pos1 = 1;
8981 dgst_pos2 = 2;
8982 dgst_pos3 = 3;
8983 break;
8984
8985 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8986 salt_type = SALT_TYPE_EMBEDDED;
8987 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8988 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8989 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8990 dgst_size = DGST_SIZE_4_5;
8991 parse_func = truecrypt_parse_hash_1k;
8992 sort_by_digest = sort_by_digest_4_5;
8993 opti_type = OPTI_TYPE_ZERO_BYTE;
8994 dgst_pos0 = 0;
8995 dgst_pos1 = 1;
8996 dgst_pos2 = 2;
8997 dgst_pos3 = 3;
8998 break;
8999
9000 case 6300: hash_type = HASH_TYPE_MD5;
9001 salt_type = SALT_TYPE_EMBEDDED;
9002 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9003 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9004 kern_type = KERN_TYPE_MD5AIX;
9005 dgst_size = DGST_SIZE_4_4;
9006 parse_func = md5aix_parse_hash;
9007 sort_by_digest = sort_by_digest_4_4;
9008 opti_type = OPTI_TYPE_ZERO_BYTE;
9009 dgst_pos0 = 0;
9010 dgst_pos1 = 1;
9011 dgst_pos2 = 2;
9012 dgst_pos3 = 3;
9013 break;
9014
9015 case 6400: hash_type = HASH_TYPE_SHA256;
9016 salt_type = SALT_TYPE_EMBEDDED;
9017 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9018 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9019 kern_type = KERN_TYPE_SHA256AIX;
9020 dgst_size = DGST_SIZE_4_8;
9021 parse_func = sha256aix_parse_hash;
9022 sort_by_digest = sort_by_digest_4_8;
9023 opti_type = OPTI_TYPE_ZERO_BYTE;
9024 dgst_pos0 = 0;
9025 dgst_pos1 = 1;
9026 dgst_pos2 = 2;
9027 dgst_pos3 = 3;
9028 break;
9029
9030 case 6500: hash_type = HASH_TYPE_SHA512;
9031 salt_type = SALT_TYPE_EMBEDDED;
9032 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9033 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9034 kern_type = KERN_TYPE_SHA512AIX;
9035 dgst_size = DGST_SIZE_8_8;
9036 parse_func = sha512aix_parse_hash;
9037 sort_by_digest = sort_by_digest_8_8;
9038 opti_type = OPTI_TYPE_ZERO_BYTE
9039 | OPTI_TYPE_USES_BITS_64;
9040 dgst_pos0 = 0;
9041 dgst_pos1 = 1;
9042 dgst_pos2 = 2;
9043 dgst_pos3 = 3;
9044 break;
9045
9046 case 6600: hash_type = HASH_TYPE_AES;
9047 salt_type = SALT_TYPE_EMBEDDED;
9048 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9049 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9050 kern_type = KERN_TYPE_AGILEKEY;
9051 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9052 parse_func = agilekey_parse_hash;
9053 sort_by_digest = sort_by_digest_4_5;
9054 opti_type = OPTI_TYPE_ZERO_BYTE;
9055 dgst_pos0 = 0;
9056 dgst_pos1 = 1;
9057 dgst_pos2 = 2;
9058 dgst_pos3 = 3;
9059 break;
9060
9061 case 6700: hash_type = HASH_TYPE_SHA1;
9062 salt_type = SALT_TYPE_EMBEDDED;
9063 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9064 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9065 kern_type = KERN_TYPE_SHA1AIX;
9066 dgst_size = DGST_SIZE_4_5;
9067 parse_func = sha1aix_parse_hash;
9068 sort_by_digest = sort_by_digest_4_5;
9069 opti_type = OPTI_TYPE_ZERO_BYTE;
9070 dgst_pos0 = 0;
9071 dgst_pos1 = 1;
9072 dgst_pos2 = 2;
9073 dgst_pos3 = 3;
9074 break;
9075
9076 case 6800: hash_type = HASH_TYPE_AES;
9077 salt_type = SALT_TYPE_EMBEDDED;
9078 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9079 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9080 kern_type = KERN_TYPE_LASTPASS;
9081 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9082 parse_func = lastpass_parse_hash;
9083 sort_by_digest = sort_by_digest_4_8;
9084 opti_type = OPTI_TYPE_ZERO_BYTE;
9085 dgst_pos0 = 0;
9086 dgst_pos1 = 1;
9087 dgst_pos2 = 2;
9088 dgst_pos3 = 3;
9089 break;
9090
9091 case 6900: hash_type = HASH_TYPE_GOST;
9092 salt_type = SALT_TYPE_NONE;
9093 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9094 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9095 kern_type = KERN_TYPE_GOST;
9096 dgst_size = DGST_SIZE_4_8;
9097 parse_func = gost_parse_hash;
9098 sort_by_digest = sort_by_digest_4_8;
9099 opti_type = OPTI_TYPE_ZERO_BYTE;
9100 dgst_pos0 = 0;
9101 dgst_pos1 = 1;
9102 dgst_pos2 = 2;
9103 dgst_pos3 = 3;
9104 break;
9105
9106 case 7100: hash_type = HASH_TYPE_SHA512;
9107 salt_type = SALT_TYPE_EMBEDDED;
9108 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9109 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9110 kern_type = KERN_TYPE_PBKDF2_SHA512;
9111 dgst_size = DGST_SIZE_8_16;
9112 parse_func = sha512osx_parse_hash;
9113 sort_by_digest = sort_by_digest_8_16;
9114 opti_type = OPTI_TYPE_ZERO_BYTE
9115 | OPTI_TYPE_USES_BITS_64
9116 | OPTI_TYPE_SLOW_HASH_SIMD;
9117 dgst_pos0 = 0;
9118 dgst_pos1 = 1;
9119 dgst_pos2 = 2;
9120 dgst_pos3 = 3;
9121 break;
9122
9123 case 7200: hash_type = HASH_TYPE_SHA512;
9124 salt_type = SALT_TYPE_EMBEDDED;
9125 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9126 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9127 kern_type = KERN_TYPE_PBKDF2_SHA512;
9128 dgst_size = DGST_SIZE_8_16;
9129 parse_func = sha512grub_parse_hash;
9130 sort_by_digest = sort_by_digest_8_16;
9131 opti_type = OPTI_TYPE_ZERO_BYTE
9132 | OPTI_TYPE_USES_BITS_64
9133 | OPTI_TYPE_SLOW_HASH_SIMD;
9134 dgst_pos0 = 0;
9135 dgst_pos1 = 1;
9136 dgst_pos2 = 2;
9137 dgst_pos3 = 3;
9138 break;
9139
9140 case 7300: hash_type = HASH_TYPE_SHA1;
9141 salt_type = SALT_TYPE_EMBEDDED;
9142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9143 opts_type = OPTS_TYPE_PT_GENERATE_BE
9144 | OPTS_TYPE_ST_ADD80
9145 | OPTS_TYPE_ST_ADDBITS15;
9146 kern_type = KERN_TYPE_RAKP;
9147 dgst_size = DGST_SIZE_4_5;
9148 parse_func = rakp_parse_hash;
9149 sort_by_digest = sort_by_digest_4_5;
9150 opti_type = OPTI_TYPE_ZERO_BYTE
9151 | OPTI_TYPE_NOT_ITERATED;
9152 dgst_pos0 = 3;
9153 dgst_pos1 = 4;
9154 dgst_pos2 = 2;
9155 dgst_pos3 = 1;
9156 break;
9157
9158 case 7400: hash_type = HASH_TYPE_SHA256;
9159 salt_type = SALT_TYPE_EMBEDDED;
9160 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9161 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9162 kern_type = KERN_TYPE_SHA256CRYPT;
9163 dgst_size = DGST_SIZE_4_8;
9164 parse_func = sha256crypt_parse_hash;
9165 sort_by_digest = sort_by_digest_4_8;
9166 opti_type = OPTI_TYPE_ZERO_BYTE;
9167 dgst_pos0 = 0;
9168 dgst_pos1 = 1;
9169 dgst_pos2 = 2;
9170 dgst_pos3 = 3;
9171 break;
9172
9173 case 7500: hash_type = HASH_TYPE_KRB5PA;
9174 salt_type = SALT_TYPE_EMBEDDED;
9175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9176 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9177 kern_type = KERN_TYPE_KRB5PA;
9178 dgst_size = DGST_SIZE_4_4;
9179 parse_func = krb5pa_parse_hash;
9180 sort_by_digest = sort_by_digest_4_4;
9181 opti_type = OPTI_TYPE_ZERO_BYTE
9182 | OPTI_TYPE_NOT_ITERATED;
9183 dgst_pos0 = 0;
9184 dgst_pos1 = 1;
9185 dgst_pos2 = 2;
9186 dgst_pos3 = 3;
9187 break;
9188
9189 case 7600: hash_type = HASH_TYPE_SHA1;
9190 salt_type = SALT_TYPE_INTERN;
9191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9192 opts_type = OPTS_TYPE_PT_GENERATE_BE
9193 | OPTS_TYPE_PT_ADD80
9194 | OPTS_TYPE_PT_ADDBITS15;
9195 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9196 dgst_size = DGST_SIZE_4_5;
9197 parse_func = redmine_parse_hash;
9198 sort_by_digest = sort_by_digest_4_5;
9199 opti_type = OPTI_TYPE_ZERO_BYTE
9200 | OPTI_TYPE_PRECOMPUTE_INIT
9201 | OPTI_TYPE_EARLY_SKIP
9202 | OPTI_TYPE_NOT_ITERATED
9203 | OPTI_TYPE_PREPENDED_SALT;
9204 dgst_pos0 = 3;
9205 dgst_pos1 = 4;
9206 dgst_pos2 = 2;
9207 dgst_pos3 = 1;
9208 break;
9209
9210 case 7700: hash_type = HASH_TYPE_SAPB;
9211 salt_type = SALT_TYPE_EMBEDDED;
9212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9213 opts_type = OPTS_TYPE_PT_GENERATE_LE
9214 | OPTS_TYPE_PT_UPPER
9215 | OPTS_TYPE_ST_UPPER;
9216 kern_type = KERN_TYPE_SAPB;
9217 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9218 parse_func = sapb_parse_hash;
9219 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9220 opti_type = OPTI_TYPE_ZERO_BYTE
9221 | OPTI_TYPE_PRECOMPUTE_INIT
9222 | OPTI_TYPE_NOT_ITERATED;
9223 dgst_pos0 = 0;
9224 dgst_pos1 = 1;
9225 dgst_pos2 = 2;
9226 dgst_pos3 = 3;
9227 break;
9228
9229 case 7800: hash_type = HASH_TYPE_SAPG;
9230 salt_type = SALT_TYPE_EMBEDDED;
9231 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9232 opts_type = OPTS_TYPE_PT_GENERATE_BE
9233 | OPTS_TYPE_ST_ADD80
9234 | OPTS_TYPE_ST_UPPER;
9235 kern_type = KERN_TYPE_SAPG;
9236 dgst_size = DGST_SIZE_4_5;
9237 parse_func = sapg_parse_hash;
9238 sort_by_digest = sort_by_digest_4_5;
9239 opti_type = OPTI_TYPE_ZERO_BYTE
9240 | OPTI_TYPE_PRECOMPUTE_INIT
9241 | OPTI_TYPE_NOT_ITERATED;
9242 dgst_pos0 = 3;
9243 dgst_pos1 = 4;
9244 dgst_pos2 = 2;
9245 dgst_pos3 = 1;
9246 break;
9247
9248 case 7900: hash_type = HASH_TYPE_SHA512;
9249 salt_type = SALT_TYPE_EMBEDDED;
9250 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9251 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9252 kern_type = KERN_TYPE_DRUPAL7;
9253 dgst_size = DGST_SIZE_8_8;
9254 parse_func = drupal7_parse_hash;
9255 sort_by_digest = sort_by_digest_8_8;
9256 opti_type = OPTI_TYPE_ZERO_BYTE
9257 | OPTI_TYPE_USES_BITS_64;
9258 dgst_pos0 = 0;
9259 dgst_pos1 = 1;
9260 dgst_pos2 = 2;
9261 dgst_pos3 = 3;
9262 break;
9263
9264 case 8000: hash_type = HASH_TYPE_SHA256;
9265 salt_type = SALT_TYPE_EMBEDDED;
9266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9267 opts_type = OPTS_TYPE_PT_GENERATE_BE
9268 | OPTS_TYPE_PT_UNICODE
9269 | OPTS_TYPE_ST_ADD80
9270 | OPTS_TYPE_ST_HEX;
9271 kern_type = KERN_TYPE_SYBASEASE;
9272 dgst_size = DGST_SIZE_4_8;
9273 parse_func = sybasease_parse_hash;
9274 sort_by_digest = sort_by_digest_4_8;
9275 opti_type = OPTI_TYPE_ZERO_BYTE
9276 | OPTI_TYPE_PRECOMPUTE_INIT
9277 | OPTI_TYPE_EARLY_SKIP
9278 | OPTI_TYPE_NOT_ITERATED
9279 | OPTI_TYPE_RAW_HASH;
9280 dgst_pos0 = 3;
9281 dgst_pos1 = 7;
9282 dgst_pos2 = 2;
9283 dgst_pos3 = 6;
9284 break;
9285
9286 case 8100: hash_type = HASH_TYPE_SHA1;
9287 salt_type = SALT_TYPE_EMBEDDED;
9288 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9289 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9290 kern_type = KERN_TYPE_NETSCALER;
9291 dgst_size = DGST_SIZE_4_5;
9292 parse_func = netscaler_parse_hash;
9293 sort_by_digest = sort_by_digest_4_5;
9294 opti_type = OPTI_TYPE_ZERO_BYTE
9295 | OPTI_TYPE_PRECOMPUTE_INIT
9296 | OPTI_TYPE_PRECOMPUTE_MERKLE
9297 | OPTI_TYPE_EARLY_SKIP
9298 | OPTI_TYPE_NOT_ITERATED
9299 | OPTI_TYPE_PREPENDED_SALT
9300 | OPTI_TYPE_RAW_HASH;
9301 dgst_pos0 = 3;
9302 dgst_pos1 = 4;
9303 dgst_pos2 = 2;
9304 dgst_pos3 = 1;
9305 break;
9306
9307 case 8200: hash_type = HASH_TYPE_SHA256;
9308 salt_type = SALT_TYPE_EMBEDDED;
9309 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9310 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9311 kern_type = KERN_TYPE_CLOUDKEY;
9312 dgst_size = DGST_SIZE_4_8;
9313 parse_func = cloudkey_parse_hash;
9314 sort_by_digest = sort_by_digest_4_8;
9315 opti_type = OPTI_TYPE_ZERO_BYTE;
9316 dgst_pos0 = 0;
9317 dgst_pos1 = 1;
9318 dgst_pos2 = 2;
9319 dgst_pos3 = 3;
9320 break;
9321
9322 case 8300: hash_type = HASH_TYPE_SHA1;
9323 salt_type = SALT_TYPE_EMBEDDED;
9324 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9325 opts_type = OPTS_TYPE_PT_GENERATE_BE
9326 | OPTS_TYPE_ST_HEX
9327 | OPTS_TYPE_ST_ADD80;
9328 kern_type = KERN_TYPE_NSEC3;
9329 dgst_size = DGST_SIZE_4_5;
9330 parse_func = nsec3_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 8400: hash_type = HASH_TYPE_SHA1;
9340 salt_type = SALT_TYPE_INTERN;
9341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9342 opts_type = OPTS_TYPE_PT_GENERATE_BE
9343 | OPTS_TYPE_PT_ADD80
9344 | OPTS_TYPE_PT_ADDBITS15;
9345 kern_type = KERN_TYPE_WBB3;
9346 dgst_size = DGST_SIZE_4_5;
9347 parse_func = wbb3_parse_hash;
9348 sort_by_digest = sort_by_digest_4_5;
9349 opti_type = OPTI_TYPE_ZERO_BYTE
9350 | OPTI_TYPE_PRECOMPUTE_INIT
9351 | OPTI_TYPE_NOT_ITERATED;
9352 dgst_pos0 = 3;
9353 dgst_pos1 = 4;
9354 dgst_pos2 = 2;
9355 dgst_pos3 = 1;
9356 break;
9357
9358 case 8500: hash_type = HASH_TYPE_DESRACF;
9359 salt_type = SALT_TYPE_EMBEDDED;
9360 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9361 opts_type = OPTS_TYPE_PT_GENERATE_LE
9362 | OPTS_TYPE_ST_UPPER;
9363 kern_type = KERN_TYPE_RACF;
9364 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9365 parse_func = racf_parse_hash;
9366 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9367 opti_type = OPTI_TYPE_ZERO_BYTE
9368 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9369 dgst_pos0 = 0;
9370 dgst_pos1 = 1;
9371 dgst_pos2 = 2;
9372 dgst_pos3 = 3;
9373 break;
9374
9375 case 8600: hash_type = HASH_TYPE_LOTUS5;
9376 salt_type = SALT_TYPE_NONE;
9377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9378 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9379 kern_type = KERN_TYPE_LOTUS5;
9380 dgst_size = DGST_SIZE_4_4;
9381 parse_func = lotus5_parse_hash;
9382 sort_by_digest = sort_by_digest_4_4;
9383 opti_type = OPTI_TYPE_EARLY_SKIP
9384 | OPTI_TYPE_NOT_ITERATED
9385 | OPTI_TYPE_NOT_SALTED
9386 | OPTI_TYPE_RAW_HASH;
9387 dgst_pos0 = 0;
9388 dgst_pos1 = 1;
9389 dgst_pos2 = 2;
9390 dgst_pos3 = 3;
9391 break;
9392
9393 case 8700: hash_type = HASH_TYPE_LOTUS6;
9394 salt_type = SALT_TYPE_EMBEDDED;
9395 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9396 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9397 kern_type = KERN_TYPE_LOTUS6;
9398 dgst_size = DGST_SIZE_4_4;
9399 parse_func = lotus6_parse_hash;
9400 sort_by_digest = sort_by_digest_4_4;
9401 opti_type = OPTI_TYPE_EARLY_SKIP
9402 | OPTI_TYPE_NOT_ITERATED
9403 | OPTI_TYPE_RAW_HASH;
9404 dgst_pos0 = 0;
9405 dgst_pos1 = 1;
9406 dgst_pos2 = 2;
9407 dgst_pos3 = 3;
9408 break;
9409
9410 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9411 salt_type = SALT_TYPE_EMBEDDED;
9412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9413 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9414 kern_type = KERN_TYPE_ANDROIDFDE;
9415 dgst_size = DGST_SIZE_4_4;
9416 parse_func = androidfde_parse_hash;
9417 sort_by_digest = sort_by_digest_4_4;
9418 opti_type = OPTI_TYPE_ZERO_BYTE;
9419 dgst_pos0 = 0;
9420 dgst_pos1 = 1;
9421 dgst_pos2 = 2;
9422 dgst_pos3 = 3;
9423 break;
9424
9425 case 8900: hash_type = HASH_TYPE_SCRYPT;
9426 salt_type = SALT_TYPE_EMBEDDED;
9427 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9428 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9429 kern_type = KERN_TYPE_SCRYPT;
9430 dgst_size = DGST_SIZE_4_8;
9431 parse_func = scrypt_parse_hash;
9432 sort_by_digest = sort_by_digest_4_8;
9433 opti_type = OPTI_TYPE_ZERO_BYTE;
9434 dgst_pos0 = 0;
9435 dgst_pos1 = 1;
9436 dgst_pos2 = 2;
9437 dgst_pos3 = 3;
9438 break;
9439
9440 case 9000: hash_type = HASH_TYPE_SHA1;
9441 salt_type = SALT_TYPE_EMBEDDED;
9442 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9443 opts_type = OPTS_TYPE_PT_GENERATE_LE
9444 | OPTS_TYPE_ST_GENERATE_LE;
9445 kern_type = KERN_TYPE_PSAFE2;
9446 dgst_size = DGST_SIZE_4_5;
9447 parse_func = psafe2_parse_hash;
9448 sort_by_digest = sort_by_digest_4_5;
9449 opti_type = OPTI_TYPE_ZERO_BYTE;
9450 dgst_pos0 = 0;
9451 dgst_pos1 = 1;
9452 dgst_pos2 = 2;
9453 dgst_pos3 = 3;
9454 break;
9455
9456 case 9100: hash_type = HASH_TYPE_LOTUS8;
9457 salt_type = SALT_TYPE_EMBEDDED;
9458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9459 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9460 kern_type = KERN_TYPE_LOTUS8;
9461 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9462 parse_func = lotus8_parse_hash;
9463 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9464 opti_type = OPTI_TYPE_ZERO_BYTE;
9465 dgst_pos0 = 0;
9466 dgst_pos1 = 1;
9467 dgst_pos2 = 2;
9468 dgst_pos3 = 3;
9469 break;
9470
9471 case 9200: hash_type = HASH_TYPE_SHA256;
9472 salt_type = SALT_TYPE_EMBEDDED;
9473 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9474 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9475 kern_type = KERN_TYPE_PBKDF2_SHA256;
9476 dgst_size = DGST_SIZE_4_32;
9477 parse_func = cisco8_parse_hash;
9478 sort_by_digest = sort_by_digest_4_32;
9479 opti_type = OPTI_TYPE_ZERO_BYTE
9480 | OPTI_TYPE_SLOW_HASH_SIMD;
9481 dgst_pos0 = 0;
9482 dgst_pos1 = 1;
9483 dgst_pos2 = 2;
9484 dgst_pos3 = 3;
9485 break;
9486
9487 case 9300: hash_type = HASH_TYPE_SCRYPT;
9488 salt_type = SALT_TYPE_EMBEDDED;
9489 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9490 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9491 kern_type = KERN_TYPE_SCRYPT;
9492 dgst_size = DGST_SIZE_4_8;
9493 parse_func = cisco9_parse_hash;
9494 sort_by_digest = sort_by_digest_4_8;
9495 opti_type = OPTI_TYPE_ZERO_BYTE;
9496 dgst_pos0 = 0;
9497 dgst_pos1 = 1;
9498 dgst_pos2 = 2;
9499 dgst_pos3 = 3;
9500 break;
9501
9502 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9503 salt_type = SALT_TYPE_EMBEDDED;
9504 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9505 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9506 kern_type = KERN_TYPE_OFFICE2007;
9507 dgst_size = DGST_SIZE_4_4;
9508 parse_func = office2007_parse_hash;
9509 sort_by_digest = sort_by_digest_4_4;
9510 opti_type = OPTI_TYPE_ZERO_BYTE;
9511 dgst_pos0 = 0;
9512 dgst_pos1 = 1;
9513 dgst_pos2 = 2;
9514 dgst_pos3 = 3;
9515 break;
9516
9517 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9518 salt_type = SALT_TYPE_EMBEDDED;
9519 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9520 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9521 kern_type = KERN_TYPE_OFFICE2010;
9522 dgst_size = DGST_SIZE_4_4;
9523 parse_func = office2010_parse_hash;
9524 sort_by_digest = sort_by_digest_4_4;
9525 opti_type = OPTI_TYPE_ZERO_BYTE;
9526 dgst_pos0 = 0;
9527 dgst_pos1 = 1;
9528 dgst_pos2 = 2;
9529 dgst_pos3 = 3;
9530 break;
9531
9532 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9533 salt_type = SALT_TYPE_EMBEDDED;
9534 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9535 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9536 kern_type = KERN_TYPE_OFFICE2013;
9537 dgst_size = DGST_SIZE_4_4;
9538 parse_func = office2013_parse_hash;
9539 sort_by_digest = sort_by_digest_4_4;
9540 opti_type = OPTI_TYPE_ZERO_BYTE;
9541 dgst_pos0 = 0;
9542 dgst_pos1 = 1;
9543 dgst_pos2 = 2;
9544 dgst_pos3 = 3;
9545 break;
9546
9547 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9548 salt_type = SALT_TYPE_EMBEDDED;
9549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9550 opts_type = OPTS_TYPE_PT_GENERATE_LE
9551 | OPTS_TYPE_PT_ADD80
9552 | OPTS_TYPE_PT_UNICODE;
9553 kern_type = KERN_TYPE_OLDOFFICE01;
9554 dgst_size = DGST_SIZE_4_4;
9555 parse_func = oldoffice01_parse_hash;
9556 sort_by_digest = sort_by_digest_4_4;
9557 opti_type = OPTI_TYPE_ZERO_BYTE
9558 | OPTI_TYPE_PRECOMPUTE_INIT
9559 | OPTI_TYPE_NOT_ITERATED;
9560 dgst_pos0 = 0;
9561 dgst_pos1 = 1;
9562 dgst_pos2 = 2;
9563 dgst_pos3 = 3;
9564 break;
9565
9566 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9567 salt_type = SALT_TYPE_EMBEDDED;
9568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9569 opts_type = OPTS_TYPE_PT_GENERATE_LE
9570 | OPTS_TYPE_PT_ADD80;
9571 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9572 dgst_size = DGST_SIZE_4_4;
9573 parse_func = oldoffice01cm1_parse_hash;
9574 sort_by_digest = sort_by_digest_4_4;
9575 opti_type = OPTI_TYPE_ZERO_BYTE
9576 | OPTI_TYPE_PRECOMPUTE_INIT
9577 | OPTI_TYPE_NOT_ITERATED;
9578 dgst_pos0 = 0;
9579 dgst_pos1 = 1;
9580 dgst_pos2 = 2;
9581 dgst_pos3 = 3;
9582 break;
9583
9584 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9585 salt_type = SALT_TYPE_EMBEDDED;
9586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9587 opts_type = OPTS_TYPE_PT_GENERATE_LE
9588 | OPTS_TYPE_PT_ADD80
9589 | OPTS_TYPE_PT_UNICODE
9590 | OPTS_TYPE_PT_NEVERCRACK;
9591 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9592 dgst_size = DGST_SIZE_4_4;
9593 parse_func = oldoffice01cm2_parse_hash;
9594 sort_by_digest = sort_by_digest_4_4;
9595 opti_type = OPTI_TYPE_ZERO_BYTE
9596 | OPTI_TYPE_PRECOMPUTE_INIT
9597 | OPTI_TYPE_NOT_ITERATED;
9598 dgst_pos0 = 0;
9599 dgst_pos1 = 1;
9600 dgst_pos2 = 2;
9601 dgst_pos3 = 3;
9602 break;
9603
9604 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9605 salt_type = SALT_TYPE_EMBEDDED;
9606 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9607 opts_type = OPTS_TYPE_PT_GENERATE_BE
9608 | OPTS_TYPE_PT_ADD80
9609 | OPTS_TYPE_PT_UNICODE;
9610 kern_type = KERN_TYPE_OLDOFFICE34;
9611 dgst_size = DGST_SIZE_4_4;
9612 parse_func = oldoffice34_parse_hash;
9613 sort_by_digest = sort_by_digest_4_4;
9614 opti_type = OPTI_TYPE_ZERO_BYTE
9615 | OPTI_TYPE_PRECOMPUTE_INIT
9616 | OPTI_TYPE_NOT_ITERATED;
9617 dgst_pos0 = 0;
9618 dgst_pos1 = 1;
9619 dgst_pos2 = 2;
9620 dgst_pos3 = 3;
9621 break;
9622
9623 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9624 salt_type = SALT_TYPE_EMBEDDED;
9625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9626 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9627 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9628 dgst_size = DGST_SIZE_4_4;
9629 parse_func = oldoffice34cm1_parse_hash;
9630 sort_by_digest = sort_by_digest_4_4;
9631 opti_type = OPTI_TYPE_ZERO_BYTE
9632 | OPTI_TYPE_PRECOMPUTE_INIT
9633 | OPTI_TYPE_NOT_ITERATED;
9634 dgst_pos0 = 0;
9635 dgst_pos1 = 1;
9636 dgst_pos2 = 2;
9637 dgst_pos3 = 3;
9638 break;
9639
9640 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9641 salt_type = SALT_TYPE_EMBEDDED;
9642 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9643 opts_type = OPTS_TYPE_PT_GENERATE_BE
9644 | OPTS_TYPE_PT_ADD80
9645 | OPTS_TYPE_PT_UNICODE
9646 | OPTS_TYPE_PT_NEVERCRACK;
9647 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9648 dgst_size = DGST_SIZE_4_4;
9649 parse_func = oldoffice34cm2_parse_hash;
9650 sort_by_digest = sort_by_digest_4_4;
9651 opti_type = OPTI_TYPE_ZERO_BYTE
9652 | OPTI_TYPE_PRECOMPUTE_INIT
9653 | OPTI_TYPE_NOT_ITERATED;
9654 dgst_pos0 = 0;
9655 dgst_pos1 = 1;
9656 dgst_pos2 = 2;
9657 dgst_pos3 = 3;
9658 break;
9659
9660 case 9900: hash_type = HASH_TYPE_MD5;
9661 salt_type = SALT_TYPE_NONE;
9662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9663 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9664 kern_type = KERN_TYPE_RADMIN2;
9665 dgst_size = DGST_SIZE_4_4;
9666 parse_func = radmin2_parse_hash;
9667 sort_by_digest = sort_by_digest_4_4;
9668 opti_type = OPTI_TYPE_ZERO_BYTE
9669 | OPTI_TYPE_PRECOMPUTE_INIT
9670 | OPTI_TYPE_EARLY_SKIP
9671 | OPTI_TYPE_NOT_ITERATED
9672 | OPTI_TYPE_NOT_SALTED;
9673 dgst_pos0 = 0;
9674 dgst_pos1 = 3;
9675 dgst_pos2 = 2;
9676 dgst_pos3 = 1;
9677 break;
9678
9679 case 10000: hash_type = HASH_TYPE_SHA256;
9680 salt_type = SALT_TYPE_EMBEDDED;
9681 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9682 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9683 kern_type = KERN_TYPE_PBKDF2_SHA256;
9684 dgst_size = DGST_SIZE_4_32;
9685 parse_func = djangopbkdf2_parse_hash;
9686 sort_by_digest = sort_by_digest_4_32;
9687 opti_type = OPTI_TYPE_ZERO_BYTE
9688 | OPTI_TYPE_SLOW_HASH_SIMD;
9689 dgst_pos0 = 0;
9690 dgst_pos1 = 1;
9691 dgst_pos2 = 2;
9692 dgst_pos3 = 3;
9693 break;
9694
9695 case 10100: hash_type = HASH_TYPE_SIPHASH;
9696 salt_type = SALT_TYPE_EMBEDDED;
9697 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9698 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9699 kern_type = KERN_TYPE_SIPHASH;
9700 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9701 parse_func = siphash_parse_hash;
9702 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9703 opti_type = OPTI_TYPE_ZERO_BYTE
9704 | OPTI_TYPE_NOT_ITERATED
9705 | OPTI_TYPE_RAW_HASH;
9706 dgst_pos0 = 0;
9707 dgst_pos1 = 1;
9708 dgst_pos2 = 2;
9709 dgst_pos3 = 3;
9710 break;
9711
9712 case 10200: hash_type = HASH_TYPE_MD5;
9713 salt_type = SALT_TYPE_EMBEDDED;
9714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9715 opts_type = OPTS_TYPE_PT_GENERATE_LE
9716 | OPTS_TYPE_ST_ADD80
9717 | OPTS_TYPE_ST_ADDBITS14;
9718 kern_type = KERN_TYPE_HMACMD5_PW;
9719 dgst_size = DGST_SIZE_4_4;
9720 parse_func = crammd5_parse_hash;
9721 sort_by_digest = sort_by_digest_4_4;
9722 opti_type = OPTI_TYPE_ZERO_BYTE
9723 | OPTI_TYPE_NOT_ITERATED;
9724 dgst_pos0 = 0;
9725 dgst_pos1 = 3;
9726 dgst_pos2 = 2;
9727 dgst_pos3 = 1;
9728 break;
9729
9730 case 10300: hash_type = HASH_TYPE_SHA1;
9731 salt_type = SALT_TYPE_EMBEDDED;
9732 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9733 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9734 kern_type = KERN_TYPE_SAPH_SHA1;
9735 dgst_size = DGST_SIZE_4_5;
9736 parse_func = saph_sha1_parse_hash;
9737 sort_by_digest = sort_by_digest_4_5;
9738 opti_type = OPTI_TYPE_ZERO_BYTE;
9739 dgst_pos0 = 0;
9740 dgst_pos1 = 1;
9741 dgst_pos2 = 2;
9742 dgst_pos3 = 3;
9743 break;
9744
9745 case 10400: hash_type = HASH_TYPE_PDFU16;
9746 salt_type = SALT_TYPE_EMBEDDED;
9747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9748 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9749 kern_type = KERN_TYPE_PDF11;
9750 dgst_size = DGST_SIZE_4_4;
9751 parse_func = pdf11_parse_hash;
9752 sort_by_digest = sort_by_digest_4_4;
9753 opti_type = OPTI_TYPE_ZERO_BYTE
9754 | OPTI_TYPE_NOT_ITERATED;
9755 dgst_pos0 = 0;
9756 dgst_pos1 = 1;
9757 dgst_pos2 = 2;
9758 dgst_pos3 = 3;
9759 break;
9760
9761 case 10410: hash_type = HASH_TYPE_PDFU16;
9762 salt_type = SALT_TYPE_EMBEDDED;
9763 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9764 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9765 kern_type = KERN_TYPE_PDF11CM1;
9766 dgst_size = DGST_SIZE_4_4;
9767 parse_func = pdf11cm1_parse_hash;
9768 sort_by_digest = sort_by_digest_4_4;
9769 opti_type = OPTI_TYPE_ZERO_BYTE
9770 | OPTI_TYPE_NOT_ITERATED;
9771 dgst_pos0 = 0;
9772 dgst_pos1 = 1;
9773 dgst_pos2 = 2;
9774 dgst_pos3 = 3;
9775 break;
9776
9777 case 10420: hash_type = HASH_TYPE_PDFU16;
9778 salt_type = SALT_TYPE_EMBEDDED;
9779 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9780 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9781 kern_type = KERN_TYPE_PDF11CM2;
9782 dgst_size = DGST_SIZE_4_4;
9783 parse_func = pdf11cm2_parse_hash;
9784 sort_by_digest = sort_by_digest_4_4;
9785 opti_type = OPTI_TYPE_ZERO_BYTE
9786 | OPTI_TYPE_NOT_ITERATED;
9787 dgst_pos0 = 0;
9788 dgst_pos1 = 1;
9789 dgst_pos2 = 2;
9790 dgst_pos3 = 3;
9791 break;
9792
9793 case 10500: hash_type = HASH_TYPE_PDFU16;
9794 salt_type = SALT_TYPE_EMBEDDED;
9795 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9796 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9797 kern_type = KERN_TYPE_PDF14;
9798 dgst_size = DGST_SIZE_4_4;
9799 parse_func = pdf14_parse_hash;
9800 sort_by_digest = sort_by_digest_4_4;
9801 opti_type = OPTI_TYPE_ZERO_BYTE
9802 | OPTI_TYPE_NOT_ITERATED;
9803 dgst_pos0 = 0;
9804 dgst_pos1 = 1;
9805 dgst_pos2 = 2;
9806 dgst_pos3 = 3;
9807 break;
9808
9809 case 10600: hash_type = HASH_TYPE_SHA256;
9810 salt_type = SALT_TYPE_EMBEDDED;
9811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9812 opts_type = OPTS_TYPE_PT_GENERATE_BE
9813 | OPTS_TYPE_ST_ADD80
9814 | OPTS_TYPE_ST_ADDBITS15
9815 | OPTS_TYPE_HASH_COPY;
9816 kern_type = KERN_TYPE_SHA256_PWSLT;
9817 dgst_size = DGST_SIZE_4_8;
9818 parse_func = pdf17l3_parse_hash;
9819 sort_by_digest = sort_by_digest_4_8;
9820 opti_type = OPTI_TYPE_ZERO_BYTE
9821 | OPTI_TYPE_PRECOMPUTE_INIT
9822 | OPTI_TYPE_PRECOMPUTE_MERKLE
9823 | OPTI_TYPE_EARLY_SKIP
9824 | OPTI_TYPE_NOT_ITERATED
9825 | OPTI_TYPE_APPENDED_SALT
9826 | OPTI_TYPE_RAW_HASH;
9827 dgst_pos0 = 3;
9828 dgst_pos1 = 7;
9829 dgst_pos2 = 2;
9830 dgst_pos3 = 6;
9831 break;
9832
9833 case 10700: hash_type = HASH_TYPE_PDFU32;
9834 salt_type = SALT_TYPE_EMBEDDED;
9835 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9836 opts_type = OPTS_TYPE_PT_GENERATE_LE
9837 | OPTS_TYPE_HASH_COPY;
9838 kern_type = KERN_TYPE_PDF17L8;
9839 dgst_size = DGST_SIZE_4_8;
9840 parse_func = pdf17l8_parse_hash;
9841 sort_by_digest = sort_by_digest_4_8;
9842 opti_type = OPTI_TYPE_ZERO_BYTE
9843 | OPTI_TYPE_NOT_ITERATED;
9844 dgst_pos0 = 0;
9845 dgst_pos1 = 1;
9846 dgst_pos2 = 2;
9847 dgst_pos3 = 3;
9848 break;
9849
9850 case 10800: hash_type = HASH_TYPE_SHA384;
9851 salt_type = SALT_TYPE_NONE;
9852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9853 opts_type = OPTS_TYPE_PT_GENERATE_BE
9854 | OPTS_TYPE_PT_ADD80
9855 | OPTS_TYPE_PT_ADDBITS15;
9856 kern_type = KERN_TYPE_SHA384;
9857 dgst_size = DGST_SIZE_8_8;
9858 parse_func = sha384_parse_hash;
9859 sort_by_digest = sort_by_digest_8_8;
9860 opti_type = OPTI_TYPE_ZERO_BYTE
9861 | OPTI_TYPE_PRECOMPUTE_INIT
9862 | OPTI_TYPE_PRECOMPUTE_MERKLE
9863 | OPTI_TYPE_EARLY_SKIP
9864 | OPTI_TYPE_NOT_ITERATED
9865 | OPTI_TYPE_NOT_SALTED
9866 | OPTI_TYPE_USES_BITS_64
9867 | OPTI_TYPE_RAW_HASH;
9868 dgst_pos0 = 6;
9869 dgst_pos1 = 7;
9870 dgst_pos2 = 4;
9871 dgst_pos3 = 5;
9872 break;
9873
9874 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9875 salt_type = SALT_TYPE_EMBEDDED;
9876 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9877 opts_type = OPTS_TYPE_PT_GENERATE_LE
9878 | OPTS_TYPE_ST_BASE64
9879 | OPTS_TYPE_HASH_COPY;
9880 kern_type = KERN_TYPE_PBKDF2_SHA256;
9881 dgst_size = DGST_SIZE_4_32;
9882 parse_func = pbkdf2_sha256_parse_hash;
9883 sort_by_digest = sort_by_digest_4_32;
9884 opti_type = OPTI_TYPE_ZERO_BYTE
9885 | OPTI_TYPE_SLOW_HASH_SIMD;
9886 dgst_pos0 = 0;
9887 dgst_pos1 = 1;
9888 dgst_pos2 = 2;
9889 dgst_pos3 = 3;
9890 break;
9891
9892 case 11000: hash_type = HASH_TYPE_MD5;
9893 salt_type = SALT_TYPE_INTERN;
9894 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9895 opts_type = OPTS_TYPE_PT_GENERATE_LE
9896 | OPTS_TYPE_PT_ADD80;
9897 kern_type = KERN_TYPE_PRESTASHOP;
9898 dgst_size = DGST_SIZE_4_4;
9899 parse_func = prestashop_parse_hash;
9900 sort_by_digest = sort_by_digest_4_4;
9901 opti_type = OPTI_TYPE_ZERO_BYTE
9902 | OPTI_TYPE_PRECOMPUTE_INIT
9903 | OPTI_TYPE_NOT_ITERATED
9904 | OPTI_TYPE_PREPENDED_SALT;
9905 dgst_pos0 = 0;
9906 dgst_pos1 = 3;
9907 dgst_pos2 = 2;
9908 dgst_pos3 = 1;
9909 break;
9910
9911 case 11100: hash_type = HASH_TYPE_MD5;
9912 salt_type = SALT_TYPE_EMBEDDED;
9913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9914 opts_type = OPTS_TYPE_PT_GENERATE_LE
9915 | OPTS_TYPE_ST_ADD80;
9916 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9917 dgst_size = DGST_SIZE_4_4;
9918 parse_func = postgresql_auth_parse_hash;
9919 sort_by_digest = sort_by_digest_4_4;
9920 opti_type = OPTI_TYPE_ZERO_BYTE
9921 | OPTI_TYPE_PRECOMPUTE_INIT
9922 | OPTI_TYPE_PRECOMPUTE_MERKLE
9923 | OPTI_TYPE_EARLY_SKIP;
9924 dgst_pos0 = 0;
9925 dgst_pos1 = 3;
9926 dgst_pos2 = 2;
9927 dgst_pos3 = 1;
9928 break;
9929
9930 case 11200: hash_type = HASH_TYPE_SHA1;
9931 salt_type = SALT_TYPE_EMBEDDED;
9932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9933 opts_type = OPTS_TYPE_PT_GENERATE_BE
9934 | OPTS_TYPE_PT_ADD80
9935 | OPTS_TYPE_ST_HEX;
9936 kern_type = KERN_TYPE_MYSQL_AUTH;
9937 dgst_size = DGST_SIZE_4_5;
9938 parse_func = mysql_auth_parse_hash;
9939 sort_by_digest = sort_by_digest_4_5;
9940 opti_type = OPTI_TYPE_ZERO_BYTE
9941 | OPTI_TYPE_EARLY_SKIP;
9942 dgst_pos0 = 3;
9943 dgst_pos1 = 4;
9944 dgst_pos2 = 2;
9945 dgst_pos3 = 1;
9946 break;
9947
9948 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9949 salt_type = SALT_TYPE_EMBEDDED;
9950 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9951 opts_type = OPTS_TYPE_PT_GENERATE_LE
9952 | OPTS_TYPE_ST_HEX
9953 | OPTS_TYPE_ST_ADD80;
9954 kern_type = KERN_TYPE_BITCOIN_WALLET;
9955 dgst_size = DGST_SIZE_4_4;
9956 parse_func = bitcoin_wallet_parse_hash;
9957 sort_by_digest = sort_by_digest_4_4;
9958 opti_type = OPTI_TYPE_ZERO_BYTE;
9959 dgst_pos0 = 0;
9960 dgst_pos1 = 1;
9961 dgst_pos2 = 2;
9962 dgst_pos3 = 3;
9963 break;
9964
9965 case 11400: hash_type = HASH_TYPE_MD5;
9966 salt_type = SALT_TYPE_EMBEDDED;
9967 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9968 opts_type = OPTS_TYPE_PT_GENERATE_LE
9969 | OPTS_TYPE_PT_ADD80
9970 | OPTS_TYPE_HASH_COPY;
9971 kern_type = KERN_TYPE_SIP_AUTH;
9972 dgst_size = DGST_SIZE_4_4;
9973 parse_func = sip_auth_parse_hash;
9974 sort_by_digest = sort_by_digest_4_4;
9975 opti_type = OPTI_TYPE_ZERO_BYTE;
9976 dgst_pos0 = 0;
9977 dgst_pos1 = 3;
9978 dgst_pos2 = 2;
9979 dgst_pos3 = 1;
9980 break;
9981
9982 case 11500: hash_type = HASH_TYPE_CRC32;
9983 salt_type = SALT_TYPE_INTERN;
9984 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9985 opts_type = OPTS_TYPE_PT_GENERATE_LE
9986 | OPTS_TYPE_ST_GENERATE_LE
9987 | OPTS_TYPE_ST_HEX;
9988 kern_type = KERN_TYPE_CRC32;
9989 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9990 parse_func = crc32_parse_hash;
9991 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9992 opti_type = OPTI_TYPE_ZERO_BYTE;
9993 dgst_pos0 = 0;
9994 dgst_pos1 = 1;
9995 dgst_pos2 = 2;
9996 dgst_pos3 = 3;
9997 break;
9998
9999 case 11600: hash_type = HASH_TYPE_AES;
10000 salt_type = SALT_TYPE_EMBEDDED;
10001 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10002 opts_type = OPTS_TYPE_PT_GENERATE_LE
10003 | OPTS_TYPE_PT_NEVERCRACK;
10004 kern_type = KERN_TYPE_SEVEN_ZIP;
10005 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10006 parse_func = seven_zip_parse_hash;
10007 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10008 opti_type = OPTI_TYPE_ZERO_BYTE;
10009 dgst_pos0 = 0;
10010 dgst_pos1 = 1;
10011 dgst_pos2 = 2;
10012 dgst_pos3 = 3;
10013 break;
10014
10015 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10016 salt_type = SALT_TYPE_NONE;
10017 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10018 opts_type = OPTS_TYPE_PT_GENERATE_LE
10019 | OPTS_TYPE_PT_ADD01;
10020 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10021 dgst_size = DGST_SIZE_4_8;
10022 parse_func = gost2012sbog_256_parse_hash;
10023 sort_by_digest = sort_by_digest_4_8;
10024 opti_type = OPTI_TYPE_ZERO_BYTE;
10025 dgst_pos0 = 0;
10026 dgst_pos1 = 1;
10027 dgst_pos2 = 2;
10028 dgst_pos3 = 3;
10029 break;
10030
10031 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10032 salt_type = SALT_TYPE_NONE;
10033 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10034 opts_type = OPTS_TYPE_PT_GENERATE_LE
10035 | OPTS_TYPE_PT_ADD01;
10036 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10037 dgst_size = DGST_SIZE_4_16;
10038 parse_func = gost2012sbog_512_parse_hash;
10039 sort_by_digest = sort_by_digest_4_16;
10040 opti_type = OPTI_TYPE_ZERO_BYTE;
10041 dgst_pos0 = 0;
10042 dgst_pos1 = 1;
10043 dgst_pos2 = 2;
10044 dgst_pos3 = 3;
10045 break;
10046
10047 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10048 salt_type = SALT_TYPE_EMBEDDED;
10049 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10050 opts_type = OPTS_TYPE_PT_GENERATE_LE
10051 | OPTS_TYPE_ST_BASE64
10052 | OPTS_TYPE_HASH_COPY;
10053 kern_type = KERN_TYPE_PBKDF2_MD5;
10054 dgst_size = DGST_SIZE_4_32;
10055 parse_func = pbkdf2_md5_parse_hash;
10056 sort_by_digest = sort_by_digest_4_32;
10057 opti_type = OPTI_TYPE_ZERO_BYTE
10058 | OPTI_TYPE_SLOW_HASH_SIMD;
10059 dgst_pos0 = 0;
10060 dgst_pos1 = 1;
10061 dgst_pos2 = 2;
10062 dgst_pos3 = 3;
10063 break;
10064
10065 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10066 salt_type = SALT_TYPE_EMBEDDED;
10067 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10068 opts_type = OPTS_TYPE_PT_GENERATE_LE
10069 | OPTS_TYPE_ST_BASE64
10070 | OPTS_TYPE_HASH_COPY;
10071 kern_type = KERN_TYPE_PBKDF2_SHA1;
10072 dgst_size = DGST_SIZE_4_32;
10073 parse_func = pbkdf2_sha1_parse_hash;
10074 sort_by_digest = sort_by_digest_4_32;
10075 opti_type = OPTI_TYPE_ZERO_BYTE
10076 | OPTI_TYPE_SLOW_HASH_SIMD;
10077 dgst_pos0 = 0;
10078 dgst_pos1 = 1;
10079 dgst_pos2 = 2;
10080 dgst_pos3 = 3;
10081 break;
10082
10083 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10084 salt_type = SALT_TYPE_EMBEDDED;
10085 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10086 opts_type = OPTS_TYPE_PT_GENERATE_LE
10087 | OPTS_TYPE_ST_BASE64
10088 | OPTS_TYPE_HASH_COPY;
10089 kern_type = KERN_TYPE_PBKDF2_SHA512;
10090 dgst_size = DGST_SIZE_8_16;
10091 parse_func = pbkdf2_sha512_parse_hash;
10092 sort_by_digest = sort_by_digest_8_16;
10093 opti_type = OPTI_TYPE_ZERO_BYTE
10094 | OPTI_TYPE_USES_BITS_64
10095 | OPTI_TYPE_SLOW_HASH_SIMD;
10096 dgst_pos0 = 0;
10097 dgst_pos1 = 1;
10098 dgst_pos2 = 2;
10099 dgst_pos3 = 3;
10100 break;
10101
10102 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10103 salt_type = SALT_TYPE_EMBEDDED;
10104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10105 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10106 kern_type = KERN_TYPE_ECRYPTFS;
10107 dgst_size = DGST_SIZE_8_8;
10108 parse_func = ecryptfs_parse_hash;
10109 sort_by_digest = sort_by_digest_8_8;
10110 opti_type = OPTI_TYPE_ZERO_BYTE
10111 | OPTI_TYPE_USES_BITS_64;
10112 dgst_pos0 = 0;
10113 dgst_pos1 = 1;
10114 dgst_pos2 = 2;
10115 dgst_pos3 = 3;
10116 break;
10117
10118 case 12300: hash_type = HASH_TYPE_ORACLET;
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_ORACLET;
10123 dgst_size = DGST_SIZE_8_16;
10124 parse_func = oraclet_parse_hash;
10125 sort_by_digest = sort_by_digest_8_16;
10126 opti_type = OPTI_TYPE_ZERO_BYTE
10127 | OPTI_TYPE_USES_BITS_64;
10128 dgst_pos0 = 0;
10129 dgst_pos1 = 1;
10130 dgst_pos2 = 2;
10131 dgst_pos3 = 3;
10132 break;
10133
10134 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10135 salt_type = SALT_TYPE_EMBEDDED;
10136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10137 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10138 kern_type = KERN_TYPE_BSDICRYPT;
10139 dgst_size = DGST_SIZE_4_4;
10140 parse_func = bsdicrypt_parse_hash;
10141 sort_by_digest = sort_by_digest_4_4;
10142 opti_type = OPTI_TYPE_ZERO_BYTE
10143 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10144 dgst_pos0 = 0;
10145 dgst_pos1 = 1;
10146 dgst_pos2 = 2;
10147 dgst_pos3 = 3;
10148 break;
10149
10150 case 12500: hash_type = HASH_TYPE_RAR3HP;
10151 salt_type = SALT_TYPE_EMBEDDED;
10152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10153 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10154 kern_type = KERN_TYPE_RAR3;
10155 dgst_size = DGST_SIZE_4_4;
10156 parse_func = rar3hp_parse_hash;
10157 sort_by_digest = sort_by_digest_4_4;
10158 opti_type = OPTI_TYPE_ZERO_BYTE;
10159 dgst_pos0 = 0;
10160 dgst_pos1 = 1;
10161 dgst_pos2 = 2;
10162 dgst_pos3 = 3;
10163 break;
10164
10165 case 12600: hash_type = HASH_TYPE_SHA256;
10166 salt_type = SALT_TYPE_INTERN;
10167 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10168 opts_type = OPTS_TYPE_PT_GENERATE_BE
10169 | OPTS_TYPE_PT_ADD80;
10170 kern_type = KERN_TYPE_CF10;
10171 dgst_size = DGST_SIZE_4_8;
10172 parse_func = cf10_parse_hash;
10173 sort_by_digest = sort_by_digest_4_8;
10174 opti_type = OPTI_TYPE_ZERO_BYTE
10175 | OPTI_TYPE_PRECOMPUTE_INIT
10176 | OPTI_TYPE_EARLY_SKIP
10177 | OPTI_TYPE_NOT_ITERATED;
10178 dgst_pos0 = 3;
10179 dgst_pos1 = 7;
10180 dgst_pos2 = 2;
10181 dgst_pos3 = 6;
10182 break;
10183
10184 case 12700: hash_type = HASH_TYPE_AES;
10185 salt_type = SALT_TYPE_EMBEDDED;
10186 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10187 opts_type = OPTS_TYPE_PT_GENERATE_LE
10188 | OPTS_TYPE_HASH_COPY;
10189 kern_type = KERN_TYPE_MYWALLET;
10190 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10191 parse_func = mywallet_parse_hash;
10192 sort_by_digest = sort_by_digest_4_5;
10193 opti_type = OPTI_TYPE_ZERO_BYTE;
10194 dgst_pos0 = 0;
10195 dgst_pos1 = 1;
10196 dgst_pos2 = 2;
10197 dgst_pos3 = 3;
10198 break;
10199
10200 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10201 salt_type = SALT_TYPE_EMBEDDED;
10202 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10203 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10204 kern_type = KERN_TYPE_MS_DRSR;
10205 dgst_size = DGST_SIZE_4_8;
10206 parse_func = ms_drsr_parse_hash;
10207 sort_by_digest = sort_by_digest_4_8;
10208 opti_type = OPTI_TYPE_ZERO_BYTE;
10209 dgst_pos0 = 0;
10210 dgst_pos1 = 1;
10211 dgst_pos2 = 2;
10212 dgst_pos3 = 3;
10213 break;
10214
10215 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10216 salt_type = SALT_TYPE_EMBEDDED;
10217 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10218 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10219 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10220 dgst_size = DGST_SIZE_4_8;
10221 parse_func = androidfde_samsung_parse_hash;
10222 sort_by_digest = sort_by_digest_4_8;
10223 opti_type = OPTI_TYPE_ZERO_BYTE;
10224 dgst_pos0 = 0;
10225 dgst_pos1 = 1;
10226 dgst_pos2 = 2;
10227 dgst_pos3 = 3;
10228 break;
10229
10230 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10231 salt_type = SALT_TYPE_EMBEDDED;
10232 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10233 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10234 kern_type = KERN_TYPE_RAR5;
10235 dgst_size = DGST_SIZE_4_4;
10236 parse_func = rar5_parse_hash;
10237 sort_by_digest = sort_by_digest_4_4;
10238 opti_type = OPTI_TYPE_ZERO_BYTE;
10239 dgst_pos0 = 0;
10240 dgst_pos1 = 1;
10241 dgst_pos2 = 2;
10242 dgst_pos3 = 3;
10243 break;
10244
10245 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10246 salt_type = SALT_TYPE_EMBEDDED;
10247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10248 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10249 kern_type = KERN_TYPE_KRB5TGS;
10250 dgst_size = DGST_SIZE_4_4;
10251 parse_func = krb5tgs_parse_hash;
10252 sort_by_digest = sort_by_digest_4_4;
10253 opti_type = OPTI_TYPE_ZERO_BYTE
10254 | OPTI_TYPE_NOT_ITERATED;
10255 dgst_pos0 = 0;
10256 dgst_pos1 = 1;
10257 dgst_pos2 = 2;
10258 dgst_pos3 = 3;
10259 break;
10260
10261 case 13200: hash_type = HASH_TYPE_AES;
10262 salt_type = SALT_TYPE_EMBEDDED;
10263 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10264 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10265 kern_type = KERN_TYPE_AXCRYPT;
10266 dgst_size = DGST_SIZE_4_4;
10267 parse_func = axcrypt_parse_hash;
10268 sort_by_digest = sort_by_digest_4_4;
10269 opti_type = OPTI_TYPE_ZERO_BYTE;
10270 dgst_pos0 = 0;
10271 dgst_pos1 = 1;
10272 dgst_pos2 = 2;
10273 dgst_pos3 = 3;
10274 break;
10275
10276 case 13300: hash_type = HASH_TYPE_SHA1;
10277 salt_type = SALT_TYPE_NONE;
10278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10279 opts_type = OPTS_TYPE_PT_GENERATE_BE
10280 | OPTS_TYPE_PT_ADD80
10281 | OPTS_TYPE_PT_ADDBITS15;
10282 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10283 dgst_size = DGST_SIZE_4_5;
10284 parse_func = sha1axcrypt_parse_hash;
10285 sort_by_digest = sort_by_digest_4_5;
10286 opti_type = OPTI_TYPE_ZERO_BYTE
10287 | OPTI_TYPE_PRECOMPUTE_INIT
10288 | OPTI_TYPE_EARLY_SKIP
10289 | OPTI_TYPE_NOT_ITERATED
10290 | OPTI_TYPE_NOT_SALTED;
10291 dgst_pos0 = 0;
10292 dgst_pos1 = 4;
10293 dgst_pos2 = 3;
10294 dgst_pos3 = 2;
10295 break;
10296
10297 case 13400: hash_type = HASH_TYPE_AES;
10298 salt_type = SALT_TYPE_EMBEDDED;
10299 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10300 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10301 kern_type = KERN_TYPE_KEEPASS;
10302 dgst_size = DGST_SIZE_4_4;
10303 parse_func = keepass_parse_hash;
10304 sort_by_digest = sort_by_digest_4_4;
10305 opti_type = OPTI_TYPE_ZERO_BYTE;
10306 dgst_pos0 = 0;
10307 dgst_pos1 = 1;
10308 dgst_pos2 = 2;
10309 dgst_pos3 = 3;
10310 break;
10311
10312 case 13500: hash_type = HASH_TYPE_SHA1;
10313 salt_type = SALT_TYPE_EMBEDDED;
10314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10315 opts_type = OPTS_TYPE_PT_GENERATE_BE
10316 | OPTS_TYPE_PT_UNICODE
10317 | OPTS_TYPE_PT_ADD80;
10318 kern_type = KERN_TYPE_PSTOKEN;
10319 dgst_size = DGST_SIZE_4_5;
10320 parse_func = pstoken_parse_hash;
10321 sort_by_digest = sort_by_digest_4_5;
10322 opti_type = OPTI_TYPE_ZERO_BYTE
10323 | OPTI_TYPE_PRECOMPUTE_INIT
10324 | OPTI_TYPE_EARLY_SKIP
10325 | OPTI_TYPE_NOT_ITERATED
10326 | OPTI_TYPE_PREPENDED_SALT
10327 | OPTI_TYPE_RAW_HASH;
10328 dgst_pos0 = 3;
10329 dgst_pos1 = 4;
10330 dgst_pos2 = 2;
10331 dgst_pos3 = 1;
10332 break;
10333
10334 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10335 salt_type = SALT_TYPE_EMBEDDED;
10336 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10337 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10338 kern_type = KERN_TYPE_ZIP2;
10339 dgst_size = DGST_SIZE_4_4;
10340 parse_func = zip2_parse_hash;
10341 sort_by_digest = sort_by_digest_4_4;
10342 opti_type = OPTI_TYPE_ZERO_BYTE;
10343 dgst_pos0 = 0;
10344 dgst_pos1 = 1;
10345 dgst_pos2 = 2;
10346 dgst_pos3 = 3;
10347 break;
10348
10349 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10350 salt_type = SALT_TYPE_EMBEDDED;
10351 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10352 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10353 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10354 dgst_size = DGST_SIZE_4_5;
10355 parse_func = veracrypt_parse_hash_655331;
10356 sort_by_digest = sort_by_digest_4_5;
10357 opti_type = OPTI_TYPE_ZERO_BYTE;
10358 dgst_pos0 = 0;
10359 dgst_pos1 = 1;
10360 dgst_pos2 = 2;
10361 dgst_pos3 = 3;
10362 break;
10363
10364 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10365 salt_type = SALT_TYPE_EMBEDDED;
10366 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10367 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10368 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10369 dgst_size = DGST_SIZE_4_5;
10370 parse_func = veracrypt_parse_hash_655331;
10371 sort_by_digest = sort_by_digest_4_5;
10372 opti_type = OPTI_TYPE_ZERO_BYTE;
10373 dgst_pos0 = 0;
10374 dgst_pos1 = 1;
10375 dgst_pos2 = 2;
10376 dgst_pos3 = 3;
10377 break;
10378
10379 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10380 salt_type = SALT_TYPE_EMBEDDED;
10381 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10382 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10383 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10384 dgst_size = DGST_SIZE_4_5;
10385 parse_func = veracrypt_parse_hash_655331;
10386 sort_by_digest = sort_by_digest_4_5;
10387 opti_type = OPTI_TYPE_ZERO_BYTE;
10388 dgst_pos0 = 0;
10389 dgst_pos1 = 1;
10390 dgst_pos2 = 2;
10391 dgst_pos3 = 3;
10392 break;
10393
10394 case 13721: hash_type = HASH_TYPE_SHA512;
10395 salt_type = SALT_TYPE_EMBEDDED;
10396 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10397 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10398 kern_type = KERN_TYPE_TCSHA512_XTS512;
10399 dgst_size = DGST_SIZE_8_8;
10400 parse_func = veracrypt_parse_hash_500000;
10401 sort_by_digest = sort_by_digest_8_8;
10402 opti_type = OPTI_TYPE_ZERO_BYTE
10403 | OPTI_TYPE_USES_BITS_64;
10404 dgst_pos0 = 0;
10405 dgst_pos1 = 1;
10406 dgst_pos2 = 2;
10407 dgst_pos3 = 3;
10408 break;
10409
10410 case 13722: hash_type = HASH_TYPE_SHA512;
10411 salt_type = SALT_TYPE_EMBEDDED;
10412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10413 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10414 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10415 dgst_size = DGST_SIZE_8_8;
10416 parse_func = veracrypt_parse_hash_500000;
10417 sort_by_digest = sort_by_digest_8_8;
10418 opti_type = OPTI_TYPE_ZERO_BYTE
10419 | OPTI_TYPE_USES_BITS_64;
10420 dgst_pos0 = 0;
10421 dgst_pos1 = 1;
10422 dgst_pos2 = 2;
10423 dgst_pos3 = 3;
10424 break;
10425
10426 case 13723: hash_type = HASH_TYPE_SHA512;
10427 salt_type = SALT_TYPE_EMBEDDED;
10428 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10429 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10430 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10431 dgst_size = DGST_SIZE_8_8;
10432 parse_func = veracrypt_parse_hash_500000;
10433 sort_by_digest = sort_by_digest_8_8;
10434 opti_type = OPTI_TYPE_ZERO_BYTE
10435 | OPTI_TYPE_USES_BITS_64;
10436 dgst_pos0 = 0;
10437 dgst_pos1 = 1;
10438 dgst_pos2 = 2;
10439 dgst_pos3 = 3;
10440 break;
10441
10442 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10443 salt_type = SALT_TYPE_EMBEDDED;
10444 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10445 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10446 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10447 dgst_size = DGST_SIZE_4_8;
10448 parse_func = veracrypt_parse_hash_500000;
10449 sort_by_digest = sort_by_digest_4_8;
10450 opti_type = OPTI_TYPE_ZERO_BYTE;
10451 dgst_pos0 = 0;
10452 dgst_pos1 = 1;
10453 dgst_pos2 = 2;
10454 dgst_pos3 = 3;
10455 break;
10456
10457 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10458 salt_type = SALT_TYPE_EMBEDDED;
10459 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10460 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10461 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10462 dgst_size = DGST_SIZE_4_8;
10463 parse_func = veracrypt_parse_hash_500000;
10464 sort_by_digest = sort_by_digest_4_8;
10465 opti_type = OPTI_TYPE_ZERO_BYTE;
10466 dgst_pos0 = 0;
10467 dgst_pos1 = 1;
10468 dgst_pos2 = 2;
10469 dgst_pos3 = 3;
10470 break;
10471
10472 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10473 salt_type = SALT_TYPE_EMBEDDED;
10474 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10475 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10476 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10477 dgst_size = DGST_SIZE_4_8;
10478 parse_func = veracrypt_parse_hash_500000;
10479 sort_by_digest = sort_by_digest_4_8;
10480 opti_type = OPTI_TYPE_ZERO_BYTE;
10481 dgst_pos0 = 0;
10482 dgst_pos1 = 1;
10483 dgst_pos2 = 2;
10484 dgst_pos3 = 3;
10485 break;
10486
10487 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10488 salt_type = SALT_TYPE_EMBEDDED;
10489 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10490 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10491 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10492 dgst_size = DGST_SIZE_4_5;
10493 parse_func = veracrypt_parse_hash_327661;
10494 sort_by_digest = sort_by_digest_4_5;
10495 opti_type = OPTI_TYPE_ZERO_BYTE;
10496 dgst_pos0 = 0;
10497 dgst_pos1 = 1;
10498 dgst_pos2 = 2;
10499 dgst_pos3 = 3;
10500 break;
10501
10502 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10503 salt_type = SALT_TYPE_EMBEDDED;
10504 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10505 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10506 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10507 dgst_size = DGST_SIZE_4_5;
10508 parse_func = veracrypt_parse_hash_327661;
10509 sort_by_digest = sort_by_digest_4_5;
10510 opti_type = OPTI_TYPE_ZERO_BYTE;
10511 dgst_pos0 = 0;
10512 dgst_pos1 = 1;
10513 dgst_pos2 = 2;
10514 dgst_pos3 = 3;
10515 break;
10516
10517 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10518 salt_type = SALT_TYPE_EMBEDDED;
10519 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10520 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10521 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10522 dgst_size = DGST_SIZE_4_5;
10523 parse_func = veracrypt_parse_hash_327661;
10524 sort_by_digest = sort_by_digest_4_5;
10525 opti_type = OPTI_TYPE_ZERO_BYTE;
10526 dgst_pos0 = 0;
10527 dgst_pos1 = 1;
10528 dgst_pos2 = 2;
10529 dgst_pos3 = 3;
10530 break;
10531
10532 case 13751: hash_type = HASH_TYPE_SHA256;
10533 salt_type = SALT_TYPE_EMBEDDED;
10534 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10535 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10536 kern_type = KERN_TYPE_VCSHA256_XTS512;
10537 dgst_size = DGST_SIZE_4_8;
10538 parse_func = veracrypt_parse_hash_500000;
10539 sort_by_digest = sort_by_digest_4_8;
10540 opti_type = OPTI_TYPE_ZERO_BYTE;
10541 dgst_pos0 = 0;
10542 dgst_pos1 = 1;
10543 dgst_pos2 = 2;
10544 dgst_pos3 = 3;
10545 break;
10546
10547 case 13752: hash_type = HASH_TYPE_SHA256;
10548 salt_type = SALT_TYPE_EMBEDDED;
10549 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10550 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10551 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10552 dgst_size = DGST_SIZE_4_8;
10553 parse_func = veracrypt_parse_hash_500000;
10554 sort_by_digest = sort_by_digest_4_8;
10555 opti_type = OPTI_TYPE_ZERO_BYTE;
10556 dgst_pos0 = 0;
10557 dgst_pos1 = 1;
10558 dgst_pos2 = 2;
10559 dgst_pos3 = 3;
10560 break;
10561
10562 case 13753: hash_type = HASH_TYPE_SHA256;
10563 salt_type = SALT_TYPE_EMBEDDED;
10564 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10565 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10566 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10567 dgst_size = DGST_SIZE_4_8;
10568 parse_func = veracrypt_parse_hash_500000;
10569 sort_by_digest = sort_by_digest_4_8;
10570 opti_type = OPTI_TYPE_ZERO_BYTE;
10571 dgst_pos0 = 0;
10572 dgst_pos1 = 1;
10573 dgst_pos2 = 2;
10574 dgst_pos3 = 3;
10575 break;
10576
10577 case 13761: hash_type = HASH_TYPE_SHA256;
10578 salt_type = SALT_TYPE_EMBEDDED;
10579 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10580 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10581 kern_type = KERN_TYPE_VCSHA256_XTS512;
10582 dgst_size = DGST_SIZE_4_8;
10583 parse_func = veracrypt_parse_hash_200000;
10584 sort_by_digest = sort_by_digest_4_8;
10585 opti_type = OPTI_TYPE_ZERO_BYTE;
10586 dgst_pos0 = 0;
10587 dgst_pos1 = 1;
10588 dgst_pos2 = 2;
10589 dgst_pos3 = 3;
10590 break;
10591
10592 case 13762: hash_type = HASH_TYPE_SHA256;
10593 salt_type = SALT_TYPE_EMBEDDED;
10594 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10595 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10596 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10597 dgst_size = DGST_SIZE_4_8;
10598 parse_func = veracrypt_parse_hash_200000;
10599 sort_by_digest = sort_by_digest_4_8;
10600 opti_type = OPTI_TYPE_ZERO_BYTE;
10601 dgst_pos0 = 0;
10602 dgst_pos1 = 1;
10603 dgst_pos2 = 2;
10604 dgst_pos3 = 3;
10605 break;
10606
10607 case 13763: hash_type = HASH_TYPE_SHA256;
10608 salt_type = SALT_TYPE_EMBEDDED;
10609 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10610 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10611 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10612 dgst_size = DGST_SIZE_4_8;
10613 parse_func = veracrypt_parse_hash_200000;
10614 sort_by_digest = sort_by_digest_4_8;
10615 opti_type = OPTI_TYPE_ZERO_BYTE;
10616 dgst_pos0 = 0;
10617 dgst_pos1 = 1;
10618 dgst_pos2 = 2;
10619 dgst_pos3 = 3;
10620 break;
10621
10622
10623 default: usage_mini_print (PROGNAME); return (-1);
10624 }
10625
10626 /**
10627 * parser
10628 */
10629
10630 data.parse_func = parse_func;
10631
10632 /**
10633 * misc stuff
10634 */
10635
10636 if (hex_salt)
10637 {
10638 if (salt_type == SALT_TYPE_INTERN)
10639 {
10640 opts_type |= OPTS_TYPE_ST_HEX;
10641 }
10642 else
10643 {
10644 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10645
10646 return (-1);
10647 }
10648 }
10649
10650 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10651 | (salt_type == SALT_TYPE_EXTERN)
10652 | (salt_type == SALT_TYPE_EMBEDDED)
10653 | (salt_type == SALT_TYPE_VIRTUAL));
10654
10655 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10656
10657 data.hash_type = hash_type;
10658 data.attack_mode = attack_mode;
10659 data.attack_kern = attack_kern;
10660 data.attack_exec = attack_exec;
10661 data.kern_type = kern_type;
10662 data.opts_type = opts_type;
10663 data.dgst_size = dgst_size;
10664 data.salt_type = salt_type;
10665 data.isSalted = isSalted;
10666 data.sort_by_digest = sort_by_digest;
10667 data.dgst_pos0 = dgst_pos0;
10668 data.dgst_pos1 = dgst_pos1;
10669 data.dgst_pos2 = dgst_pos2;
10670 data.dgst_pos3 = dgst_pos3;
10671
10672 esalt_size = 0;
10673
10674 switch (hash_mode)
10675 {
10676 case 2500: esalt_size = sizeof (wpa_t); break;
10677 case 5300: esalt_size = sizeof (ikepsk_t); break;
10678 case 5400: esalt_size = sizeof (ikepsk_t); break;
10679 case 5500: esalt_size = sizeof (netntlm_t); break;
10680 case 5600: esalt_size = sizeof (netntlm_t); break;
10681 case 6211: esalt_size = sizeof (tc_t); break;
10682 case 6212: esalt_size = sizeof (tc_t); break;
10683 case 6213: esalt_size = sizeof (tc_t); break;
10684 case 6221: esalt_size = sizeof (tc_t); break;
10685 case 6222: esalt_size = sizeof (tc_t); break;
10686 case 6223: esalt_size = sizeof (tc_t); break;
10687 case 6231: esalt_size = sizeof (tc_t); break;
10688 case 6232: esalt_size = sizeof (tc_t); break;
10689 case 6233: esalt_size = sizeof (tc_t); break;
10690 case 6241: esalt_size = sizeof (tc_t); break;
10691 case 6242: esalt_size = sizeof (tc_t); break;
10692 case 6243: esalt_size = sizeof (tc_t); break;
10693 case 6600: esalt_size = sizeof (agilekey_t); break;
10694 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10695 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10696 case 7300: esalt_size = sizeof (rakp_t); break;
10697 case 7500: esalt_size = sizeof (krb5pa_t); break;
10698 case 8200: esalt_size = sizeof (cloudkey_t); break;
10699 case 8800: esalt_size = sizeof (androidfde_t); break;
10700 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10701 case 9400: esalt_size = sizeof (office2007_t); break;
10702 case 9500: esalt_size = sizeof (office2010_t); break;
10703 case 9600: esalt_size = sizeof (office2013_t); break;
10704 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10705 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10706 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10707 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10708 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10709 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10710 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10711 case 10200: esalt_size = sizeof (cram_md5_t); break;
10712 case 10400: esalt_size = sizeof (pdf_t); break;
10713 case 10410: esalt_size = sizeof (pdf_t); break;
10714 case 10420: esalt_size = sizeof (pdf_t); break;
10715 case 10500: esalt_size = sizeof (pdf_t); break;
10716 case 10600: esalt_size = sizeof (pdf_t); break;
10717 case 10700: esalt_size = sizeof (pdf_t); break;
10718 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10719 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10720 case 11400: esalt_size = sizeof (sip_t); break;
10721 case 11600: esalt_size = sizeof (seven_zip_t); break;
10722 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10723 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10724 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10725 case 13000: esalt_size = sizeof (rar5_t); break;
10726 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10727 case 13400: esalt_size = sizeof (keepass_t); break;
10728 case 13500: esalt_size = sizeof (pstoken_t); break;
10729 case 13600: esalt_size = sizeof (zip2_t); break;
10730 case 13711: esalt_size = sizeof (tc_t); break;
10731 case 13712: esalt_size = sizeof (tc_t); break;
10732 case 13713: esalt_size = sizeof (tc_t); break;
10733 case 13721: esalt_size = sizeof (tc_t); break;
10734 case 13722: esalt_size = sizeof (tc_t); break;
10735 case 13723: esalt_size = sizeof (tc_t); break;
10736 case 13731: esalt_size = sizeof (tc_t); break;
10737 case 13732: esalt_size = sizeof (tc_t); break;
10738 case 13733: esalt_size = sizeof (tc_t); break;
10739 case 13741: esalt_size = sizeof (tc_t); break;
10740 case 13742: esalt_size = sizeof (tc_t); break;
10741 case 13743: esalt_size = sizeof (tc_t); break;
10742 case 13751: esalt_size = sizeof (tc_t); break;
10743 case 13752: esalt_size = sizeof (tc_t); break;
10744 case 13753: esalt_size = sizeof (tc_t); break;
10745 case 13761: esalt_size = sizeof (tc_t); break;
10746 case 13762: esalt_size = sizeof (tc_t); break;
10747 case 13763: esalt_size = sizeof (tc_t); break;
10748 }
10749
10750 data.esalt_size = esalt_size;
10751
10752 /**
10753 * choose dictionary parser
10754 */
10755
10756 if (hash_type == HASH_TYPE_LM)
10757 {
10758 get_next_word_func = get_next_word_lm;
10759 }
10760 else if (opts_type & OPTS_TYPE_PT_UPPER)
10761 {
10762 get_next_word_func = get_next_word_uc;
10763 }
10764 else
10765 {
10766 get_next_word_func = get_next_word_std;
10767 }
10768
10769 /**
10770 * dictstat
10771 */
10772
10773 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10774
10775 #ifdef _POSIX
10776 size_t dictstat_nmemb = 0;
10777 #endif
10778
10779 #ifdef _WIN
10780 uint dictstat_nmemb = 0;
10781 #endif
10782
10783 char dictstat[256] = { 0 };
10784
10785 FILE *dictstat_fp = NULL;
10786
10787 if (keyspace == 0)
10788 {
10789 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10790
10791 dictstat_fp = fopen (dictstat, "rb");
10792
10793 if (dictstat_fp)
10794 {
10795 #ifdef _POSIX
10796 struct stat tmpstat;
10797
10798 fstat (fileno (dictstat_fp), &tmpstat);
10799 #endif
10800
10801 #ifdef _WIN
10802 struct stat64 tmpstat;
10803
10804 _fstat64 (fileno (dictstat_fp), &tmpstat);
10805 #endif
10806
10807 if (tmpstat.st_mtime < COMPTIME)
10808 {
10809 /* with v0.15 the format changed so we have to ensure user is using a good version
10810 since there is no version-header in the dictstat file */
10811
10812 fclose (dictstat_fp);
10813
10814 unlink (dictstat);
10815 }
10816 else
10817 {
10818 while (!feof (dictstat_fp))
10819 {
10820 dictstat_t d;
10821
10822 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10823
10824 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10825
10826 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10827 {
10828 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10829
10830 return -1;
10831 }
10832 }
10833
10834 fclose (dictstat_fp);
10835 }
10836 }
10837 }
10838
10839 /**
10840 * potfile
10841 */
10842
10843 char potfile[256] = { 0 };
10844
10845 if (potfile_path == NULL)
10846 {
10847 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10848 }
10849 else
10850 {
10851 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10852 }
10853
10854 data.pot_fp = NULL;
10855
10856 FILE *out_fp = NULL;
10857 FILE *pot_fp = NULL;
10858
10859 if (show == 1 || left == 1)
10860 {
10861 pot_fp = fopen (potfile, "rb");
10862
10863 if (pot_fp == NULL)
10864 {
10865 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10866
10867 return (-1);
10868 }
10869
10870 if (outfile != NULL)
10871 {
10872 if ((out_fp = fopen (outfile, "ab")) == NULL)
10873 {
10874 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10875
10876 fclose (pot_fp);
10877
10878 return (-1);
10879 }
10880 }
10881 else
10882 {
10883 out_fp = stdout;
10884 }
10885 }
10886 else
10887 {
10888 if (potfile_disable == 0)
10889 {
10890 pot_fp = fopen (potfile, "ab");
10891
10892 if (pot_fp == NULL)
10893 {
10894 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10895
10896 return (-1);
10897 }
10898
10899 data.pot_fp = pot_fp;
10900 }
10901 }
10902
10903 pot_t *pot = NULL;
10904
10905 uint pot_cnt = 0;
10906 uint pot_avail = 0;
10907
10908 if (show == 1 || left == 1)
10909 {
10910 SUPPRESS_OUTPUT = 1;
10911
10912 pot_avail = count_lines (pot_fp);
10913
10914 rewind (pot_fp);
10915
10916 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10917
10918 uint pot_hashes_avail = 0;
10919
10920 uint line_num = 0;
10921
10922 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10923
10924 while (!feof (pot_fp))
10925 {
10926 line_num++;
10927
10928 int line_len = fgetl (pot_fp, line_buf);
10929
10930 if (line_len == 0) continue;
10931
10932 char *plain_buf = line_buf + line_len;
10933
10934 pot_t *pot_ptr = &pot[pot_cnt];
10935
10936 hash_t *hashes_buf = &pot_ptr->hash;
10937
10938 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10939 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10940
10941 if (pot_cnt == pot_hashes_avail)
10942 {
10943 uint pos = 0;
10944
10945 for (pos = 0; pos < INCR_POT; pos++)
10946 {
10947 if ((pot_cnt + pos) >= pot_avail) break;
10948
10949 pot_t *tmp_pot = &pot[pot_cnt + pos];
10950
10951 hash_t *tmp_hash = &tmp_pot->hash;
10952
10953 tmp_hash->digest = mymalloc (dgst_size);
10954
10955 if (isSalted)
10956 {
10957 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10958 }
10959
10960 if (esalt_size)
10961 {
10962 tmp_hash->esalt = mymalloc (esalt_size);
10963 }
10964
10965 pot_hashes_avail++;
10966 }
10967 }
10968
10969 int plain_len = 0;
10970
10971 int parser_status;
10972
10973 int iter = MAX_CUT_TRIES;
10974
10975 do
10976 {
10977 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10978 {
10979 if (line_buf[i] == ':')
10980 {
10981 line_len--;
10982
10983 break;
10984 }
10985 }
10986
10987 if (data.hash_mode != 2500)
10988 {
10989 parser_status = parse_func (line_buf, line_len, hashes_buf);
10990 }
10991 else
10992 {
10993 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10994
10995 if (line_len > max_salt_size)
10996 {
10997 parser_status = PARSER_GLOBAL_LENGTH;
10998 }
10999 else
11000 {
11001 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11002
11003 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11004
11005 hashes_buf->salt->salt_len = line_len;
11006
11007 parser_status = PARSER_OK;
11008 }
11009 }
11010
11011 // if NOT parsed without error, we add the ":" to the plain
11012
11013 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11014 {
11015 plain_len++;
11016 plain_buf--;
11017 }
11018
11019 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11020
11021 if (parser_status < PARSER_GLOBAL_ZERO)
11022 {
11023 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11024
11025 continue;
11026 }
11027
11028 if (plain_len >= 255) continue;
11029
11030 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11031
11032 pot_ptr->plain_len = plain_len;
11033
11034 pot_cnt++;
11035 }
11036
11037 myfree (line_buf);
11038
11039 fclose (pot_fp);
11040
11041 SUPPRESS_OUTPUT = 0;
11042
11043 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11044 }
11045
11046 /**
11047 * word len
11048 */
11049
11050 uint pw_min = PW_MIN;
11051 uint pw_max = PW_MAX;
11052
11053 switch (hash_mode)
11054 {
11055 case 125: if (pw_max > 32) pw_max = 32;
11056 break;
11057 case 400: if (pw_max > 40) pw_max = 40;
11058 break;
11059 case 500: if (pw_max > 16) pw_max = 16;
11060 break;
11061 case 1500: if (pw_max > 8) pw_max = 8;
11062 break;
11063 case 1600: if (pw_max > 16) pw_max = 16;
11064 break;
11065 case 1800: if (pw_max > 16) pw_max = 16;
11066 break;
11067 case 2100: if (pw_max > 16) pw_max = 16;
11068 break;
11069 case 2500: if (pw_min < 8) pw_min = 8;
11070 break;
11071 case 3000: if (pw_max > 7) pw_max = 7;
11072 break;
11073 case 5200: if (pw_max > 24) pw_max = 24;
11074 break;
11075 case 5800: if (pw_max > 16) pw_max = 16;
11076 break;
11077 case 6300: if (pw_max > 16) pw_max = 16;
11078 break;
11079 case 7400: if (pw_max > 16) pw_max = 16;
11080 break;
11081 case 7900: if (pw_max > 48) pw_max = 48;
11082 break;
11083 case 8500: if (pw_max > 8) pw_max = 8;
11084 break;
11085 case 8600: if (pw_max > 16) pw_max = 16;
11086 break;
11087 case 9710: pw_min = 5;
11088 pw_max = 5;
11089 break;
11090 case 9810: pw_min = 5;
11091 pw_max = 5;
11092 break;
11093 case 10410: pw_min = 5;
11094 pw_max = 5;
11095 break;
11096 case 10300: if (pw_max < 3) pw_min = 3;
11097 if (pw_max > 40) pw_max = 40;
11098 break;
11099 case 10500: if (pw_max < 3) pw_min = 3;
11100 if (pw_max > 40) pw_max = 40;
11101 break;
11102 case 10700: if (pw_max > 16) pw_max = 16;
11103 break;
11104 case 11300: if (pw_max > 40) pw_max = 40;
11105 break;
11106 case 11600: if (pw_max > 32) pw_max = 32;
11107 break;
11108 case 12500: if (pw_max > 20) pw_max = 20;
11109 break;
11110 case 12800: if (pw_max > 24) pw_max = 24;
11111 break;
11112 }
11113
11114 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11115 {
11116 switch (attack_kern)
11117 {
11118 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11119 break;
11120 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11121 break;
11122 }
11123 }
11124
11125 /**
11126 * charsets : keep them together for more easy maintainnce
11127 */
11128
11129 cs_t mp_sys[6] = { { { 0 }, 0 } };
11130 cs_t mp_usr[4] = { { { 0 }, 0 } };
11131
11132 mp_setup_sys (mp_sys);
11133
11134 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11135 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11136 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11137 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11138
11139 /**
11140 * load hashes, part I: find input mode, count hashes
11141 */
11142
11143 uint hashlist_mode = 0;
11144 uint hashlist_format = HLFMT_HASHCAT;
11145
11146 uint hashes_avail = 0;
11147
11148 if (benchmark == 0)
11149 {
11150 struct stat f;
11151
11152 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11153
11154 if ((hash_mode == 2500) ||
11155 (hash_mode == 5200) ||
11156 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11157 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11158 (hash_mode == 9000))
11159 {
11160 hashlist_mode = HL_MODE_ARG;
11161
11162 char *hashfile = myargv[optind];
11163
11164 data.hashfile = hashfile;
11165
11166 logfile_top_var_string ("target", hashfile);
11167 }
11168
11169 if (hashlist_mode == HL_MODE_ARG)
11170 {
11171 if (hash_mode == 2500)
11172 {
11173 struct stat st;
11174
11175 if (stat (data.hashfile, &st) == -1)
11176 {
11177 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11178
11179 return (-1);
11180 }
11181
11182 hashes_avail = st.st_size / sizeof (hccap_t);
11183 }
11184 else
11185 {
11186 hashes_avail = 1;
11187 }
11188 }
11189 else if (hashlist_mode == HL_MODE_FILE)
11190 {
11191 char *hashfile = myargv[optind];
11192
11193 data.hashfile = hashfile;
11194
11195 logfile_top_var_string ("target", hashfile);
11196
11197 FILE *fp = NULL;
11198
11199 if ((fp = fopen (hashfile, "rb")) == NULL)
11200 {
11201 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11202
11203 return (-1);
11204 }
11205
11206 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11207
11208 hashes_avail = count_lines (fp);
11209
11210 rewind (fp);
11211
11212 if (hashes_avail == 0)
11213 {
11214 log_error ("ERROR: hashfile is empty or corrupt");
11215
11216 fclose (fp);
11217
11218 return (-1);
11219 }
11220
11221 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11222
11223 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11224 {
11225 log_error ("ERROR: remove not supported in native hashfile-format mode");
11226
11227 fclose (fp);
11228
11229 return (-1);
11230 }
11231
11232 fclose (fp);
11233 }
11234 }
11235 else
11236 {
11237 hashlist_mode = HL_MODE_ARG;
11238
11239 hashes_avail = 1;
11240 }
11241
11242 if (hash_mode == 3000) hashes_avail *= 2;
11243
11244 data.hashlist_mode = hashlist_mode;
11245 data.hashlist_format = hashlist_format;
11246
11247 logfile_top_uint (hashlist_mode);
11248 logfile_top_uint (hashlist_format);
11249
11250 /**
11251 * load hashes, part II: allocate required memory, set pointers
11252 */
11253
11254 hash_t *hashes_buf = NULL;
11255 void *digests_buf = NULL;
11256 salt_t *salts_buf = NULL;
11257 void *esalts_buf = NULL;
11258
11259 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11260
11261 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11262
11263 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11264 {
11265 u32 hash_pos;
11266
11267 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11268 {
11269 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11270
11271 hashes_buf[hash_pos].hash_info = hash_info;
11272
11273 if (username && (remove || show || left))
11274 {
11275 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11276 }
11277
11278 if (benchmark)
11279 {
11280 hash_info->orighash = (char *) mymalloc (256);
11281 }
11282 }
11283 }
11284
11285 if (isSalted)
11286 {
11287 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11288
11289 if (esalt_size)
11290 {
11291 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11292 }
11293 }
11294 else
11295 {
11296 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11297 }
11298
11299 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11300 {
11301 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11302
11303 if (isSalted)
11304 {
11305 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11306
11307 if (esalt_size)
11308 {
11309 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11310 }
11311 }
11312 else
11313 {
11314 hashes_buf[hash_pos].salt = &salts_buf[0];
11315 }
11316 }
11317
11318 /**
11319 * load hashes, part III: parse hashes or generate them if benchmark
11320 */
11321
11322 uint hashes_cnt = 0;
11323
11324 if (benchmark == 0)
11325 {
11326 if (keyspace == 1)
11327 {
11328 // useless to read hash file for keyspace, cheat a little bit w/ optind
11329 }
11330 else if (hashes_avail == 0)
11331 {
11332 }
11333 else if (hashlist_mode == HL_MODE_ARG)
11334 {
11335 char *input_buf = myargv[optind];
11336
11337 uint input_len = strlen (input_buf);
11338
11339 logfile_top_var_string ("target", input_buf);
11340
11341 char *hash_buf = NULL;
11342 int hash_len = 0;
11343
11344 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11345
11346 bool hash_fmt_error = 0;
11347
11348 if (hash_len < 1) hash_fmt_error = 1;
11349 if (hash_buf == NULL) hash_fmt_error = 1;
11350
11351 if (hash_fmt_error)
11352 {
11353 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11354 }
11355 else
11356 {
11357 if (opts_type & OPTS_TYPE_HASH_COPY)
11358 {
11359 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11360
11361 hash_info_tmp->orighash = mystrdup (hash_buf);
11362 }
11363
11364 if (isSalted)
11365 {
11366 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11367 }
11368
11369 int parser_status = PARSER_OK;
11370
11371 if (hash_mode == 2500)
11372 {
11373 if (hash_len == 0)
11374 {
11375 log_error ("ERROR: hccap file not specified");
11376
11377 return (-1);
11378 }
11379
11380 hashlist_mode = HL_MODE_FILE;
11381
11382 data.hashlist_mode = hashlist_mode;
11383
11384 FILE *fp = fopen (hash_buf, "rb");
11385
11386 if (fp == NULL)
11387 {
11388 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11389
11390 return (-1);
11391 }
11392
11393 if (hashes_avail < 1)
11394 {
11395 log_error ("ERROR: hccap file is empty or corrupt");
11396
11397 fclose (fp);
11398
11399 return (-1);
11400 }
11401
11402 uint hccap_size = sizeof (hccap_t);
11403
11404 char *in = (char *) mymalloc (hccap_size);
11405
11406 while (!feof (fp))
11407 {
11408 int n = fread (in, hccap_size, 1, fp);
11409
11410 if (n != 1)
11411 {
11412 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11413
11414 break;
11415 }
11416
11417 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11418
11419 if (parser_status != PARSER_OK)
11420 {
11421 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11422
11423 continue;
11424 }
11425
11426 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11427
11428 if ((show == 1) || (left == 1))
11429 {
11430 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11431
11432 char *salt_ptr = (char *) tmp_salt->salt_buf;
11433
11434 int cur_pos = tmp_salt->salt_len;
11435 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11436
11437 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11438
11439 // do the appending task
11440
11441 snprintf (salt_ptr + cur_pos,
11442 rem_len,
11443 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11444 wpa->orig_mac1[0],
11445 wpa->orig_mac1[1],
11446 wpa->orig_mac1[2],
11447 wpa->orig_mac1[3],
11448 wpa->orig_mac1[4],
11449 wpa->orig_mac1[5],
11450 wpa->orig_mac2[0],
11451 wpa->orig_mac2[1],
11452 wpa->orig_mac2[2],
11453 wpa->orig_mac2[3],
11454 wpa->orig_mac2[4],
11455 wpa->orig_mac2[5]);
11456
11457 // memset () the remaining part of the salt
11458
11459 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11460 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11461
11462 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11463
11464 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11465 }
11466
11467 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);
11468 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);
11469
11470 hashes_cnt++;
11471 }
11472
11473 fclose (fp);
11474
11475 myfree (in);
11476 }
11477 else if (hash_mode == 3000)
11478 {
11479 if (hash_len == 32)
11480 {
11481 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11482
11483 hash_t *lm_hash_left = NULL;
11484
11485 if (parser_status == PARSER_OK)
11486 {
11487 lm_hash_left = &hashes_buf[hashes_cnt];
11488
11489 hashes_cnt++;
11490 }
11491 else
11492 {
11493 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11494 }
11495
11496 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11497
11498 hash_t *lm_hash_right = NULL;
11499
11500 if (parser_status == PARSER_OK)
11501 {
11502 lm_hash_right = &hashes_buf[hashes_cnt];
11503
11504 hashes_cnt++;
11505 }
11506 else
11507 {
11508 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11509 }
11510
11511 // show / left
11512
11513 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11514 {
11515 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);
11516 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);
11517 }
11518 }
11519 else
11520 {
11521 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11522
11523 if (parser_status == PARSER_OK)
11524 {
11525 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11526 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11527 }
11528
11529 if (parser_status == PARSER_OK)
11530 {
11531 hashes_cnt++;
11532 }
11533 else
11534 {
11535 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11536 }
11537 }
11538 }
11539 else
11540 {
11541 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11542
11543 if (parser_status == PARSER_OK)
11544 {
11545 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11546 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11547 }
11548
11549 if (parser_status == PARSER_OK)
11550 {
11551 hashes_cnt++;
11552 }
11553 else
11554 {
11555 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11556 }
11557 }
11558 }
11559 }
11560 else if (hashlist_mode == HL_MODE_FILE)
11561 {
11562 char *hashfile = data.hashfile;
11563
11564 FILE *fp;
11565
11566 if ((fp = fopen (hashfile, "rb")) == NULL)
11567 {
11568 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11569
11570 return (-1);
11571 }
11572
11573 uint line_num = 0;
11574
11575 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11576
11577 while (!feof (fp))
11578 {
11579 line_num++;
11580
11581 int line_len = fgetl (fp, line_buf);
11582
11583 if (line_len == 0) continue;
11584
11585 char *hash_buf = NULL;
11586 int hash_len = 0;
11587
11588 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11589
11590 bool hash_fmt_error = 0;
11591
11592 if (hash_len < 1) hash_fmt_error = 1;
11593 if (hash_buf == NULL) hash_fmt_error = 1;
11594
11595 if (hash_fmt_error)
11596 {
11597 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11598
11599 continue;
11600 }
11601
11602 if (username)
11603 {
11604 char *user_buf = NULL;
11605 int user_len = 0;
11606
11607 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11608
11609 if (remove || show)
11610 {
11611 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11612
11613 *user = (user_t *) mymalloc (sizeof (user_t));
11614
11615 user_t *user_ptr = *user;
11616
11617 if (user_buf != NULL)
11618 {
11619 user_ptr->user_name = mystrdup (user_buf);
11620 }
11621 else
11622 {
11623 user_ptr->user_name = mystrdup ("");
11624 }
11625
11626 user_ptr->user_len = user_len;
11627 }
11628 }
11629
11630 if (opts_type & OPTS_TYPE_HASH_COPY)
11631 {
11632 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11633
11634 hash_info_tmp->orighash = mystrdup (hash_buf);
11635 }
11636
11637 if (isSalted)
11638 {
11639 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11640 }
11641
11642 if (hash_mode == 3000)
11643 {
11644 if (hash_len == 32)
11645 {
11646 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11647
11648 if (parser_status < PARSER_GLOBAL_ZERO)
11649 {
11650 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11651
11652 continue;
11653 }
11654
11655 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11656
11657 hashes_cnt++;
11658
11659 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11660
11661 if (parser_status < PARSER_GLOBAL_ZERO)
11662 {
11663 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11664
11665 continue;
11666 }
11667
11668 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11669
11670 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);
11671
11672 hashes_cnt++;
11673
11674 // show / left
11675
11676 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);
11677 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);
11678 }
11679 else
11680 {
11681 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11682
11683 if (parser_status < PARSER_GLOBAL_ZERO)
11684 {
11685 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11686
11687 continue;
11688 }
11689
11690 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);
11691
11692 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11693 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11694
11695 hashes_cnt++;
11696 }
11697 }
11698 else
11699 {
11700 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11701
11702 if (parser_status < PARSER_GLOBAL_ZERO)
11703 {
11704 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11705
11706 continue;
11707 }
11708
11709 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);
11710
11711 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11712 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11713
11714 hashes_cnt++;
11715 }
11716 }
11717
11718 myfree (line_buf);
11719
11720 fclose (fp);
11721
11722 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11723
11724 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11725 }
11726 }
11727 else
11728 {
11729 if (isSalted)
11730 {
11731 hashes_buf[0].salt->salt_len = 8;
11732
11733 // special salt handling
11734
11735 switch (hash_mode)
11736 {
11737 case 1500: hashes_buf[0].salt->salt_len = 2;
11738 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11739 break;
11740 case 1731: hashes_buf[0].salt->salt_len = 4;
11741 break;
11742 case 2410: hashes_buf[0].salt->salt_len = 4;
11743 break;
11744 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11745 break;
11746 case 3100: hashes_buf[0].salt->salt_len = 1;
11747 break;
11748 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11749 break;
11750 case 5800: hashes_buf[0].salt->salt_len = 16;
11751 break;
11752 case 6800: hashes_buf[0].salt->salt_len = 32;
11753 break;
11754 case 8400: hashes_buf[0].salt->salt_len = 40;
11755 break;
11756 case 8800: hashes_buf[0].salt->salt_len = 16;
11757 break;
11758 case 8900: hashes_buf[0].salt->salt_len = 16;
11759 hashes_buf[0].salt->scrypt_N = 1024;
11760 hashes_buf[0].salt->scrypt_r = 1;
11761 hashes_buf[0].salt->scrypt_p = 1;
11762 break;
11763 case 9100: hashes_buf[0].salt->salt_len = 16;
11764 break;
11765 case 9300: hashes_buf[0].salt->salt_len = 14;
11766 hashes_buf[0].salt->scrypt_N = 16384;
11767 hashes_buf[0].salt->scrypt_r = 1;
11768 hashes_buf[0].salt->scrypt_p = 1;
11769 break;
11770 case 9400: hashes_buf[0].salt->salt_len = 16;
11771 break;
11772 case 9500: hashes_buf[0].salt->salt_len = 16;
11773 break;
11774 case 9600: hashes_buf[0].salt->salt_len = 16;
11775 break;
11776 case 9700: hashes_buf[0].salt->salt_len = 16;
11777 break;
11778 case 9710: hashes_buf[0].salt->salt_len = 16;
11779 break;
11780 case 9720: hashes_buf[0].salt->salt_len = 16;
11781 break;
11782 case 9800: hashes_buf[0].salt->salt_len = 16;
11783 break;
11784 case 9810: hashes_buf[0].salt->salt_len = 16;
11785 break;
11786 case 9820: hashes_buf[0].salt->salt_len = 16;
11787 break;
11788 case 10300: hashes_buf[0].salt->salt_len = 12;
11789 break;
11790 case 11500: hashes_buf[0].salt->salt_len = 4;
11791 break;
11792 case 11600: hashes_buf[0].salt->salt_len = 4;
11793 break;
11794 case 12400: hashes_buf[0].salt->salt_len = 4;
11795 break;
11796 case 12500: hashes_buf[0].salt->salt_len = 8;
11797 break;
11798 case 12600: hashes_buf[0].salt->salt_len = 64;
11799 break;
11800 }
11801
11802 // special esalt handling
11803
11804 switch (hash_mode)
11805 {
11806 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11807 break;
11808 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11809 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11810 break;
11811 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11812 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11813 break;
11814 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11815 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11816 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11817 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11818 break;
11819 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11820 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11821 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11822 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11823 break;
11824 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11825 break;
11826 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11827 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11828 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11829 break;
11830 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11831 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11832 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11833 break;
11834 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11835 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11836 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11837 break;
11838 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11839 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11840 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11841 break;
11842 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11843 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11844 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11845 break;
11846 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11847 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11848 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11849 break;
11850 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11851 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11852 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11853 break;
11854 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11855 break;
11856 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11857 break;
11858 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11859 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11860 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11861 break;
11862 }
11863 }
11864
11865 // set hashfile
11866
11867 switch (hash_mode)
11868 {
11869 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11870 break;
11871 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11872 break;
11873 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11874 break;
11875 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11876 break;
11877 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11878 break;
11879 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11880 break;
11881 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11882 break;
11883 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11884 break;
11885 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11886 break;
11887 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11888 break;
11889 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11890 break;
11891 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11892 break;
11893 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11894 break;
11895 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11896 break;
11897 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11898 break;
11899 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11900 break;
11901 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11902 break;
11903 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11904 break;
11905 case 13711: data.hashfile = mystrdup ("hashcat.vc");
11906 break;
11907 case 13712: data.hashfile = mystrdup ("hashcat.vc");
11908 break;
11909 case 13713: data.hashfile = mystrdup ("hashcat.vc");
11910 break;
11911 case 13721: data.hashfile = mystrdup ("hashcat.vc");
11912 break;
11913 case 13722: data.hashfile = mystrdup ("hashcat.vc");
11914 break;
11915 case 13723: data.hashfile = mystrdup ("hashcat.vc");
11916 break;
11917 case 13731: data.hashfile = mystrdup ("hashcat.vc");
11918 break;
11919 case 13732: data.hashfile = mystrdup ("hashcat.vc");
11920 break;
11921 case 13733: data.hashfile = mystrdup ("hashcat.vc");
11922 break;
11923 case 13741: data.hashfile = mystrdup ("hashcat.vc");
11924 break;
11925 case 13742: data.hashfile = mystrdup ("hashcat.vc");
11926 break;
11927 case 13743: data.hashfile = mystrdup ("hashcat.vc");
11928 break;
11929 case 13751: data.hashfile = mystrdup ("hashcat.vc");
11930 break;
11931 case 13752: data.hashfile = mystrdup ("hashcat.vc");
11932 break;
11933 case 13753: data.hashfile = mystrdup ("hashcat.vc");
11934 break;
11935 case 13761: data.hashfile = mystrdup ("hashcat.vc");
11936 break;
11937 case 13762: data.hashfile = mystrdup ("hashcat.vc");
11938 break;
11939 case 13763: data.hashfile = mystrdup ("hashcat.vc");
11940 break;
11941 }
11942
11943 // set default iterations
11944
11945 switch (hash_mode)
11946 {
11947 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11948 break;
11949 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11950 break;
11951 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11952 break;
11953 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11954 break;
11955 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11956 break;
11957 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11958 break;
11959 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11960 break;
11961 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11962 break;
11963 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11964 break;
11965 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11966 break;
11967 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11968 break;
11969 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11970 break;
11971 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11972 break;
11973 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11974 break;
11975 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11976 break;
11977 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11978 break;
11979 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11980 break;
11981 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11982 break;
11983 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11984 break;
11985 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11986 break;
11987 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11988 break;
11989 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11990 break;
11991 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11992 break;
11993 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11994 break;
11995 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11996 break;
11997 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11998 break;
11999 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12000 break;
12001 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12002 break;
12003 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12004 break;
12005 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12006 break;
12007 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12008 break;
12009 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12010 break;
12011 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12012 break;
12013 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12014 break;
12015 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12016 break;
12017 case 8900: hashes_buf[0].salt->salt_iter = 1;
12018 break;
12019 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12020 break;
12021 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12022 break;
12023 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12024 break;
12025 case 9300: hashes_buf[0].salt->salt_iter = 1;
12026 break;
12027 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12028 break;
12029 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12030 break;
12031 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12032 break;
12033 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12034 break;
12035 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12036 break;
12037 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12038 break;
12039 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12040 break;
12041 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12042 break;
12043 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12044 break;
12045 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12046 break;
12047 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12048 break;
12049 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12050 break;
12051 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12052 break;
12053 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12054 break;
12055 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12056 break;
12057 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12058 break;
12059 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12060 break;
12061 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12062 break;
12063 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12064 break;
12065 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12066 break;
12067 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12068 break;
12069 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12070 break;
12071 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12072 break;
12073 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12074 break;
12075 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12076 break;
12077 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12078 break;
12079 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12080 break;
12081 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12082 break;
12083 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12084 break;
12085 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12086 break;
12087 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12088 break;
12089 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12090 break;
12091 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12092 break;
12093 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12094 break;
12095 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12096 break;
12097 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12098 break;
12099 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12100 break;
12101 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12102 break;
12103 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12104 break;
12105 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12106 break;
12107 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12108 break;
12109 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12110 break;
12111 }
12112
12113 hashes_cnt = 1;
12114 }
12115
12116 if (show == 1 || left == 1)
12117 {
12118 for (uint i = 0; i < pot_cnt; i++)
12119 {
12120 pot_t *pot_ptr = &pot[i];
12121
12122 hash_t *hashes_buf = &pot_ptr->hash;
12123
12124 local_free (hashes_buf->digest);
12125
12126 if (isSalted)
12127 {
12128 local_free (hashes_buf->salt);
12129 }
12130 }
12131
12132 local_free (pot);
12133
12134 if (data.quiet == 0) log_info_nn ("");
12135
12136 return (0);
12137 }
12138
12139 if (keyspace == 0)
12140 {
12141 if (hashes_cnt == 0)
12142 {
12143 log_error ("ERROR: No hashes loaded");
12144
12145 return (-1);
12146 }
12147 }
12148
12149 /**
12150 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12151 */
12152
12153 if (data.outfile != NULL)
12154 {
12155 if (data.hashfile != NULL)
12156 {
12157 #ifdef _POSIX
12158 struct stat tmpstat_outfile;
12159 struct stat tmpstat_hashfile;
12160 #endif
12161
12162 #ifdef _WIN
12163 struct stat64 tmpstat_outfile;
12164 struct stat64 tmpstat_hashfile;
12165 #endif
12166
12167 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12168
12169 if (tmp_outfile_fp)
12170 {
12171 #ifdef _POSIX
12172 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12173 #endif
12174
12175 #ifdef _WIN
12176 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12177 #endif
12178
12179 fclose (tmp_outfile_fp);
12180 }
12181
12182 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12183
12184 if (tmp_hashfile_fp)
12185 {
12186 #ifdef _POSIX
12187 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12188 #endif
12189
12190 #ifdef _WIN
12191 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12192 #endif
12193
12194 fclose (tmp_hashfile_fp);
12195 }
12196
12197 if (tmp_outfile_fp && tmp_outfile_fp)
12198 {
12199 tmpstat_outfile.st_mode = 0;
12200 tmpstat_outfile.st_nlink = 0;
12201 tmpstat_outfile.st_uid = 0;
12202 tmpstat_outfile.st_gid = 0;
12203 tmpstat_outfile.st_rdev = 0;
12204 tmpstat_outfile.st_atime = 0;
12205
12206 tmpstat_hashfile.st_mode = 0;
12207 tmpstat_hashfile.st_nlink = 0;
12208 tmpstat_hashfile.st_uid = 0;
12209 tmpstat_hashfile.st_gid = 0;
12210 tmpstat_hashfile.st_rdev = 0;
12211 tmpstat_hashfile.st_atime = 0;
12212
12213 #ifdef _POSIX
12214 tmpstat_outfile.st_blksize = 0;
12215 tmpstat_outfile.st_blocks = 0;
12216
12217 tmpstat_hashfile.st_blksize = 0;
12218 tmpstat_hashfile.st_blocks = 0;
12219 #endif
12220
12221 #ifdef _POSIX
12222 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12223 {
12224 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12225
12226 return (-1);
12227 }
12228 #endif
12229
12230 #ifdef _WIN
12231 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12232 {
12233 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12234
12235 return (-1);
12236 }
12237 #endif
12238 }
12239 }
12240 }
12241
12242 /**
12243 * Remove duplicates
12244 */
12245
12246 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12247
12248 if (isSalted)
12249 {
12250 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12251 }
12252 else
12253 {
12254 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12255 }
12256
12257 uint hashes_cnt_orig = hashes_cnt;
12258
12259 hashes_cnt = 1;
12260
12261 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12262 {
12263 if (isSalted)
12264 {
12265 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12266 {
12267 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12268 }
12269 }
12270 else
12271 {
12272 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12273 }
12274
12275 if (hashes_pos > hashes_cnt)
12276 {
12277 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12278 }
12279
12280 hashes_cnt++;
12281 }
12282
12283 /**
12284 * Potfile removes
12285 */
12286
12287 uint potfile_remove_cracks = 0;
12288
12289 if (potfile_disable == 0)
12290 {
12291 hash_t hash_buf;
12292
12293 hash_buf.digest = mymalloc (dgst_size);
12294 hash_buf.salt = NULL;
12295 hash_buf.esalt = NULL;
12296 hash_buf.hash_info = NULL;
12297 hash_buf.cracked = 0;
12298
12299 if (isSalted)
12300 {
12301 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12302 }
12303
12304 if (esalt_size)
12305 {
12306 hash_buf.esalt = mymalloc (esalt_size);
12307 }
12308
12309 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12310
12311 // no solution for these special hash types (for instane because they use hashfile in output etc)
12312 if ((hash_mode != 5200) &&
12313 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12314 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12315 (hash_mode != 9000))
12316 {
12317 FILE *fp = fopen (potfile, "rb");
12318
12319 if (fp != NULL)
12320 {
12321 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12322
12323 // to be safe work with a copy (because of line_len loop, i etc)
12324 // moved up here because it's easier to handle continue case
12325 // it's just 64kb
12326
12327 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12328
12329 while (!feof (fp))
12330 {
12331 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12332
12333 if (ptr == NULL) break;
12334
12335 int line_len = strlen (line_buf);
12336
12337 if (line_len == 0) continue;
12338
12339 int iter = MAX_CUT_TRIES;
12340
12341 for (int i = line_len - 1; i && iter; i--, line_len--)
12342 {
12343 if (line_buf[i] != ':') continue;
12344
12345 if (isSalted)
12346 {
12347 memset (hash_buf.salt, 0, sizeof (salt_t));
12348 }
12349
12350 hash_t *found = NULL;
12351
12352 if (hash_mode == 6800)
12353 {
12354 if (i < 64) // 64 = 16 * uint in salt_buf[]
12355 {
12356 // manipulate salt_buf
12357 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12358
12359 hash_buf.salt->salt_len = i;
12360
12361 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12362 }
12363 }
12364 else if (hash_mode == 2500)
12365 {
12366 if (i < 64) // 64 = 16 * uint in salt_buf[]
12367 {
12368 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12369 // manipulate salt_buf
12370
12371 memcpy (line_buf_cpy, line_buf, i);
12372
12373 char *mac2_pos = strrchr (line_buf_cpy, ':');
12374
12375 if (mac2_pos == NULL) continue;
12376
12377 mac2_pos[0] = 0;
12378 mac2_pos++;
12379
12380 if (strlen (mac2_pos) != 12) continue;
12381
12382 char *mac1_pos = strrchr (line_buf_cpy, ':');
12383
12384 if (mac1_pos == NULL) continue;
12385
12386 mac1_pos[0] = 0;
12387 mac1_pos++;
12388
12389 if (strlen (mac1_pos) != 12) continue;
12390
12391 uint essid_length = mac1_pos - line_buf_cpy - 1;
12392
12393 // here we need the ESSID
12394 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12395
12396 hash_buf.salt->salt_len = essid_length;
12397
12398 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12399
12400 if (found)
12401 {
12402 wpa_t *wpa = (wpa_t *) found->esalt;
12403
12404 // compare hex string(s) vs binary MAC address(es)
12405
12406 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12407 {
12408 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12409 {
12410 found = NULL;
12411
12412 break;
12413 }
12414 }
12415
12416 // early skip ;)
12417 if (!found) continue;
12418
12419 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12420 {
12421 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12422 {
12423 found = NULL;
12424
12425 break;
12426 }
12427 }
12428 }
12429 }
12430 }
12431 else
12432 {
12433 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12434
12435 if (parser_status == PARSER_OK)
12436 {
12437 if (isSalted)
12438 {
12439 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12440 }
12441 else
12442 {
12443 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12444 }
12445 }
12446 }
12447
12448 if (found == NULL) continue;
12449
12450 if (!found->cracked) potfile_remove_cracks++;
12451
12452 found->cracked = 1;
12453
12454 if (found) break;
12455
12456 iter--;
12457 }
12458 }
12459
12460 myfree (line_buf_cpy);
12461
12462 myfree (line_buf);
12463
12464 fclose (fp);
12465 }
12466 }
12467
12468 if (esalt_size)
12469 {
12470 local_free (hash_buf.esalt);
12471 }
12472
12473 if (isSalted)
12474 {
12475 local_free (hash_buf.salt);
12476 }
12477
12478 local_free (hash_buf.digest);
12479 }
12480
12481 /**
12482 * Now generate all the buffers required for later
12483 */
12484
12485 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12486
12487 salt_t *salts_buf_new = NULL;
12488 void *esalts_buf_new = NULL;
12489
12490 if (isSalted)
12491 {
12492 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12493
12494 if (esalt_size)
12495 {
12496 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12497 }
12498 }
12499 else
12500 {
12501 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12502 }
12503
12504 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12505
12506 uint digests_cnt = hashes_cnt;
12507 uint digests_done = 0;
12508
12509 size_t size_digests = digests_cnt * dgst_size;
12510 size_t size_shown = digests_cnt * sizeof (uint);
12511
12512 uint *digests_shown = (uint *) mymalloc (size_shown);
12513 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12514
12515 uint salts_cnt = 0;
12516 uint salts_done = 0;
12517
12518 hashinfo_t **hash_info = NULL;
12519
12520 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12521 {
12522 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12523
12524 if (username && (remove || show))
12525 {
12526 uint user_pos;
12527
12528 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12529 {
12530 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12531
12532 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12533 }
12534 }
12535 }
12536
12537 uint *salts_shown = (uint *) mymalloc (size_shown);
12538
12539 salt_t *salt_buf;
12540
12541 {
12542 // copied from inner loop
12543
12544 salt_buf = &salts_buf_new[salts_cnt];
12545
12546 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12547
12548 if (esalt_size)
12549 {
12550 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12551 }
12552
12553 salt_buf->digests_cnt = 0;
12554 salt_buf->digests_done = 0;
12555 salt_buf->digests_offset = 0;
12556
12557 salts_cnt++;
12558 }
12559
12560 if (hashes_buf[0].cracked == 1)
12561 {
12562 digests_shown[0] = 1;
12563
12564 digests_done++;
12565
12566 salt_buf->digests_done++;
12567 }
12568
12569 salt_buf->digests_cnt++;
12570
12571 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12572
12573 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12574 {
12575 hash_info[0] = hashes_buf[0].hash_info;
12576 }
12577
12578 // copy from inner loop
12579
12580 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12581 {
12582 if (isSalted)
12583 {
12584 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12585 {
12586 salt_buf = &salts_buf_new[salts_cnt];
12587
12588 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12589
12590 if (esalt_size)
12591 {
12592 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12593 }
12594
12595 salt_buf->digests_cnt = 0;
12596 salt_buf->digests_done = 0;
12597 salt_buf->digests_offset = hashes_pos;
12598
12599 salts_cnt++;
12600 }
12601 }
12602
12603 if (hashes_buf[hashes_pos].cracked == 1)
12604 {
12605 digests_shown[hashes_pos] = 1;
12606
12607 digests_done++;
12608
12609 salt_buf->digests_done++;
12610 }
12611
12612 salt_buf->digests_cnt++;
12613
12614 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12615
12616 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12617 {
12618 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12619 }
12620 }
12621
12622 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12623 {
12624 salt_t *salt_buf = &salts_buf_new[salt_pos];
12625
12626 if (salt_buf->digests_done == salt_buf->digests_cnt)
12627 {
12628 salts_shown[salt_pos] = 1;
12629
12630 salts_done++;
12631 }
12632
12633 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12634 }
12635
12636 local_free (digests_buf);
12637 local_free (salts_buf);
12638 local_free (esalts_buf);
12639
12640 digests_buf = digests_buf_new;
12641 salts_buf = salts_buf_new;
12642 esalts_buf = esalts_buf_new;
12643
12644 local_free (hashes_buf);
12645
12646 /**
12647 * special modification not set from parser
12648 */
12649
12650 switch (hash_mode)
12651 {
12652 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12653 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12654 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12655 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12656 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12657 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12658 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12659 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12660 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12661 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12662 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12663 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12664 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12665 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12666 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12667 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12668 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12669 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12670 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12671 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12672 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12673 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12674 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12675 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12676 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12677 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12678 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12679 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12680 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12681 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12682 }
12683
12684 if (truecrypt_keyfiles)
12685 {
12686 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12687
12688 char *keyfiles = strdup (truecrypt_keyfiles);
12689
12690 char *keyfile = strtok (keyfiles, ",");
12691
12692 do
12693 {
12694 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12695
12696 } while ((keyfile = strtok (NULL, ",")) != NULL);
12697
12698 free (keyfiles);
12699 }
12700
12701 if (veracrypt_keyfiles)
12702 {
12703 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12704
12705 char *keyfiles = strdup (veracrypt_keyfiles);
12706
12707 char *keyfile = strtok (keyfiles, ",");
12708
12709 do
12710 {
12711 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12712
12713 } while ((keyfile = strtok (NULL, ",")) != NULL);
12714
12715 free (keyfiles);
12716 }
12717
12718 data.digests_cnt = digests_cnt;
12719 data.digests_done = digests_done;
12720 data.digests_buf = digests_buf;
12721 data.digests_shown = digests_shown;
12722 data.digests_shown_tmp = digests_shown_tmp;
12723
12724 data.salts_cnt = salts_cnt;
12725 data.salts_done = salts_done;
12726 data.salts_buf = salts_buf;
12727 data.salts_shown = salts_shown;
12728
12729 data.esalts_buf = esalts_buf;
12730 data.hash_info = hash_info;
12731
12732 /**
12733 * Automatic Optimizers
12734 */
12735
12736 if (salts_cnt == 1)
12737 opti_type |= OPTI_TYPE_SINGLE_SALT;
12738
12739 if (digests_cnt == 1)
12740 opti_type |= OPTI_TYPE_SINGLE_HASH;
12741
12742 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12743 opti_type |= OPTI_TYPE_NOT_ITERATED;
12744
12745 if (attack_mode == ATTACK_MODE_BF)
12746 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12747
12748 data.opti_type = opti_type;
12749
12750 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12751 {
12752 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12753 {
12754 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12755 {
12756 if (opts_type & OPTS_TYPE_ST_ADD80)
12757 {
12758 opts_type &= ~OPTS_TYPE_ST_ADD80;
12759 opts_type |= OPTS_TYPE_PT_ADD80;
12760 }
12761
12762 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12763 {
12764 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12765 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12766 }
12767
12768 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12769 {
12770 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12771 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12772 }
12773 }
12774 }
12775 }
12776
12777 /**
12778 * Some algorithm, like descrypt, can benefit from JIT compilation
12779 */
12780
12781 int force_jit_compilation = -1;
12782
12783 if (hash_mode == 8900)
12784 {
12785 force_jit_compilation = 8900;
12786 }
12787 else if (hash_mode == 9300)
12788 {
12789 force_jit_compilation = 8900;
12790 }
12791 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12792 {
12793 force_jit_compilation = 1500;
12794 }
12795
12796 /**
12797 * generate bitmap tables
12798 */
12799
12800 const uint bitmap_shift1 = 5;
12801 const uint bitmap_shift2 = 13;
12802
12803 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12804
12805 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12806 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12807 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12808 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12809 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12810 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12811 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12812 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12813
12814 uint bitmap_bits;
12815 uint bitmap_nums;
12816 uint bitmap_mask;
12817 uint bitmap_size;
12818
12819 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12820 {
12821 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12822
12823 bitmap_nums = 1 << bitmap_bits;
12824
12825 bitmap_mask = bitmap_nums - 1;
12826
12827 bitmap_size = bitmap_nums * sizeof (uint);
12828
12829 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12830
12831 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;
12832 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;
12833
12834 break;
12835 }
12836
12837 bitmap_nums = 1 << bitmap_bits;
12838
12839 bitmap_mask = bitmap_nums - 1;
12840
12841 bitmap_size = bitmap_nums * sizeof (uint);
12842
12843 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);
12844 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);
12845
12846 /**
12847 * prepare quick rule
12848 */
12849
12850 data.rule_buf_l = rule_buf_l;
12851 data.rule_buf_r = rule_buf_r;
12852
12853 int rule_len_l = (int) strlen (rule_buf_l);
12854 int rule_len_r = (int) strlen (rule_buf_r);
12855
12856 data.rule_len_l = rule_len_l;
12857 data.rule_len_r = rule_len_r;
12858
12859 /**
12860 * load rules
12861 */
12862
12863 uint *all_kernel_rules_cnt = NULL;
12864
12865 kernel_rule_t **all_kernel_rules_buf = NULL;
12866
12867 if (rp_files_cnt)
12868 {
12869 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12870
12871 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12872 }
12873
12874 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12875
12876 int rule_len = 0;
12877
12878 for (uint i = 0; i < rp_files_cnt; i++)
12879 {
12880 uint kernel_rules_avail = 0;
12881
12882 uint kernel_rules_cnt = 0;
12883
12884 kernel_rule_t *kernel_rules_buf = NULL;
12885
12886 char *rp_file = rp_files[i];
12887
12888 char in[BLOCK_SIZE] = { 0 };
12889 char out[BLOCK_SIZE] = { 0 };
12890
12891 FILE *fp = NULL;
12892
12893 uint rule_line = 0;
12894
12895 if ((fp = fopen (rp_file, "rb")) == NULL)
12896 {
12897 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12898
12899 return (-1);
12900 }
12901
12902 while (!feof (fp))
12903 {
12904 memset (rule_buf, 0, HCBUFSIZ);
12905
12906 rule_len = fgetl (fp, rule_buf);
12907
12908 rule_line++;
12909
12910 if (rule_len == 0) continue;
12911
12912 if (rule_buf[0] == '#') continue;
12913
12914 if (kernel_rules_avail == kernel_rules_cnt)
12915 {
12916 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12917
12918 kernel_rules_avail += INCR_RULES;
12919 }
12920
12921 memset (in, 0, BLOCK_SIZE);
12922 memset (out, 0, BLOCK_SIZE);
12923
12924 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12925
12926 if (result == -1)
12927 {
12928 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12929
12930 continue;
12931 }
12932
12933 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12934 {
12935 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12936
12937 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12938
12939 continue;
12940 }
12941
12942 /* its so slow
12943 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12944 {
12945 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12946
12947 continue;
12948 }
12949 */
12950
12951 kernel_rules_cnt++;
12952 }
12953
12954 fclose (fp);
12955
12956 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12957
12958 all_kernel_rules_buf[i] = kernel_rules_buf;
12959 }
12960
12961 /**
12962 * merge rules or automatic rule generator
12963 */
12964
12965 uint kernel_rules_cnt = 0;
12966
12967 kernel_rule_t *kernel_rules_buf = NULL;
12968
12969 if (attack_mode == ATTACK_MODE_STRAIGHT)
12970 {
12971 if (rp_files_cnt)
12972 {
12973 kernel_rules_cnt = 1;
12974
12975 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12976
12977 repeats[0] = kernel_rules_cnt;
12978
12979 for (uint i = 0; i < rp_files_cnt; i++)
12980 {
12981 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12982
12983 repeats[i + 1] = kernel_rules_cnt;
12984 }
12985
12986 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12987
12988 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12989
12990 for (uint i = 0; i < kernel_rules_cnt; i++)
12991 {
12992 uint out_pos = 0;
12993
12994 kernel_rule_t *out = &kernel_rules_buf[i];
12995
12996 for (uint j = 0; j < rp_files_cnt; j++)
12997 {
12998 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12999 uint in_pos;
13000
13001 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13002
13003 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13004 {
13005 if (out_pos == RULES_MAX - 1)
13006 {
13007 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13008
13009 break;
13010 }
13011
13012 out->cmds[out_pos] = in->cmds[in_pos];
13013 }
13014 }
13015 }
13016
13017 local_free (repeats);
13018 }
13019 else if (rp_gen)
13020 {
13021 uint kernel_rules_avail = 0;
13022
13023 while (kernel_rules_cnt < rp_gen)
13024 {
13025 if (kernel_rules_avail == kernel_rules_cnt)
13026 {
13027 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13028
13029 kernel_rules_avail += INCR_RULES;
13030 }
13031
13032 memset (rule_buf, 0, HCBUFSIZ);
13033
13034 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13035
13036 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13037
13038 kernel_rules_cnt++;
13039 }
13040 }
13041 }
13042
13043 myfree (rule_buf);
13044
13045 /**
13046 * generate NOP rules
13047 */
13048
13049 if (kernel_rules_cnt == 0)
13050 {
13051 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13052
13053 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13054
13055 kernel_rules_cnt++;
13056 }
13057
13058 data.kernel_rules_cnt = kernel_rules_cnt;
13059 data.kernel_rules_buf = kernel_rules_buf;
13060
13061 /**
13062 * OpenCL platforms: detect
13063 */
13064
13065 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13066 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13067
13068 cl_uint platforms_cnt = 0;
13069 cl_uint platform_devices_cnt = 0;
13070
13071 if (keyspace == 0)
13072 {
13073 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13074
13075 if (platforms_cnt == 0)
13076 {
13077 log_info ("");
13078 log_info ("ATTENTION! No OpenCL compatible platform found");
13079 log_info ("");
13080 log_info ("You're probably missing the OpenCL runtime installation");
13081 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13082 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13083 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13084 log_info ("");
13085
13086 return (-1);
13087 }
13088
13089 if (opencl_platforms_filter != (uint) -1)
13090 {
13091 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13092
13093 if (opencl_platforms_filter > platform_cnt_mask)
13094 {
13095 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13096
13097 return (-1);
13098 }
13099 }
13100 }
13101
13102 /**
13103 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13104 */
13105
13106 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13107 {
13108 cl_platform_id platform = platforms[platform_id];
13109
13110 char platform_vendor[INFOSZ] = { 0 };
13111
13112 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13113
13114 #ifdef HAVE_HWMON
13115 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13116 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13117 {
13118 // make sure that we do not directly control the fan for NVidia
13119
13120 gpu_temp_retain = 0;
13121
13122 data.gpu_temp_retain = gpu_temp_retain;
13123 }
13124 #endif // HAVE_NVML || HAVE_NVAPI
13125 #endif
13126 }
13127
13128 /**
13129 * OpenCL device types:
13130 * 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.
13131 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13132 */
13133
13134 if (opencl_device_types == NULL)
13135 {
13136 cl_device_type device_types_all = 0;
13137
13138 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13139 {
13140 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13141
13142 cl_platform_id platform = platforms[platform_id];
13143
13144 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13145
13146 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13147 {
13148 cl_device_id device = platform_devices[platform_devices_id];
13149
13150 cl_device_type device_type;
13151
13152 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13153
13154 device_types_all |= device_type;
13155 }
13156 }
13157
13158 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13159 {
13160 device_types_filter |= CL_DEVICE_TYPE_CPU;
13161 }
13162 }
13163
13164 /**
13165 * OpenCL devices: simply push all devices from all platforms into the same device array
13166 */
13167
13168 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13169
13170 data.devices_param = devices_param;
13171
13172 uint devices_cnt = 0;
13173
13174 uint devices_active = 0;
13175
13176 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13177 {
13178 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13179
13180 cl_platform_id platform = platforms[platform_id];
13181
13182 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13183
13184 char platform_vendor[INFOSZ] = { 0 };
13185
13186 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13187
13188 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13189 // this causes trouble with vendor id based macros
13190 // we'll assign generic to those without special optimization available
13191
13192 cl_uint vendor_id = 0;
13193
13194 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13195 {
13196 vendor_id = VENDOR_ID_AMD;
13197 }
13198 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13199 {
13200 vendor_id = VENDOR_ID_APPLE;
13201 }
13202 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13203 {
13204 vendor_id = VENDOR_ID_INTEL_BEIGNET;
13205 }
13206 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13207 {
13208 vendor_id = VENDOR_ID_INTEL_SDK;
13209 }
13210 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13211 {
13212 vendor_id = VENDOR_ID_MESA;
13213 }
13214 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13215 {
13216 vendor_id = VENDOR_ID_NV;
13217 }
13218 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13219 {
13220 vendor_id = VENDOR_ID_POCL;
13221 }
13222 else
13223 {
13224 vendor_id = VENDOR_ID_GENERIC;
13225 }
13226
13227 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13228 {
13229 size_t param_value_size = 0;
13230
13231 const uint device_id = devices_cnt;
13232
13233 hc_device_param_t *device_param = &data.devices_param[device_id];
13234
13235 device_param->vendor_id = vendor_id;
13236
13237 device_param->device = platform_devices[platform_devices_id];
13238
13239 device_param->device_id = device_id;
13240
13241 device_param->platform_devices_id = platform_devices_id;
13242
13243 // device_type
13244
13245 cl_device_type device_type;
13246
13247 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13248
13249 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13250
13251 device_param->device_type = device_type;
13252
13253 // device_name
13254
13255 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13256
13257 char *device_name = (char *) mymalloc (param_value_size);
13258
13259 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13260
13261 device_param->device_name = device_name;
13262
13263 // tuning db
13264
13265 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13266
13267 // device_version
13268
13269 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13270
13271 char *device_version = (char *) mymalloc (param_value_size);
13272
13273 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13274
13275 device_param->device_version = device_version;
13276
13277 // device_opencl_version
13278
13279 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13280
13281 char *device_opencl_version = (char *) mymalloc (param_value_size);
13282
13283 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13284
13285 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13286
13287 myfree (device_opencl_version);
13288
13289 // vector_width
13290
13291 cl_uint vector_width;
13292
13293 if (opencl_vector_width_chgd == 0)
13294 {
13295 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13296 {
13297 if (opti_type & OPTI_TYPE_USES_BITS_64)
13298 {
13299 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13300 }
13301 else
13302 {
13303 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13304 }
13305 }
13306 else
13307 {
13308 vector_width = (cl_uint) tuningdb_entry->vector_width;
13309 }
13310 }
13311 else
13312 {
13313 vector_width = opencl_vector_width;
13314 }
13315
13316 if (vector_width > 16) vector_width = 16;
13317
13318 device_param->vector_width = vector_width;
13319
13320 // max_compute_units
13321
13322 cl_uint device_processors;
13323
13324 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13325
13326 device_param->device_processors = device_processors;
13327
13328 // device_maxmem_alloc
13329 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13330
13331 cl_ulong device_maxmem_alloc;
13332
13333 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13334
13335 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13336
13337 // device_global_mem
13338
13339 cl_ulong device_global_mem;
13340
13341 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13342
13343 device_param->device_global_mem = device_global_mem;
13344
13345 // max_work_group_size
13346
13347 size_t device_maxworkgroup_size;
13348
13349 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13350
13351 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13352
13353 // max_clock_frequency
13354
13355 cl_uint device_maxclock_frequency;
13356
13357 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13358
13359 device_param->device_maxclock_frequency = device_maxclock_frequency;
13360
13361 // device_endian_little
13362
13363 cl_bool device_endian_little;
13364
13365 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13366
13367 if (device_endian_little == CL_FALSE)
13368 {
13369 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13370
13371 device_param->skipped = 1;
13372 }
13373
13374 // device_available
13375
13376 cl_bool device_available;
13377
13378 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13379
13380 if (device_available == CL_FALSE)
13381 {
13382 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13383
13384 device_param->skipped = 1;
13385 }
13386
13387 // device_compiler_available
13388
13389 cl_bool device_compiler_available;
13390
13391 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13392
13393 if (device_compiler_available == CL_FALSE)
13394 {
13395 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13396
13397 device_param->skipped = 1;
13398 }
13399
13400 // device_execution_capabilities
13401
13402 cl_device_exec_capabilities device_execution_capabilities;
13403
13404 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13405
13406 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13407 {
13408 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13409
13410 device_param->skipped = 1;
13411 }
13412
13413 // device_extensions
13414
13415 size_t device_extensions_size;
13416
13417 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13418
13419 char *device_extensions = mymalloc (device_extensions_size + 1);
13420
13421 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13422
13423 if (strstr (device_extensions, "base_atomics") == 0)
13424 {
13425 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13426
13427 device_param->skipped = 1;
13428 }
13429
13430 if (strstr (device_extensions, "byte_addressable_store") == 0)
13431 {
13432 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13433
13434 device_param->skipped = 1;
13435 }
13436
13437 myfree (device_extensions);
13438
13439 // device_local_mem_size
13440
13441 cl_ulong device_local_mem_size;
13442
13443 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13444
13445 if (device_local_mem_size < 32768)
13446 {
13447 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13448
13449 device_param->skipped = 1;
13450 }
13451
13452
13453 // skipped
13454
13455 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13456 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13457
13458 // driver_version
13459
13460 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13461
13462 char *driver_version = (char *) mymalloc (param_value_size);
13463
13464 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13465
13466 device_param->driver_version = driver_version;
13467
13468 // device_name_chksum
13469
13470 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13471
13472 #if __x86_64__
13473 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13474 #else
13475 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13476 #endif
13477
13478 uint device_name_digest[4] = { 0 };
13479
13480 md5_64 ((uint *) device_name_chksum, device_name_digest);
13481
13482 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13483
13484 device_param->device_name_chksum = device_name_chksum;
13485
13486 // device_processor_cores
13487
13488 if (device_type & CL_DEVICE_TYPE_CPU)
13489 {
13490 cl_uint device_processor_cores = 1;
13491
13492 device_param->device_processor_cores = device_processor_cores;
13493 }
13494
13495 if (device_type & CL_DEVICE_TYPE_GPU)
13496 {
13497 if (vendor_id == VENDOR_ID_AMD)
13498 {
13499 cl_uint device_processor_cores = 0;
13500
13501 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13502
13503 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13504
13505 device_param->device_processor_cores = device_processor_cores;
13506 }
13507 else if (vendor_id == VENDOR_ID_NV)
13508 {
13509 cl_uint kernel_exec_timeout = 0;
13510
13511 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13512
13513 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13514
13515 device_param->kernel_exec_timeout = kernel_exec_timeout;
13516
13517 cl_uint device_processor_cores = 0;
13518
13519 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13520
13521 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13522
13523 device_param->device_processor_cores = device_processor_cores;
13524
13525 cl_uint sm_minor = 0;
13526 cl_uint sm_major = 0;
13527
13528 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13529 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13530
13531 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13532 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13533
13534 device_param->sm_minor = sm_minor;
13535 device_param->sm_major = sm_major;
13536 }
13537 else
13538 {
13539 cl_uint device_processor_cores = 1;
13540
13541 device_param->device_processor_cores = device_processor_cores;
13542 }
13543 }
13544
13545 // display results
13546
13547 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13548 {
13549 if (status_automate == 0)
13550 {
13551 if (device_param->skipped == 0)
13552 {
13553 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13554 device_id + 1,
13555 device_name,
13556 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13557 (unsigned int) (device_global_mem / 1024 / 1024),
13558 (unsigned int) (device_maxclock_frequency),
13559 (unsigned int) device_processors);
13560 }
13561 else
13562 {
13563 log_info ("Device #%u: %s, skipped",
13564 device_id + 1,
13565 device_name);
13566 }
13567 }
13568 }
13569
13570 // common driver check
13571
13572 if (device_param->skipped == 0)
13573 {
13574 if (device_type & CL_DEVICE_TYPE_GPU)
13575 {
13576 if (vendor_id == VENDOR_ID_AMD)
13577 {
13578 int catalyst_check = (force == 1) ? 0 : 1;
13579
13580 int catalyst_warn = 0;
13581
13582 int catalyst_broken = 0;
13583
13584 if (catalyst_check == 1)
13585 {
13586 catalyst_warn = 1;
13587
13588 // v14.9 and higher
13589 if (atoi (device_param->driver_version) >= 1573)
13590 {
13591 catalyst_warn = 0;
13592 }
13593
13594 catalyst_check = 0;
13595 }
13596
13597 if (catalyst_broken == 1)
13598 {
13599 log_info ("");
13600 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13601 log_info ("It will pass over cracked hashes and does not report them as cracked");
13602 log_info ("You are STRONGLY encouraged not to use it");
13603 log_info ("You can use --force to override this but do not post error reports if you do so");
13604 log_info ("");
13605
13606 return (-1);
13607 }
13608
13609 if (catalyst_warn == 1)
13610 {
13611 log_info ("");
13612 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13613 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13614 log_info ("See hashcat's homepage for official supported catalyst drivers");
13615 #ifdef _WIN
13616 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13617 #endif
13618 log_info ("You can use --force to override this but do not post error reports if you do so");
13619 log_info ("");
13620
13621 return (-1);
13622 }
13623 }
13624 else if (vendor_id == VENDOR_ID_NV)
13625 {
13626 if (device_param->kernel_exec_timeout != 0)
13627 {
13628 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);
13629 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13630 }
13631 }
13632 }
13633
13634 if (device_type & CL_DEVICE_TYPE_CPU)
13635 {
13636 if (vendor_id == VENDOR_ID_AMD)
13637 {
13638 if (force == 0)
13639 {
13640 log_info ("");
13641 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13642 log_info ("You are STRONGLY encouraged not to use it");
13643 log_info ("You can use --force to override this but do not post error reports if you do so");
13644 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13645 log_info ("");
13646
13647 return (-1);
13648 }
13649 }
13650 }
13651
13652 /**
13653 * kernel accel and loops tuning db adjustment
13654 */
13655
13656 device_param->kernel_accel_min = 1;
13657 device_param->kernel_accel_max = 1024;
13658
13659 device_param->kernel_loops_min = 1;
13660 device_param->kernel_loops_max = 1024;
13661
13662 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13663
13664 if (tuningdb_entry)
13665 {
13666 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13667 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13668
13669 if (_kernel_accel)
13670 {
13671 device_param->kernel_accel_min = _kernel_accel;
13672 device_param->kernel_accel_max = _kernel_accel;
13673 }
13674
13675 if (_kernel_loops)
13676 {
13677 if (workload_profile == 1)
13678 {
13679 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13680 }
13681 else if (workload_profile == 2)
13682 {
13683 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13684 }
13685
13686 device_param->kernel_loops_min = _kernel_loops;
13687 device_param->kernel_loops_max = _kernel_loops;
13688 }
13689 }
13690
13691 // commandline parameters overwrite tuningdb entries
13692
13693 if (kernel_accel)
13694 {
13695 device_param->kernel_accel_min = kernel_accel;
13696 device_param->kernel_accel_max = kernel_accel;
13697 }
13698
13699 if (kernel_loops)
13700 {
13701 device_param->kernel_loops_min = kernel_loops;
13702 device_param->kernel_loops_max = kernel_loops;
13703 }
13704
13705 /**
13706 * activate device
13707 */
13708
13709 devices_active++;
13710 }
13711
13712 // next please
13713
13714 devices_cnt++;
13715 }
13716 }
13717
13718 if (keyspace == 0 && devices_active == 0)
13719 {
13720 log_error ("ERROR: No devices found/left");
13721
13722 return (-1);
13723 }
13724
13725 // 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)
13726
13727 if (devices_filter != (uint) -1)
13728 {
13729 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13730
13731 if (devices_filter > devices_cnt_mask)
13732 {
13733 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13734
13735 return (-1);
13736 }
13737 }
13738
13739 data.devices_cnt = devices_cnt;
13740
13741 data.devices_active = devices_active;
13742
13743 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13744 {
13745 if (status_automate == 0)
13746 {
13747 log_info ("");
13748 }
13749 }
13750
13751 /**
13752 * HM devices: init
13753 */
13754
13755 #ifdef HAVE_HWMON
13756 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13757 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13758 #endif
13759
13760 #ifdef HAVE_ADL
13761 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13762 #endif
13763
13764 if (gpu_temp_disable == 0)
13765 {
13766 #if defined(WIN) && defined(HAVE_NVAPI)
13767 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13768
13769 if (nvapi_init (nvapi) == 0)
13770 data.hm_nv = nvapi;
13771
13772 if (data.hm_nv)
13773 {
13774 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13775 {
13776 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13777
13778 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13779
13780 int tmp_out = 0;
13781
13782 for (int i = 0; i < tmp_in; i++)
13783 {
13784 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13785 }
13786
13787 for (int i = 0; i < tmp_out; i++)
13788 {
13789 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13790
13791 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13792
13793 if (hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, hm_adapters_nv[i].adapter_index.nv, 0, &pCoolerSettings) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13794 }
13795 }
13796 }
13797 #endif // WIN && HAVE_NVAPI
13798
13799 #if defined(LINUX) && defined(HAVE_NVML)
13800 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13801
13802 if (nvml_init (nvml) == 0)
13803 data.hm_nv = nvml;
13804
13805 if (data.hm_nv)
13806 {
13807 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13808 {
13809 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13810
13811 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13812
13813 int tmp_out = 0;
13814
13815 for (int i = 0; i < tmp_in; i++)
13816 {
13817 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13818 }
13819
13820 for (int i = 0; i < tmp_out; i++)
13821 {
13822 unsigned int speed;
13823
13824 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13825 }
13826 }
13827 }
13828 #endif // LINUX && HAVE_NVML
13829
13830 data.hm_amd = NULL;
13831
13832 #ifdef HAVE_ADL
13833 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13834
13835 if (adl_init (adl) == 0)
13836 data.hm_amd = adl;
13837
13838 if (data.hm_amd)
13839 {
13840 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13841 {
13842 // total number of adapters
13843
13844 int hm_adapters_num;
13845
13846 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13847
13848 // adapter info
13849
13850 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13851
13852 if (lpAdapterInfo == NULL) return (-1);
13853
13854 // get a list (of ids of) valid/usable adapters
13855
13856 int num_adl_adapters = 0;
13857
13858 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13859
13860 if (num_adl_adapters > 0)
13861 {
13862 hc_thread_mutex_lock (mux_adl);
13863
13864 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13865
13866 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13867
13868 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13869 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13870
13871 hc_thread_mutex_unlock (mux_adl);
13872 }
13873
13874 myfree (valid_adl_device_list);
13875 myfree (lpAdapterInfo);
13876 }
13877 }
13878 #endif // HAVE_ADL
13879
13880 if (data.hm_amd == NULL && data.hm_nv == NULL)
13881 {
13882 gpu_temp_disable = 1;
13883 }
13884 }
13885
13886 /**
13887 * OpenCL devices: allocate buffer for device specific information
13888 */
13889
13890 #ifdef HAVE_HWMON
13891 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13892
13893 #ifdef HAVE_ADL
13894 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13895
13896 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13897 #endif // ADL
13898 #endif
13899
13900 /**
13901 * enable custom signal handler(s)
13902 */
13903
13904 if (benchmark == 0)
13905 {
13906 hc_signal (sigHandler_default);
13907 }
13908 else
13909 {
13910 hc_signal (sigHandler_benchmark);
13911 }
13912
13913 /**
13914 * User-defined GPU temp handling
13915 */
13916
13917 #ifdef HAVE_HWMON
13918 if (gpu_temp_disable == 1)
13919 {
13920 gpu_temp_abort = 0;
13921 gpu_temp_retain = 0;
13922 }
13923
13924 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13925 {
13926 if (gpu_temp_abort < gpu_temp_retain)
13927 {
13928 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13929
13930 return (-1);
13931 }
13932 }
13933
13934 data.gpu_temp_disable = gpu_temp_disable;
13935 data.gpu_temp_abort = gpu_temp_abort;
13936 data.gpu_temp_retain = gpu_temp_retain;
13937 #endif
13938
13939 /**
13940 * inform the user
13941 */
13942
13943 if (data.quiet == 0)
13944 {
13945 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13946
13947 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);
13948
13949 if (attack_mode == ATTACK_MODE_STRAIGHT)
13950 {
13951 log_info ("Rules: %u", kernel_rules_cnt);
13952 }
13953
13954 if (opti_type)
13955 {
13956 log_info ("Applicable Optimizers:");
13957
13958 for (uint i = 0; i < 32; i++)
13959 {
13960 const uint opti_bit = 1u << i;
13961
13962 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13963 }
13964 }
13965
13966 /**
13967 * Watchdog and Temperature balance
13968 */
13969
13970 #ifdef HAVE_HWMON
13971 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13972 {
13973 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13974 }
13975
13976 if (gpu_temp_abort == 0)
13977 {
13978 log_info ("Watchdog: Temperature abort trigger disabled");
13979 }
13980 else
13981 {
13982 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13983 }
13984
13985 if (gpu_temp_retain == 0)
13986 {
13987 log_info ("Watchdog: Temperature retain trigger disabled");
13988 }
13989 else
13990 {
13991 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13992 }
13993
13994 if (data.quiet == 0) log_info ("");
13995 #endif
13996 }
13997
13998 /**
13999 * HM devices: copy
14000 */
14001
14002 if (gpu_temp_disable == 0)
14003 {
14004 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14005 {
14006 hc_device_param_t *device_param = &data.devices_param[device_id];
14007
14008 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14009
14010 if (device_param->skipped) continue;
14011
14012 const uint platform_devices_id = device_param->platform_devices_id;
14013
14014 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14015 if (device_param->vendor_id == VENDOR_ID_NV)
14016 {
14017 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14018 }
14019 #endif
14020
14021 #ifdef HAVE_ADL
14022 if (device_param->vendor_id == VENDOR_ID_AMD)
14023 {
14024 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14025 }
14026 #endif
14027 }
14028 }
14029
14030 /*
14031 * Temporary fix:
14032 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14033 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14034 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14035 * Driver / ADL bug?
14036 */
14037
14038 #ifdef HAVE_ADL
14039 if (powertune_enable == 1)
14040 {
14041 hc_thread_mutex_lock (mux_adl);
14042
14043 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14044 {
14045 hc_device_param_t *device_param = &data.devices_param[device_id];
14046
14047 if (device_param->skipped) continue;
14048
14049 if (data.hm_device[device_id].od_version == 6)
14050 {
14051 // set powertune value only
14052
14053 int powertune_supported = 0;
14054
14055 int ADL_rc = 0;
14056
14057 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14058 {
14059 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14060
14061 return (-1);
14062 }
14063
14064 if (powertune_supported != 0)
14065 {
14066 // powertune set
14067 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14068
14069 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14070 {
14071 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14072
14073 return (-1);
14074 }
14075
14076 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14077 {
14078 log_error ("ERROR: Failed to set new ADL PowerControl values");
14079
14080 return (-1);
14081 }
14082 }
14083 }
14084 }
14085
14086 hc_thread_mutex_unlock (mux_adl);
14087 }
14088 #endif // HAVE_ADK
14089 #endif // HAVE_HWMON
14090
14091 #ifdef DEBUG
14092 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14093 #endif
14094
14095 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14096
14097 uint kernel_power_all = 0;
14098
14099 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14100 {
14101 /**
14102 * host buffer
14103 */
14104
14105 hc_device_param_t *device_param = &data.devices_param[device_id];
14106
14107 if (device_param->skipped) continue;
14108
14109 /**
14110 * device properties
14111 */
14112
14113 const char *device_name_chksum = device_param->device_name_chksum;
14114 const u32 device_processors = device_param->device_processors;
14115 const u32 device_processor_cores = device_param->device_processor_cores;
14116
14117 /**
14118 * create context for each device
14119 */
14120
14121 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14122
14123 /**
14124 * create command-queue
14125 */
14126
14127 // not supported with NV
14128 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14129
14130 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14131
14132 /**
14133 * kernel threads: some algorithms need a fixed kernel-threads count
14134 * because of shared memory usage or bitslice
14135 * there needs to be some upper limit, otherwise there's too much overhead
14136 */
14137
14138 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14139
14140 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14141 {
14142 kernel_threads = KERNEL_THREADS_MAX_CPU;
14143 }
14144
14145 if (hash_mode == 1500) kernel_threads = 64; // DES
14146 if (hash_mode == 3000) kernel_threads = 64; // DES
14147 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14148 if (hash_mode == 7500) kernel_threads = 64; // RC4
14149 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14150 if (hash_mode == 9700) kernel_threads = 64; // RC4
14151 if (hash_mode == 9710) kernel_threads = 64; // RC4
14152 if (hash_mode == 9800) kernel_threads = 64; // RC4
14153 if (hash_mode == 9810) kernel_threads = 64; // RC4
14154 if (hash_mode == 10400) kernel_threads = 64; // RC4
14155 if (hash_mode == 10410) kernel_threads = 64; // RC4
14156 if (hash_mode == 10500) kernel_threads = 64; // RC4
14157 if (hash_mode == 13100) kernel_threads = 64; // RC4
14158
14159 /**
14160 * create input buffers on device : calculate size of fixed memory buffers
14161 */
14162
14163 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14164 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14165
14166 device_param->size_root_css = size_root_css;
14167 device_param->size_markov_css = size_markov_css;
14168
14169 size_t size_results = sizeof (uint);
14170
14171 device_param->size_results = size_results;
14172
14173 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14174 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14175
14176 size_t size_plains = digests_cnt * sizeof (plain_t);
14177 size_t size_salts = salts_cnt * sizeof (salt_t);
14178 size_t size_esalts = salts_cnt * esalt_size;
14179
14180 device_param->size_plains = size_plains;
14181 device_param->size_digests = size_digests;
14182 device_param->size_shown = size_shown;
14183 device_param->size_salts = size_salts;
14184
14185 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14186 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14187 size_t size_tm = 32 * sizeof (bs_word_t);
14188
14189 // scryptV stuff
14190
14191 size_t size_scryptV = 1;
14192
14193 if ((hash_mode == 8900) || (hash_mode == 9300))
14194 {
14195 uint tmto_start = 0;
14196 uint tmto_stop = 10;
14197
14198 if (scrypt_tmto)
14199 {
14200 tmto_start = scrypt_tmto;
14201 }
14202 else
14203 {
14204 // in case the user did not specify the tmto manually
14205 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14206 // but set the lower end only in case the user has a device with too less memory
14207
14208 if (hash_mode == 8900)
14209 {
14210 if (device_param->vendor_id == VENDOR_ID_AMD)
14211 {
14212 tmto_start = 1;
14213 }
14214 else if (device_param->vendor_id == VENDOR_ID_NV)
14215 {
14216 tmto_start = 2;
14217 }
14218 }
14219 else if (hash_mode == 9300)
14220 {
14221 if (device_param->vendor_id == VENDOR_ID_AMD)
14222 {
14223 tmto_start = 2;
14224 }
14225 else if (device_param->vendor_id == VENDOR_ID_NV)
14226 {
14227 tmto_start = 2;
14228 }
14229 }
14230 }
14231
14232 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14233 {
14234 // TODO: in theory the following calculation needs to be done per salt, not global
14235 // we assume all hashes have the same scrypt settings
14236
14237 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14238
14239 size_scryptV /= 1 << tmto;
14240
14241 size_scryptV *= device_processors * device_processor_cores;
14242
14243 if (size_scryptV > device_param->device_maxmem_alloc)
14244 {
14245 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14246
14247 continue;
14248 }
14249
14250 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14251 {
14252 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14253 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14254 }
14255
14256 break;
14257 }
14258
14259 if (data.salts_buf[0].scrypt_phy == 0)
14260 {
14261 log_error ("ERROR: can't allocate enough device memory");
14262
14263 return -1;
14264 }
14265
14266 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14267 }
14268
14269 /**
14270 * some algorithms need a fixed kernel-loops count
14271 */
14272
14273 if (hash_mode == 1500)
14274 {
14275 const u32 kernel_loops_fixed = 1024;
14276
14277 device_param->kernel_loops_min = kernel_loops_fixed;
14278 device_param->kernel_loops_max = kernel_loops_fixed;
14279 }
14280
14281 if (hash_mode == 3000)
14282 {
14283 const u32 kernel_loops_fixed = 1024;
14284
14285 device_param->kernel_loops_min = kernel_loops_fixed;
14286 device_param->kernel_loops_max = kernel_loops_fixed;
14287 }
14288
14289 if (hash_mode == 8900)
14290 {
14291 const u32 kernel_loops_fixed = 1;
14292
14293 device_param->kernel_loops_min = kernel_loops_fixed;
14294 device_param->kernel_loops_max = kernel_loops_fixed;
14295 }
14296
14297 if (hash_mode == 9300)
14298 {
14299 const u32 kernel_loops_fixed = 1;
14300
14301 device_param->kernel_loops_min = kernel_loops_fixed;
14302 device_param->kernel_loops_max = kernel_loops_fixed;
14303 }
14304
14305 if (hash_mode == 12500)
14306 {
14307 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14308
14309 device_param->kernel_loops_min = kernel_loops_fixed;
14310 device_param->kernel_loops_max = kernel_loops_fixed;
14311 }
14312
14313 /**
14314 * some algorithms have a maximum kernel-loops count
14315 */
14316
14317 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14318 {
14319 u32 innerloop_cnt = 0;
14320
14321 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14322 {
14323 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14324 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14325 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14326 }
14327 else
14328 {
14329 innerloop_cnt = data.salts_buf[0].salt_iter;
14330 }
14331
14332 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14333 (innerloop_cnt <= device_param->kernel_loops_max))
14334 {
14335 device_param->kernel_loops_max = innerloop_cnt;
14336 }
14337 }
14338
14339 u32 kernel_accel_min = device_param->kernel_accel_min;
14340 u32 kernel_accel_max = device_param->kernel_accel_max;
14341
14342 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14343
14344 size_t size_pws = 4;
14345 size_t size_tmps = 4;
14346 size_t size_hooks = 4;
14347
14348 while (kernel_accel_max >= kernel_accel_min)
14349 {
14350 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14351
14352 // size_pws
14353
14354 size_pws = kernel_power_max * sizeof (pw_t);
14355
14356 // size_tmps
14357
14358 switch (hash_mode)
14359 {
14360 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14361 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14362 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14363 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14364 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14365 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14366 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14367 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14368 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14369 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14370 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14371 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14372 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14373 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14374 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14375 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14376 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14377 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14378 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14379 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14380 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14381 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14382 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14383 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14384 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14385 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14386 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14387 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14388 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14389 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14390 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14391 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14392 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14393 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14394 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14395 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14396 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14397 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14398 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14399 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14400 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14401 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14402 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14403 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14404 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14405 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14406 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14407 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14408 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14409 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14410 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14411 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14412 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14413 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14414 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14415 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14416 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14417 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14418 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14419 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14420 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14421 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14422 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14423 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14424 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14425 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14426 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14427 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14428 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14429 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14430 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14431 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14432 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14433 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14434 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14435 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14436 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14437 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14438 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14439 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14440 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14441 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14442 };
14443
14444 // size_hooks
14445
14446 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14447 {
14448 // none yet
14449 }
14450
14451 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14452 // if not, decrease amplifier and try again
14453
14454 int skip = 0;
14455
14456 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
14457 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
14458 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
14459
14460 if (( bitmap_size
14461 + bitmap_size
14462 + bitmap_size
14463 + bitmap_size
14464 + bitmap_size
14465 + bitmap_size
14466 + bitmap_size
14467 + bitmap_size
14468 + size_bfs
14469 + size_combs
14470 + size_digests
14471 + size_esalts
14472 + size_hooks
14473 + size_markov_css
14474 + size_plains
14475 + size_pws
14476 + size_pws // not a bug
14477 + size_results
14478 + size_root_css
14479 + size_rules
14480 + size_rules_c
14481 + size_salts
14482 + size_scryptV
14483 + size_shown
14484 + size_tm
14485 + size_tmps) > device_param->device_global_mem) skip = 1;
14486
14487 if (skip == 1)
14488 {
14489 kernel_accel_max--;
14490
14491 continue;
14492 }
14493
14494 break;
14495 }
14496
14497 /*
14498 if (kernel_accel_max == 0)
14499 {
14500 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14501
14502 return -1;
14503 }
14504 */
14505
14506 device_param->kernel_accel_min = kernel_accel_min;
14507 device_param->kernel_accel_max = kernel_accel_max;
14508
14509 /*
14510 if (kernel_accel_max < kernel_accel)
14511 {
14512 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14513
14514 device_param->kernel_accel = kernel_accel_max;
14515 }
14516 */
14517
14518 device_param->size_bfs = size_bfs;
14519 device_param->size_combs = size_combs;
14520 device_param->size_rules = size_rules;
14521 device_param->size_rules_c = size_rules_c;
14522 device_param->size_pws = size_pws;
14523 device_param->size_tmps = size_tmps;
14524 device_param->size_hooks = size_hooks;
14525
14526 // do not confuse kernel_accel_max with kernel_accel here
14527
14528 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14529
14530 device_param->kernel_threads = kernel_threads;
14531 device_param->kernel_power_user = kernel_power;
14532
14533 kernel_power_all += kernel_power;
14534
14535 /**
14536 * default building options
14537 */
14538
14539 char build_opts[1024] = { 0 };
14540
14541 // we don't have sm_* on vendors not NV but it doesn't matter
14542
14543 snprintf (build_opts, sizeof (build_opts) - 1, "-cl-std=CL1.1 -I\"%s/\" -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
14544
14545 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14546 {
14547 // we do vectorizing much better than the auto-vectorizer
14548
14549 char build_opts_new[1024] = { 0 };
14550
14551 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14552
14553 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14554 }
14555
14556 #ifdef DEBUG
14557 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14558 #endif
14559
14560 /**
14561 * main kernel
14562 */
14563
14564 {
14565 /**
14566 * kernel source filename
14567 */
14568
14569 char source_file[256] = { 0 };
14570
14571 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14572
14573 struct stat sst;
14574
14575 if (stat (source_file, &sst) == -1)
14576 {
14577 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14578
14579 return -1;
14580 }
14581
14582 /**
14583 * kernel cached filename
14584 */
14585
14586 char cached_file[256] = { 0 };
14587
14588 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14589
14590 int cached = 1;
14591
14592 struct stat cst;
14593
14594 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14595 {
14596 cached = 0;
14597 }
14598
14599 /**
14600 * kernel compile or load
14601 */
14602
14603 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14604
14605 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14606
14607 if (force_jit_compilation == -1)
14608 {
14609 if (cached == 0)
14610 {
14611 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14612
14613 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14614
14615 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14616
14617 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14618
14619 #ifdef DEBUG
14620 size_t build_log_size = 0;
14621
14622 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14623
14624 if (build_log_size > 1)
14625 {
14626 char *build_log = (char *) malloc (build_log_size + 1);
14627
14628 memset (build_log, 0, build_log_size + 1);
14629
14630 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14631
14632 puts (build_log);
14633
14634 free (build_log);
14635 }
14636 #endif
14637
14638 if (rc != 0)
14639 {
14640 device_param->skipped = true;
14641
14642 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14643
14644 continue;
14645 }
14646
14647 size_t binary_size;
14648
14649 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14650
14651 u8 *binary = (u8 *) mymalloc (binary_size);
14652
14653 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14654
14655 writeProgramBin (cached_file, binary, binary_size);
14656
14657 local_free (binary);
14658 }
14659 else
14660 {
14661 #ifdef DEBUG
14662 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14663 #endif
14664
14665 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14666
14667 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14668
14669 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14670 }
14671 }
14672 else
14673 {
14674 #ifdef DEBUG
14675 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14676 #endif
14677
14678 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14679
14680 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14681
14682 char build_opts_update[1024] = { 0 };
14683
14684 if (force_jit_compilation == 1500)
14685 {
14686 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14687 }
14688 else if (force_jit_compilation == 8900)
14689 {
14690 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%d -DSCRYPT_R=%d -DSCRYPT_P=%d -DSCRYPT_TMTO=%d", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.salts_buf[0].scrypt_tmto);
14691 }
14692 else
14693 {
14694 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14695 }
14696
14697 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14698
14699 #ifdef DEBUG
14700 size_t build_log_size = 0;
14701
14702 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14703
14704 if (build_log_size > 1)
14705 {
14706 char *build_log = (char *) malloc (build_log_size + 1);
14707
14708 memset (build_log, 0, build_log_size + 1);
14709
14710 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14711
14712 puts (build_log);
14713
14714 free (build_log);
14715 }
14716 #endif
14717
14718 if (rc != 0)
14719 {
14720 device_param->skipped = true;
14721
14722 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14723 }
14724 }
14725
14726 local_free (kernel_lengths);
14727 local_free (kernel_sources[0]);
14728 local_free (kernel_sources);
14729 }
14730
14731 /**
14732 * word generator kernel
14733 */
14734
14735 if (attack_mode != ATTACK_MODE_STRAIGHT)
14736 {
14737 /**
14738 * kernel mp source filename
14739 */
14740
14741 char source_file[256] = { 0 };
14742
14743 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14744
14745 struct stat sst;
14746
14747 if (stat (source_file, &sst) == -1)
14748 {
14749 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14750
14751 return -1;
14752 }
14753
14754 /**
14755 * kernel mp cached filename
14756 */
14757
14758 char cached_file[256] = { 0 };
14759
14760 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14761
14762 int cached = 1;
14763
14764 struct stat cst;
14765
14766 if (stat (cached_file, &cst) == -1)
14767 {
14768 cached = 0;
14769 }
14770
14771 /**
14772 * kernel compile or load
14773 */
14774
14775 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14776
14777 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14778
14779 if (cached == 0)
14780 {
14781 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14782 if (quiet == 0) log_info ("");
14783
14784 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14785
14786 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14787
14788 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14789
14790 if (rc != 0)
14791 {
14792 device_param->skipped = true;
14793
14794 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14795
14796 continue;
14797 }
14798
14799 size_t binary_size;
14800
14801 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14802
14803 u8 *binary = (u8 *) mymalloc (binary_size);
14804
14805 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14806
14807 writeProgramBin (cached_file, binary, binary_size);
14808
14809 local_free (binary);
14810 }
14811 else
14812 {
14813 #ifdef DEBUG
14814 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14815 #endif
14816
14817 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14818
14819 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14820
14821 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14822 }
14823
14824 local_free (kernel_lengths);
14825 local_free (kernel_sources[0]);
14826 local_free (kernel_sources);
14827 }
14828
14829 /**
14830 * amplifier kernel
14831 */
14832
14833 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14834 {
14835
14836 }
14837 else
14838 {
14839 /**
14840 * kernel amp source filename
14841 */
14842
14843 char source_file[256] = { 0 };
14844
14845 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14846
14847 struct stat sst;
14848
14849 if (stat (source_file, &sst) == -1)
14850 {
14851 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14852
14853 return -1;
14854 }
14855
14856 /**
14857 * kernel amp cached filename
14858 */
14859
14860 char cached_file[256] = { 0 };
14861
14862 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14863
14864 int cached = 1;
14865
14866 struct stat cst;
14867
14868 if (stat (cached_file, &cst) == -1)
14869 {
14870 cached = 0;
14871 }
14872
14873 /**
14874 * kernel compile or load
14875 */
14876
14877 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14878
14879 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14880
14881 if (cached == 0)
14882 {
14883 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14884 if (quiet == 0) log_info ("");
14885
14886 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14887
14888 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14889
14890 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14891
14892 if (rc != 0)
14893 {
14894 device_param->skipped = true;
14895
14896 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14897
14898 continue;
14899 }
14900
14901 size_t binary_size;
14902
14903 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14904
14905 u8 *binary = (u8 *) mymalloc (binary_size);
14906
14907 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14908
14909 writeProgramBin (cached_file, binary, binary_size);
14910
14911 local_free (binary);
14912 }
14913 else
14914 {
14915 #ifdef DEBUG
14916 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14917 #endif
14918
14919 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14920
14921 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14922
14923 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14924 }
14925
14926 local_free (kernel_lengths);
14927 local_free (kernel_sources[0]);
14928 local_free (kernel_sources);
14929 }
14930
14931 // some algorithm collide too fast, make that impossible
14932
14933 if (benchmark == 1)
14934 {
14935 ((uint *) digests_buf)[0] = -1;
14936 ((uint *) digests_buf)[1] = -1;
14937 ((uint *) digests_buf)[2] = -1;
14938 ((uint *) digests_buf)[3] = -1;
14939 }
14940
14941 /**
14942 * global buffers
14943 */
14944
14945 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14946 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14947 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14948 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14949 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14950 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14951 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14952 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14953 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14954 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14955 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14956 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14957 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14958 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14959 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14960 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14961 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14962 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14963
14964 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);
14965 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);
14966 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);
14967 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);
14968 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);
14969 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);
14970 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);
14971 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);
14972 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14973 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14974 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14975
14976 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14977 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14978 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14979 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14980 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14981 run_kernel_bzero (device_param, device_param->d_result, size_results);
14982
14983 /**
14984 * special buffers
14985 */
14986
14987 if (attack_kern == ATTACK_KERN_STRAIGHT)
14988 {
14989 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14990 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14991
14992 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14993
14994 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14995 }
14996 else if (attack_kern == ATTACK_KERN_COMBI)
14997 {
14998 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14999 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15000 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15001 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15002
15003 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15004 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15005 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15006 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15007 }
15008 else if (attack_kern == ATTACK_KERN_BF)
15009 {
15010 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15011 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15012 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15013 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15014 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15015
15016 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15017 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15018 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15019 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15020 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15021 }
15022
15023 if (size_esalts)
15024 {
15025 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15026
15027 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15028 }
15029
15030 /**
15031 * main host data
15032 */
15033
15034 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15035
15036 device_param->pws_buf = pws_buf;
15037
15038 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15039
15040 device_param->combs_buf = combs_buf;
15041
15042 void *hooks_buf = mymalloc (size_hooks);
15043
15044 device_param->hooks_buf = hooks_buf;
15045
15046 /**
15047 * kernel args
15048 */
15049
15050 device_param->kernel_params_buf32[21] = bitmap_mask;
15051 device_param->kernel_params_buf32[22] = bitmap_shift1;
15052 device_param->kernel_params_buf32[23] = bitmap_shift2;
15053 device_param->kernel_params_buf32[24] = 0; // salt_pos
15054 device_param->kernel_params_buf32[25] = 0; // loop_pos
15055 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15056 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15057 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15058 device_param->kernel_params_buf32[29] = 0; // digests_offset
15059 device_param->kernel_params_buf32[30] = 0; // combs_mode
15060 device_param->kernel_params_buf32[31] = 0; // gid_max
15061
15062 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15063 ? &device_param->d_pws_buf
15064 : &device_param->d_pws_amp_buf;
15065 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15066 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15067 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15068 device_param->kernel_params[ 4] = &device_param->d_tmps;
15069 device_param->kernel_params[ 5] = &device_param->d_hooks;
15070 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15071 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15072 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15073 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15074 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15075 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15076 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15077 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15078 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15079 device_param->kernel_params[15] = &device_param->d_digests_buf;
15080 device_param->kernel_params[16] = &device_param->d_digests_shown;
15081 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15082 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15083 device_param->kernel_params[19] = &device_param->d_result;
15084 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15085 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15086 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15087 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15088 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15089 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15090 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15091 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15092 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15093 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15094 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15095 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15096
15097 device_param->kernel_params_mp_buf64[3] = 0;
15098 device_param->kernel_params_mp_buf32[4] = 0;
15099 device_param->kernel_params_mp_buf32[5] = 0;
15100 device_param->kernel_params_mp_buf32[6] = 0;
15101 device_param->kernel_params_mp_buf32[7] = 0;
15102 device_param->kernel_params_mp_buf32[8] = 0;
15103
15104 device_param->kernel_params_mp[0] = NULL;
15105 device_param->kernel_params_mp[1] = NULL;
15106 device_param->kernel_params_mp[2] = NULL;
15107 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15108 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15109 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15110 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15111 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15112 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15113
15114 device_param->kernel_params_mp_l_buf64[3] = 0;
15115 device_param->kernel_params_mp_l_buf32[4] = 0;
15116 device_param->kernel_params_mp_l_buf32[5] = 0;
15117 device_param->kernel_params_mp_l_buf32[6] = 0;
15118 device_param->kernel_params_mp_l_buf32[7] = 0;
15119 device_param->kernel_params_mp_l_buf32[8] = 0;
15120 device_param->kernel_params_mp_l_buf32[9] = 0;
15121
15122 device_param->kernel_params_mp_l[0] = NULL;
15123 device_param->kernel_params_mp_l[1] = NULL;
15124 device_param->kernel_params_mp_l[2] = NULL;
15125 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15126 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15127 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15128 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15129 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15130 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15131 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15132
15133 device_param->kernel_params_mp_r_buf64[3] = 0;
15134 device_param->kernel_params_mp_r_buf32[4] = 0;
15135 device_param->kernel_params_mp_r_buf32[5] = 0;
15136 device_param->kernel_params_mp_r_buf32[6] = 0;
15137 device_param->kernel_params_mp_r_buf32[7] = 0;
15138 device_param->kernel_params_mp_r_buf32[8] = 0;
15139
15140 device_param->kernel_params_mp_r[0] = NULL;
15141 device_param->kernel_params_mp_r[1] = NULL;
15142 device_param->kernel_params_mp_r[2] = NULL;
15143 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15144 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15145 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15146 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15147 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15148 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15149
15150 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15151 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15152
15153 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15154 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15155 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15156 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15157 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15158 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15159 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15160
15161 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15162 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15163
15164 /**
15165 * kernel name
15166 */
15167
15168 size_t kernel_wgs_tmp;
15169
15170 char kernel_name[64] = { 0 };
15171
15172 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15173 {
15174 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15175 {
15176 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15177
15178 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15179
15180 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15181
15182 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15183
15184 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15185
15186 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15187 }
15188 else
15189 {
15190 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15191
15192 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15193
15194 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15195
15196 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15197
15198 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15199
15200 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15201 }
15202
15203 if (data.attack_mode == ATTACK_MODE_BF)
15204 {
15205 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15206 {
15207 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15208
15209 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15210
15211 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);
15212 }
15213 }
15214 }
15215 else
15216 {
15217 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15218
15219 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15220
15221 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15222
15223 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15224
15225 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15226
15227 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15228
15229 if (opts_type & OPTS_TYPE_HOOK12)
15230 {
15231 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15232
15233 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15234
15235 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);
15236 }
15237
15238 if (opts_type & OPTS_TYPE_HOOK23)
15239 {
15240 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15241
15242 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15243
15244 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);
15245 }
15246 }
15247
15248 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);
15249 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);
15250 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);
15251
15252 for (uint i = 0; i <= 20; i++)
15253 {
15254 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15255 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15256 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15257
15258 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15259 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15260 }
15261
15262 for (uint i = 21; i <= 31; i++)
15263 {
15264 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15265 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15266 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15267
15268 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15269 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15270 }
15271
15272 if (attack_mode == ATTACK_MODE_BF)
15273 {
15274 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15275 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15276
15277 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);
15278 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);
15279
15280 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15281 {
15282 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15283 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15284 }
15285 }
15286 else if (attack_mode == ATTACK_MODE_HYBRID1)
15287 {
15288 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15289
15290 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);
15291 }
15292 else if (attack_mode == ATTACK_MODE_HYBRID2)
15293 {
15294 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15295
15296 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);
15297 }
15298
15299 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15300 {
15301 // nothing to do
15302 }
15303 else
15304 {
15305 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15306
15307 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);
15308 }
15309
15310 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15311 {
15312 // nothing to do
15313 }
15314 else
15315 {
15316 for (uint i = 0; i < 5; i++)
15317 {
15318 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15319 }
15320
15321 for (uint i = 5; i < 7; i++)
15322 {
15323 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15324 }
15325 }
15326
15327 // maybe this has been updated by clGetKernelWorkGroupInfo()
15328 // value can only be decreased, so we don't need to reallocate buffers
15329
15330 device_param->kernel_threads = kernel_threads;
15331
15332 /**
15333 * Store initial fanspeed if gpu_temp_retain is enabled
15334 */
15335
15336 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15337 int gpu_temp_retain_set = 0;
15338
15339 if (gpu_temp_disable == 0)
15340 {
15341 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15342 {
15343 hc_thread_mutex_lock (mux_adl);
15344
15345 if (data.hm_device[device_id].fan_supported == 1)
15346 {
15347 if (gpu_temp_retain_chgd == 0)
15348 {
15349 uint cur_temp = 0;
15350 uint default_temp = 0;
15351
15352 int ADL_rc = hm_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
15353
15354 if (ADL_rc == ADL_OK)
15355 {
15356 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15357
15358 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15359
15360 // special case with multi gpu setups: always use minimum retain
15361
15362 if (gpu_temp_retain_set == 0)
15363 {
15364 gpu_temp_retain = gpu_temp_retain_target;
15365 gpu_temp_retain_set = 1;
15366 }
15367 else
15368 {
15369 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15370 }
15371
15372 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15373 }
15374 }
15375
15376 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15377
15378 temp_retain_fanspeed_value[device_id] = fan_speed;
15379
15380 if (fan_speed == -1)
15381 {
15382 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15383
15384 temp_retain_fanspeed_value[device_id] = 0;
15385 }
15386 }
15387
15388 hc_thread_mutex_unlock (mux_adl);
15389 }
15390 }
15391
15392 /**
15393 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15394 */
15395
15396 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15397 {
15398 hc_thread_mutex_lock (mux_adl);
15399
15400 if (data.hm_device[device_id].od_version == 6)
15401 {
15402 int ADL_rc;
15403
15404 // check powertune capabilities first, if not available then skip device
15405
15406 int powertune_supported = 0;
15407
15408 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15409 {
15410 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15411
15412 return (-1);
15413 }
15414
15415 if (powertune_supported != 0)
15416 {
15417 // powercontrol settings
15418
15419 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15420
15421 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15422 {
15423 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15424 }
15425
15426 if (ADL_rc != ADL_OK)
15427 {
15428 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15429
15430 return (-1);
15431 }
15432
15433 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15434 {
15435 log_error ("ERROR: Failed to set new ADL PowerControl values");
15436
15437 return (-1);
15438 }
15439
15440 // clocks
15441
15442 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15443
15444 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15445
15446 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
15447 {
15448 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15449
15450 return (-1);
15451 }
15452
15453 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15454
15455 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15456
15457 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15458 {
15459 log_error ("ERROR: Failed to get ADL device capabilities");
15460
15461 return (-1);
15462 }
15463
15464 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15465 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15466
15467 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15468 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15469
15470 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15471 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15472
15473 // warning if profile has too low max values
15474
15475 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15476 {
15477 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15478 }
15479
15480 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15481 {
15482 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15483 }
15484
15485 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15486
15487 performance_state->iNumberOfPerformanceLevels = 2;
15488
15489 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15490 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15491 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15492 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15493
15494 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
15495 {
15496 log_info ("ERROR: Failed to set ADL performance state");
15497
15498 return (-1);
15499 }
15500
15501 local_free (performance_state);
15502 }
15503 }
15504
15505 hc_thread_mutex_unlock (mux_adl);
15506 }
15507 #endif // HAVE_HWMON && HAVE_ADL
15508 }
15509
15510 data.kernel_power_all = kernel_power_all;
15511
15512 if (data.quiet == 0) log_info_nn ("");
15513
15514 /**
15515 * In benchmark-mode, inform user which algorithm is checked
15516 */
15517
15518 if (benchmark == 1)
15519 {
15520 if (status_automate == 0)
15521 {
15522 quiet = 0;
15523
15524 data.quiet = quiet;
15525
15526 char *hash_type = strhashtype (data.hash_mode); // not a bug
15527
15528 log_info ("Hashtype: %s", hash_type);
15529 log_info ("");
15530 }
15531 }
15532
15533 /**
15534 * keep track of the progress
15535 */
15536
15537 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15538 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15539 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15540
15541 /**
15542 * open filehandles
15543 */
15544
15545 #if _WIN
15546 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15547 {
15548 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15549
15550 return (-1);
15551 }
15552
15553 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15554 {
15555 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15556
15557 return (-1);
15558 }
15559
15560 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15561 {
15562 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15563
15564 return (-1);
15565 }
15566 #endif
15567
15568 /**
15569 * dictionary pad
15570 */
15571
15572 segment_size *= (1024 * 1024);
15573
15574 data.segment_size = segment_size;
15575
15576 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15577
15578 wl_data->buf = (char *) mymalloc (segment_size);
15579 wl_data->avail = segment_size;
15580 wl_data->incr = segment_size;
15581 wl_data->cnt = 0;
15582 wl_data->pos = 0;
15583
15584 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15585
15586 data.wordlist_mode = wordlist_mode;
15587
15588 cs_t *css_buf = NULL;
15589 uint css_cnt = 0;
15590 uint dictcnt = 0;
15591 uint maskcnt = 1;
15592 char **masks = NULL;
15593 char **dictfiles = NULL;
15594
15595 uint mask_from_file = 0;
15596
15597 if (attack_mode == ATTACK_MODE_STRAIGHT)
15598 {
15599 if (wordlist_mode == WL_MODE_FILE)
15600 {
15601 int wls_left = myargc - (optind + 1);
15602
15603 for (int i = 0; i < wls_left; i++)
15604 {
15605 char *l0_filename = myargv[optind + 1 + i];
15606
15607 struct stat l0_stat;
15608
15609 if (stat (l0_filename, &l0_stat) == -1)
15610 {
15611 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15612
15613 return (-1);
15614 }
15615
15616 uint is_dir = S_ISDIR (l0_stat.st_mode);
15617
15618 if (is_dir == 0)
15619 {
15620 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15621
15622 dictcnt++;
15623
15624 dictfiles[dictcnt - 1] = l0_filename;
15625 }
15626 else
15627 {
15628 // do not allow --keyspace w/ a directory
15629
15630 if (keyspace == 1)
15631 {
15632 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15633
15634 return (-1);
15635 }
15636
15637 char **dictionary_files = NULL;
15638
15639 dictionary_files = scan_directory (l0_filename);
15640
15641 if (dictionary_files != NULL)
15642 {
15643 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15644
15645 for (int d = 0; dictionary_files[d] != NULL; d++)
15646 {
15647 char *l1_filename = dictionary_files[d];
15648
15649 struct stat l1_stat;
15650
15651 if (stat (l1_filename, &l1_stat) == -1)
15652 {
15653 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15654
15655 return (-1);
15656 }
15657
15658 if (S_ISREG (l1_stat.st_mode))
15659 {
15660 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15661
15662 dictcnt++;
15663
15664 dictfiles[dictcnt - 1] = strdup (l1_filename);
15665 }
15666 }
15667 }
15668
15669 local_free (dictionary_files);
15670 }
15671 }
15672
15673 if (dictcnt < 1)
15674 {
15675 log_error ("ERROR: No usable dictionary file found.");
15676
15677 return (-1);
15678 }
15679 }
15680 else if (wordlist_mode == WL_MODE_STDIN)
15681 {
15682 dictcnt = 1;
15683 }
15684 }
15685 else if (attack_mode == ATTACK_MODE_COMBI)
15686 {
15687 // display
15688
15689 char *dictfile1 = myargv[optind + 1 + 0];
15690 char *dictfile2 = myargv[optind + 1 + 1];
15691
15692 // find the bigger dictionary and use as base
15693
15694 FILE *fp1 = NULL;
15695 FILE *fp2 = NULL;
15696
15697 struct stat tmp_stat;
15698
15699 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15700 {
15701 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15702
15703 return (-1);
15704 }
15705
15706 if (stat (dictfile1, &tmp_stat) == -1)
15707 {
15708 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15709
15710 fclose (fp1);
15711
15712 return (-1);
15713 }
15714
15715 if (S_ISDIR (tmp_stat.st_mode))
15716 {
15717 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15718
15719 fclose (fp1);
15720
15721 return (-1);
15722 }
15723
15724 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15725 {
15726 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15727
15728 fclose (fp1);
15729
15730 return (-1);
15731 }
15732
15733 if (stat (dictfile2, &tmp_stat) == -1)
15734 {
15735 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15736
15737 fclose (fp1);
15738 fclose (fp2);
15739
15740 return (-1);
15741 }
15742
15743 if (S_ISDIR (tmp_stat.st_mode))
15744 {
15745 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15746
15747 fclose (fp1);
15748 fclose (fp2);
15749
15750 return (-1);
15751 }
15752
15753 data.combs_cnt = 1;
15754
15755 data.quiet = 1;
15756
15757 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15758
15759 data.quiet = quiet;
15760
15761 if (words1_cnt == 0)
15762 {
15763 log_error ("ERROR: %s: empty file", dictfile1);
15764
15765 fclose (fp1);
15766 fclose (fp2);
15767
15768 return (-1);
15769 }
15770
15771 data.combs_cnt = 1;
15772
15773 data.quiet = 1;
15774
15775 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15776
15777 data.quiet = quiet;
15778
15779 if (words2_cnt == 0)
15780 {
15781 log_error ("ERROR: %s: empty file", dictfile2);
15782
15783 fclose (fp1);
15784 fclose (fp2);
15785
15786 return (-1);
15787 }
15788
15789 fclose (fp1);
15790 fclose (fp2);
15791
15792 data.dictfile = dictfile1;
15793 data.dictfile2 = dictfile2;
15794
15795 if (words1_cnt >= words2_cnt)
15796 {
15797 data.combs_cnt = words2_cnt;
15798 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15799
15800 dictfiles = &data.dictfile;
15801
15802 dictcnt = 1;
15803 }
15804 else
15805 {
15806 data.combs_cnt = words1_cnt;
15807 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15808
15809 dictfiles = &data.dictfile2;
15810
15811 dictcnt = 1;
15812
15813 // we also have to switch wordlist related rules!
15814
15815 char *tmpc = data.rule_buf_l;
15816
15817 data.rule_buf_l = data.rule_buf_r;
15818 data.rule_buf_r = tmpc;
15819
15820 int tmpi = data.rule_len_l;
15821
15822 data.rule_len_l = data.rule_len_r;
15823 data.rule_len_r = tmpi;
15824 }
15825 }
15826 else if (attack_mode == ATTACK_MODE_BF)
15827 {
15828 char *mask = NULL;
15829
15830 maskcnt = 0;
15831
15832 if (benchmark == 0)
15833 {
15834 mask = myargv[optind + 1];
15835
15836 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15837
15838 if ((optind + 2) <= myargc)
15839 {
15840 struct stat file_stat;
15841
15842 if (stat (mask, &file_stat) == -1)
15843 {
15844 maskcnt = 1;
15845
15846 masks[maskcnt - 1] = mystrdup (mask);
15847 }
15848 else
15849 {
15850 int wls_left = myargc - (optind + 1);
15851
15852 uint masks_avail = INCR_MASKS;
15853
15854 for (int i = 0; i < wls_left; i++)
15855 {
15856 if (i != 0)
15857 {
15858 mask = myargv[optind + 1 + i];
15859
15860 if (stat (mask, &file_stat) == -1)
15861 {
15862 log_error ("ERROR: %s: %s", mask, strerror (errno));
15863
15864 return (-1);
15865 }
15866 }
15867
15868 uint is_file = S_ISREG (file_stat.st_mode);
15869
15870 if (is_file == 1)
15871 {
15872 FILE *mask_fp;
15873
15874 if ((mask_fp = fopen (mask, "r")) == NULL)
15875 {
15876 log_error ("ERROR: %s: %s", mask, strerror (errno));
15877
15878 return (-1);
15879 }
15880
15881 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15882
15883 while (!feof (mask_fp))
15884 {
15885 memset (line_buf, 0, HCBUFSIZ);
15886
15887 int line_len = fgetl (mask_fp, line_buf);
15888
15889 if (line_len == 0) continue;
15890
15891 if (line_buf[0] == '#') continue;
15892
15893 if (masks_avail == maskcnt)
15894 {
15895 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15896
15897 masks_avail += INCR_MASKS;
15898 }
15899
15900 masks[maskcnt] = mystrdup (line_buf);
15901
15902 maskcnt++;
15903 }
15904
15905 myfree (line_buf);
15906
15907 fclose (mask_fp);
15908 }
15909 else
15910 {
15911 log_error ("ERROR: %s: unsupported file-type", mask);
15912
15913 return (-1);
15914 }
15915 }
15916
15917 mask_from_file = 1;
15918 }
15919 }
15920 else
15921 {
15922 custom_charset_1 = (char *) "?l?d?u";
15923 custom_charset_2 = (char *) "?l?d";
15924 custom_charset_3 = (char *) "?l?d*!$@_";
15925
15926 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15927 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15928 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15929
15930 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15931
15932 wordlist_mode = WL_MODE_MASK;
15933
15934 data.wordlist_mode = wordlist_mode;
15935
15936 increment = 1;
15937
15938 maskcnt = 1;
15939 }
15940 }
15941 else
15942 {
15943 /**
15944 * generate full masks and charsets
15945 */
15946
15947 masks = (char **) mymalloc (sizeof (char *));
15948
15949 switch (hash_mode)
15950 {
15951 case 1731: pw_min = 5;
15952 pw_max = 5;
15953 mask = mystrdup ("?b?b?b?b?b");
15954 break;
15955 case 12500: pw_min = 5;
15956 pw_max = 5;
15957 mask = mystrdup ("?b?b?b?b?b");
15958 break;
15959 default: pw_min = 7;
15960 pw_max = 7;
15961 mask = mystrdup ("?b?b?b?b?b?b?b");
15962 break;
15963 }
15964
15965 maskcnt = 1;
15966
15967 masks[maskcnt - 1] = mystrdup (mask);
15968
15969 wordlist_mode = WL_MODE_MASK;
15970
15971 data.wordlist_mode = wordlist_mode;
15972
15973 increment = 1;
15974 }
15975
15976 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15977
15978 if (increment)
15979 {
15980 if (increment_min > pw_min) pw_min = increment_min;
15981
15982 if (increment_max < pw_max) pw_max = increment_max;
15983 }
15984 }
15985 else if (attack_mode == ATTACK_MODE_HYBRID1)
15986 {
15987 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15988
15989 // display
15990
15991 char *mask = myargv[myargc - 1];
15992
15993 maskcnt = 0;
15994
15995 masks = (char **) mymalloc (1 * sizeof (char *));
15996
15997 // mod
15998
15999 struct stat file_stat;
16000
16001 if (stat (mask, &file_stat) == -1)
16002 {
16003 maskcnt = 1;
16004
16005 masks[maskcnt - 1] = mystrdup (mask);
16006 }
16007 else
16008 {
16009 uint is_file = S_ISREG (file_stat.st_mode);
16010
16011 if (is_file == 1)
16012 {
16013 FILE *mask_fp;
16014
16015 if ((mask_fp = fopen (mask, "r")) == NULL)
16016 {
16017 log_error ("ERROR: %s: %s", mask, strerror (errno));
16018
16019 return (-1);
16020 }
16021
16022 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16023
16024 uint masks_avail = 1;
16025
16026 while (!feof (mask_fp))
16027 {
16028 memset (line_buf, 0, HCBUFSIZ);
16029
16030 int line_len = fgetl (mask_fp, line_buf);
16031
16032 if (line_len == 0) continue;
16033
16034 if (line_buf[0] == '#') continue;
16035
16036 if (masks_avail == maskcnt)
16037 {
16038 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16039
16040 masks_avail += INCR_MASKS;
16041 }
16042
16043 masks[maskcnt] = mystrdup (line_buf);
16044
16045 maskcnt++;
16046 }
16047
16048 myfree (line_buf);
16049
16050 fclose (mask_fp);
16051
16052 mask_from_file = 1;
16053 }
16054 else
16055 {
16056 maskcnt = 1;
16057
16058 masks[maskcnt - 1] = mystrdup (mask);
16059 }
16060 }
16061
16062 // base
16063
16064 int wls_left = myargc - (optind + 2);
16065
16066 for (int i = 0; i < wls_left; i++)
16067 {
16068 char *filename = myargv[optind + 1 + i];
16069
16070 struct stat file_stat;
16071
16072 if (stat (filename, &file_stat) == -1)
16073 {
16074 log_error ("ERROR: %s: %s", filename, strerror (errno));
16075
16076 return (-1);
16077 }
16078
16079 uint is_dir = S_ISDIR (file_stat.st_mode);
16080
16081 if (is_dir == 0)
16082 {
16083 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16084
16085 dictcnt++;
16086
16087 dictfiles[dictcnt - 1] = filename;
16088 }
16089 else
16090 {
16091 // do not allow --keyspace w/ a directory
16092
16093 if (keyspace == 1)
16094 {
16095 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16096
16097 return (-1);
16098 }
16099
16100 char **dictionary_files = NULL;
16101
16102 dictionary_files = scan_directory (filename);
16103
16104 if (dictionary_files != NULL)
16105 {
16106 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16107
16108 for (int d = 0; dictionary_files[d] != NULL; d++)
16109 {
16110 char *l1_filename = dictionary_files[d];
16111
16112 struct stat l1_stat;
16113
16114 if (stat (l1_filename, &l1_stat) == -1)
16115 {
16116 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16117
16118 return (-1);
16119 }
16120
16121 if (S_ISREG (l1_stat.st_mode))
16122 {
16123 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16124
16125 dictcnt++;
16126
16127 dictfiles[dictcnt - 1] = strdup (l1_filename);
16128 }
16129 }
16130 }
16131
16132 local_free (dictionary_files);
16133 }
16134 }
16135
16136 if (dictcnt < 1)
16137 {
16138 log_error ("ERROR: No usable dictionary file found.");
16139
16140 return (-1);
16141 }
16142
16143 if (increment)
16144 {
16145 maskcnt = 0;
16146
16147 uint mask_min = increment_min; // we can't reject smaller masks here
16148 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16149
16150 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16151 {
16152 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16153
16154 if (cur_mask == NULL) break;
16155
16156 masks[maskcnt] = cur_mask;
16157
16158 maskcnt++;
16159
16160 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16161 }
16162 }
16163 }
16164 else if (attack_mode == ATTACK_MODE_HYBRID2)
16165 {
16166 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16167
16168 // display
16169
16170 char *mask = myargv[optind + 1 + 0];
16171
16172 maskcnt = 0;
16173
16174 masks = (char **) mymalloc (1 * sizeof (char *));
16175
16176 // mod
16177
16178 struct stat file_stat;
16179
16180 if (stat (mask, &file_stat) == -1)
16181 {
16182 maskcnt = 1;
16183
16184 masks[maskcnt - 1] = mystrdup (mask);
16185 }
16186 else
16187 {
16188 uint is_file = S_ISREG (file_stat.st_mode);
16189
16190 if (is_file == 1)
16191 {
16192 FILE *mask_fp;
16193
16194 if ((mask_fp = fopen (mask, "r")) == NULL)
16195 {
16196 log_error ("ERROR: %s: %s", mask, strerror (errno));
16197
16198 return (-1);
16199 }
16200
16201 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16202
16203 uint masks_avail = 1;
16204
16205 while (!feof (mask_fp))
16206 {
16207 memset (line_buf, 0, HCBUFSIZ);
16208
16209 int line_len = fgetl (mask_fp, line_buf);
16210
16211 if (line_len == 0) continue;
16212
16213 if (line_buf[0] == '#') continue;
16214
16215 if (masks_avail == maskcnt)
16216 {
16217 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16218
16219 masks_avail += INCR_MASKS;
16220 }
16221
16222 masks[maskcnt] = mystrdup (line_buf);
16223
16224 maskcnt++;
16225 }
16226
16227 myfree (line_buf);
16228
16229 fclose (mask_fp);
16230
16231 mask_from_file = 1;
16232 }
16233 else
16234 {
16235 maskcnt = 1;
16236
16237 masks[maskcnt - 1] = mystrdup (mask);
16238 }
16239 }
16240
16241 // base
16242
16243 int wls_left = myargc - (optind + 2);
16244
16245 for (int i = 0; i < wls_left; i++)
16246 {
16247 char *filename = myargv[optind + 2 + i];
16248
16249 struct stat file_stat;
16250
16251 if (stat (filename, &file_stat) == -1)
16252 {
16253 log_error ("ERROR: %s: %s", filename, strerror (errno));
16254
16255 return (-1);
16256 }
16257
16258 uint is_dir = S_ISDIR (file_stat.st_mode);
16259
16260 if (is_dir == 0)
16261 {
16262 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16263
16264 dictcnt++;
16265
16266 dictfiles[dictcnt - 1] = filename;
16267 }
16268 else
16269 {
16270 // do not allow --keyspace w/ a directory
16271
16272 if (keyspace == 1)
16273 {
16274 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16275
16276 return (-1);
16277 }
16278
16279 char **dictionary_files = NULL;
16280
16281 dictionary_files = scan_directory (filename);
16282
16283 if (dictionary_files != NULL)
16284 {
16285 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16286
16287 for (int d = 0; dictionary_files[d] != NULL; d++)
16288 {
16289 char *l1_filename = dictionary_files[d];
16290
16291 struct stat l1_stat;
16292
16293 if (stat (l1_filename, &l1_stat) == -1)
16294 {
16295 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16296
16297 return (-1);
16298 }
16299
16300 if (S_ISREG (l1_stat.st_mode))
16301 {
16302 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16303
16304 dictcnt++;
16305
16306 dictfiles[dictcnt - 1] = strdup (l1_filename);
16307 }
16308 }
16309 }
16310
16311 local_free (dictionary_files);
16312 }
16313 }
16314
16315 if (dictcnt < 1)
16316 {
16317 log_error ("ERROR: No usable dictionary file found.");
16318
16319 return (-1);
16320 }
16321
16322 if (increment)
16323 {
16324 maskcnt = 0;
16325
16326 uint mask_min = increment_min; // we can't reject smaller masks here
16327 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16328
16329 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16330 {
16331 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16332
16333 if (cur_mask == NULL) break;
16334
16335 masks[maskcnt] = cur_mask;
16336
16337 maskcnt++;
16338
16339 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16340 }
16341 }
16342 }
16343
16344 data.pw_min = pw_min;
16345 data.pw_max = pw_max;
16346
16347 /**
16348 * weak hash check
16349 */
16350
16351 if (weak_hash_threshold >= salts_cnt)
16352 {
16353 hc_device_param_t *device_param = NULL;
16354
16355 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16356 {
16357 device_param = &data.devices_param[device_id];
16358
16359 if (device_param->skipped) continue;
16360
16361 break;
16362 }
16363
16364 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16365
16366 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16367 {
16368 weak_hash_check (device_param, salt_pos);
16369 }
16370
16371 // Display hack, guarantee that there is at least one \r before real start
16372
16373 //if (data.quiet == 0) log_info ("");
16374 }
16375
16376 /**
16377 * status and monitor threads
16378 */
16379
16380 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16381
16382 hc_thread_t i_thread = 0;
16383
16384 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16385 {
16386 hc_thread_create (i_thread, thread_keypress, &benchmark);
16387 }
16388
16389 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16390
16391 uint ni_threads_cnt = 0;
16392
16393 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16394
16395 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16396
16397 ni_threads_cnt++;
16398
16399 /**
16400 * Outfile remove
16401 */
16402
16403 if (keyspace == 0)
16404 {
16405 if (outfile_check_timer != 0)
16406 {
16407 if (data.outfile_check_directory != NULL)
16408 {
16409 if ((hash_mode != 5200) &&
16410 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16411 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16412 (hash_mode != 9000))
16413 {
16414 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16415
16416 ni_threads_cnt++;
16417 }
16418 else
16419 {
16420 outfile_check_timer = 0;
16421 }
16422 }
16423 else
16424 {
16425 outfile_check_timer = 0;
16426 }
16427 }
16428 }
16429
16430 /**
16431 * Inform the user if we got some hashes remove because of the pot file remove feature
16432 */
16433
16434 if (data.quiet == 0)
16435 {
16436 if (potfile_remove_cracks > 0)
16437 {
16438 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16439 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16440 }
16441 }
16442
16443 data.outfile_check_timer = outfile_check_timer;
16444
16445 /**
16446 * main loop
16447 */
16448
16449 char **induction_dictionaries = NULL;
16450
16451 int induction_dictionaries_cnt = 0;
16452
16453 hcstat_table_t *root_table_buf = NULL;
16454 hcstat_table_t *markov_table_buf = NULL;
16455
16456 uint initial_restore_done = 0;
16457
16458 data.maskcnt = maskcnt;
16459
16460 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16461 {
16462 if (data.devices_status == STATUS_CRACKED) break;
16463
16464 data.devices_status = STATUS_INIT;
16465
16466 if (maskpos > rd->maskpos)
16467 {
16468 rd->dictpos = 0;
16469 }
16470
16471 rd->maskpos = maskpos;
16472 data.maskpos = maskpos;
16473
16474 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16475 {
16476 char *mask = masks[maskpos];
16477
16478 if (mask_from_file == 1)
16479 {
16480 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16481
16482 char *str_ptr;
16483 uint str_pos;
16484
16485 uint mask_offset = 0;
16486
16487 uint separator_cnt;
16488
16489 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16490 {
16491 str_ptr = strstr (mask + mask_offset, ",");
16492
16493 if (str_ptr == NULL) break;
16494
16495 str_pos = str_ptr - mask;
16496
16497 // escaped separator, i.e. "\,"
16498
16499 if (str_pos > 0)
16500 {
16501 if (mask[str_pos - 1] == '\\')
16502 {
16503 separator_cnt --;
16504
16505 mask_offset = str_pos + 1;
16506
16507 continue;
16508 }
16509 }
16510
16511 // reset the offset
16512
16513 mask_offset = 0;
16514
16515 mask[str_pos] = '\0';
16516
16517 switch (separator_cnt)
16518 {
16519 case 0:
16520 mp_reset_usr (mp_usr, 0);
16521
16522 custom_charset_1 = mask;
16523 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16524 break;
16525
16526 case 1:
16527 mp_reset_usr (mp_usr, 1);
16528
16529 custom_charset_2 = mask;
16530 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16531 break;
16532
16533 case 2:
16534 mp_reset_usr (mp_usr, 2);
16535
16536 custom_charset_3 = mask;
16537 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16538 break;
16539
16540 case 3:
16541 mp_reset_usr (mp_usr, 3);
16542
16543 custom_charset_4 = mask;
16544 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16545 break;
16546 }
16547
16548 mask = mask + str_pos + 1;
16549 }
16550 }
16551
16552 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16553 {
16554 if (maskpos > 0)
16555 {
16556 local_free (css_buf);
16557 local_free (data.root_css_buf);
16558 local_free (data.markov_css_buf);
16559
16560 local_free (masks[maskpos - 1]);
16561 }
16562
16563 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16564
16565 data.mask = mask;
16566 data.css_cnt = css_cnt;
16567 data.css_buf = css_buf;
16568
16569 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16570
16571 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16572
16573 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16574 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16575
16576 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16577
16578 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16579
16580 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16581 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16582
16583 data.root_css_buf = root_css_buf;
16584 data.markov_css_buf = markov_css_buf;
16585
16586 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16587
16588 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16589
16590 local_free (root_table_buf);
16591 local_free (markov_table_buf);
16592
16593 // args
16594
16595 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16596 {
16597 hc_device_param_t *device_param = &data.devices_param[device_id];
16598
16599 if (device_param->skipped) continue;
16600
16601 device_param->kernel_params_mp[0] = &device_param->d_combs;
16602 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16603 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16604
16605 device_param->kernel_params_mp_buf64[3] = 0;
16606 device_param->kernel_params_mp_buf32[4] = css_cnt;
16607 device_param->kernel_params_mp_buf32[5] = 0;
16608 device_param->kernel_params_mp_buf32[6] = 0;
16609 device_param->kernel_params_mp_buf32[7] = 0;
16610
16611 if (attack_mode == ATTACK_MODE_HYBRID1)
16612 {
16613 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16614 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16615 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16616 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16617 }
16618 else if (attack_mode == ATTACK_MODE_HYBRID2)
16619 {
16620 device_param->kernel_params_mp_buf32[5] = 0;
16621 device_param->kernel_params_mp_buf32[6] = 0;
16622 device_param->kernel_params_mp_buf32[7] = 0;
16623 }
16624
16625 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]);
16626 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]);
16627 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]);
16628
16629 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);
16630 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);
16631 }
16632 }
16633 else if (attack_mode == ATTACK_MODE_BF)
16634 {
16635 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16636
16637 if (increment)
16638 {
16639 for (uint i = 0; i < dictcnt; i++)
16640 {
16641 local_free (dictfiles[i]);
16642 }
16643
16644 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16645 {
16646 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16647
16648 if (l1_filename == NULL) break;
16649
16650 dictcnt++;
16651
16652 dictfiles[dictcnt - 1] = l1_filename;
16653 }
16654 }
16655 else
16656 {
16657 dictcnt++;
16658
16659 dictfiles[dictcnt - 1] = mask;
16660 }
16661
16662 if (dictcnt == 0)
16663 {
16664 log_error ("ERROR: Mask is too small");
16665
16666 return (-1);
16667 }
16668 }
16669 }
16670
16671 free (induction_dictionaries);
16672
16673 // induction_dictionaries_cnt = 0; // implied
16674
16675 if (attack_mode != ATTACK_MODE_BF)
16676 {
16677 if (keyspace == 0)
16678 {
16679 induction_dictionaries = scan_directory (induction_directory);
16680
16681 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16682 }
16683 }
16684
16685 if (induction_dictionaries_cnt)
16686 {
16687 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16688 }
16689
16690 /**
16691 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16692 */
16693 if (keyspace == 1)
16694 {
16695 if ((maskcnt > 1) || (dictcnt > 1))
16696 {
16697 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16698
16699 return (-1);
16700 }
16701 }
16702
16703 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16704 {
16705 char *subid = logfile_generate_subid ();
16706
16707 data.subid = subid;
16708
16709 logfile_sub_msg ("START");
16710
16711 data.devices_status = STATUS_INIT;
16712
16713 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16714 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16715 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16716
16717 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16718
16719 data.cpt_pos = 0;
16720
16721 data.cpt_start = time (NULL);
16722
16723 data.cpt_total = 0;
16724
16725 if (data.restore == 0)
16726 {
16727 rd->words_cur = skip;
16728
16729 skip = 0;
16730
16731 data.skip = 0;
16732 }
16733
16734 data.ms_paused = 0;
16735
16736 data.words_cur = rd->words_cur;
16737
16738 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16739 {
16740 hc_device_param_t *device_param = &data.devices_param[device_id];
16741
16742 if (device_param->skipped) continue;
16743
16744 device_param->speed_pos = 0;
16745
16746 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16747 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16748
16749 device_param->exec_pos = 0;
16750
16751 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16752
16753 device_param->kernel_power = device_param->kernel_power_user;
16754
16755 device_param->outerloop_pos = 0;
16756 device_param->outerloop_left = 0;
16757 device_param->innerloop_pos = 0;
16758 device_param->innerloop_left = 0;
16759
16760 // some more resets:
16761
16762 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16763
16764 device_param->pws_cnt = 0;
16765
16766 device_param->words_off = 0;
16767 device_param->words_done = 0;
16768 }
16769
16770 data.kernel_power_div = 0;
16771
16772 // figure out some workload
16773
16774 if (attack_mode == ATTACK_MODE_STRAIGHT)
16775 {
16776 if (data.wordlist_mode == WL_MODE_FILE)
16777 {
16778 char *dictfile = NULL;
16779
16780 if (induction_dictionaries_cnt)
16781 {
16782 dictfile = induction_dictionaries[0];
16783 }
16784 else
16785 {
16786 dictfile = dictfiles[dictpos];
16787 }
16788
16789 data.dictfile = dictfile;
16790
16791 logfile_sub_string (dictfile);
16792
16793 for (uint i = 0; i < rp_files_cnt; i++)
16794 {
16795 logfile_sub_var_string ("rulefile", rp_files[i]);
16796 }
16797
16798 FILE *fd2 = fopen (dictfile, "rb");
16799
16800 if (fd2 == NULL)
16801 {
16802 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16803
16804 return (-1);
16805 }
16806
16807 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16808
16809 fclose (fd2);
16810
16811 if (data.words_cnt == 0)
16812 {
16813 if (data.devices_status == STATUS_CRACKED) break;
16814 if (data.devices_status == STATUS_ABORTED) break;
16815
16816 dictpos++;
16817
16818 continue;
16819 }
16820 }
16821 }
16822 else if (attack_mode == ATTACK_MODE_COMBI)
16823 {
16824 char *dictfile = data.dictfile;
16825 char *dictfile2 = data.dictfile2;
16826
16827 logfile_sub_string (dictfile);
16828 logfile_sub_string (dictfile2);
16829
16830 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16831 {
16832 FILE *fd2 = fopen (dictfile, "rb");
16833
16834 if (fd2 == NULL)
16835 {
16836 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16837
16838 return (-1);
16839 }
16840
16841 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16842
16843 fclose (fd2);
16844 }
16845 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16846 {
16847 FILE *fd2 = fopen (dictfile2, "rb");
16848
16849 if (fd2 == NULL)
16850 {
16851 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16852
16853 return (-1);
16854 }
16855
16856 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16857
16858 fclose (fd2);
16859 }
16860
16861 if (data.words_cnt == 0)
16862 {
16863 if (data.devices_status == STATUS_CRACKED) break;
16864 if (data.devices_status == STATUS_ABORTED) break;
16865
16866 dictpos++;
16867
16868 continue;
16869 }
16870 }
16871 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16872 {
16873 char *dictfile = NULL;
16874
16875 if (induction_dictionaries_cnt)
16876 {
16877 dictfile = induction_dictionaries[0];
16878 }
16879 else
16880 {
16881 dictfile = dictfiles[dictpos];
16882 }
16883
16884 data.dictfile = dictfile;
16885
16886 char *mask = data.mask;
16887
16888 logfile_sub_string (dictfile);
16889 logfile_sub_string (mask);
16890
16891 FILE *fd2 = fopen (dictfile, "rb");
16892
16893 if (fd2 == NULL)
16894 {
16895 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16896
16897 return (-1);
16898 }
16899
16900 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16901
16902 fclose (fd2);
16903
16904 if (data.words_cnt == 0)
16905 {
16906 if (data.devices_status == STATUS_CRACKED) break;
16907 if (data.devices_status == STATUS_ABORTED) break;
16908
16909 dictpos++;
16910
16911 continue;
16912 }
16913 }
16914 else if (attack_mode == ATTACK_MODE_BF)
16915 {
16916 local_free (css_buf);
16917 local_free (data.root_css_buf);
16918 local_free (data.markov_css_buf);
16919
16920 char *mask = dictfiles[dictpos];
16921
16922 logfile_sub_string (mask);
16923
16924 // base
16925
16926 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16927
16928 if (opts_type & OPTS_TYPE_PT_UNICODE)
16929 {
16930 uint css_cnt_unicode = css_cnt * 2;
16931
16932 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16933
16934 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16935 {
16936 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16937
16938 css_buf_unicode[j + 1].cs_buf[0] = 0;
16939 css_buf_unicode[j + 1].cs_len = 1;
16940 }
16941
16942 free (css_buf);
16943
16944 css_buf = css_buf_unicode;
16945 css_cnt = css_cnt_unicode;
16946 }
16947
16948 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16949
16950 uint mask_min = pw_min;
16951 uint mask_max = pw_max;
16952
16953 if (opts_type & OPTS_TYPE_PT_UNICODE)
16954 {
16955 mask_min *= 2;
16956 mask_max *= 2;
16957 }
16958
16959 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16960 {
16961 if (css_cnt < mask_min)
16962 {
16963 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16964 }
16965
16966 if (css_cnt > mask_max)
16967 {
16968 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16969 }
16970
16971 // skip to next mask
16972
16973 dictpos++;
16974
16975 rd->dictpos = dictpos;
16976
16977 logfile_sub_msg ("STOP");
16978
16979 continue;
16980 }
16981
16982 uint save_css_cnt = css_cnt;
16983
16984 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16985 {
16986 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16987 {
16988 uint salt_len = (uint) data.salts_buf[0].salt_len;
16989 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16990
16991 uint css_cnt_salt = css_cnt + salt_len;
16992
16993 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16994
16995 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16996
16997 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16998 {
16999 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17000 css_buf_salt[j].cs_len = 1;
17001 }
17002
17003 free (css_buf);
17004
17005 css_buf = css_buf_salt;
17006 css_cnt = css_cnt_salt;
17007 }
17008 }
17009
17010 data.mask = mask;
17011 data.css_cnt = css_cnt;
17012 data.css_buf = css_buf;
17013
17014 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17015
17016 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17017
17018 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17019
17020 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17021 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17022
17023 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17024
17025 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17026
17027 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17028 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17029
17030 data.root_css_buf = root_css_buf;
17031 data.markov_css_buf = markov_css_buf;
17032
17033 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17034
17035 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17036
17037 local_free (root_table_buf);
17038 local_free (markov_table_buf);
17039
17040 // copy + args
17041
17042 uint css_cnt_l = css_cnt;
17043 uint css_cnt_r;
17044
17045 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17046 {
17047 if (save_css_cnt < 6)
17048 {
17049 css_cnt_r = 1;
17050 }
17051 else if (save_css_cnt == 6)
17052 {
17053 css_cnt_r = 2;
17054 }
17055 else
17056 {
17057 if (opts_type & OPTS_TYPE_PT_UNICODE)
17058 {
17059 if (save_css_cnt == 8 || save_css_cnt == 10)
17060 {
17061 css_cnt_r = 2;
17062 }
17063 else
17064 {
17065 css_cnt_r = 4;
17066 }
17067 }
17068 else
17069 {
17070 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17071 {
17072 css_cnt_r = 3;
17073 }
17074 else
17075 {
17076 css_cnt_r = 4;
17077 }
17078 }
17079 }
17080 }
17081 else
17082 {
17083 css_cnt_r = 1;
17084
17085 /* unfinished code?
17086 int sum = css_buf[css_cnt_r - 1].cs_len;
17087
17088 for (uint i = 1; i < 4 && i < css_cnt; i++)
17089 {
17090 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17091
17092 css_cnt_r++;
17093
17094 sum *= css_buf[css_cnt_r - 1].cs_len;
17095 }
17096 */
17097 }
17098
17099 css_cnt_l -= css_cnt_r;
17100
17101 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17102
17103 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17104 {
17105 hc_device_param_t *device_param = &data.devices_param[device_id];
17106
17107 if (device_param->skipped) continue;
17108
17109 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17110 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17111 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17112
17113 device_param->kernel_params_mp_l_buf64[3] = 0;
17114 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17115 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17116 device_param->kernel_params_mp_l_buf32[6] = 0;
17117 device_param->kernel_params_mp_l_buf32[7] = 0;
17118 device_param->kernel_params_mp_l_buf32[8] = 0;
17119
17120 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17121 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17122 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17123 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17124
17125 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17126 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17127 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17128
17129 device_param->kernel_params_mp_r_buf64[3] = 0;
17130 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17131 device_param->kernel_params_mp_r_buf32[5] = 0;
17132 device_param->kernel_params_mp_r_buf32[6] = 0;
17133 device_param->kernel_params_mp_r_buf32[7] = 0;
17134
17135 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]);
17136 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]);
17137 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]);
17138
17139 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]);
17140 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]);
17141 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]);
17142
17143 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);
17144 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);
17145 }
17146 }
17147
17148 u64 words_base = data.words_cnt;
17149
17150 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17151 {
17152 if (data.kernel_rules_cnt)
17153 {
17154 words_base /= data.kernel_rules_cnt;
17155 }
17156 }
17157 else if (data.attack_kern == ATTACK_KERN_COMBI)
17158 {
17159 if (data.combs_cnt)
17160 {
17161 words_base /= data.combs_cnt;
17162 }
17163 }
17164 else if (data.attack_kern == ATTACK_KERN_BF)
17165 {
17166 if (data.bfs_cnt)
17167 {
17168 words_base /= data.bfs_cnt;
17169 }
17170 }
17171
17172 data.words_base = words_base;
17173
17174 if (keyspace == 1)
17175 {
17176 log_info ("%llu", (unsigned long long int) words_base);
17177
17178 return (0);
17179 }
17180
17181 if (data.words_cur > data.words_base)
17182 {
17183 log_error ("ERROR: restore value greater keyspace");
17184
17185 return (-1);
17186 }
17187
17188 if (data.words_cur)
17189 {
17190 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17191 {
17192 for (uint i = 0; i < data.salts_cnt; i++)
17193 {
17194 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17195 }
17196 }
17197 else if (data.attack_kern == ATTACK_KERN_COMBI)
17198 {
17199 for (uint i = 0; i < data.salts_cnt; i++)
17200 {
17201 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17202 }
17203 }
17204 else if (data.attack_kern == ATTACK_KERN_BF)
17205 {
17206 for (uint i = 0; i < data.salts_cnt; i++)
17207 {
17208 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17209 }
17210 }
17211 }
17212
17213 /*
17214 * Inform user about possible slow speeds
17215 */
17216
17217 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17218 {
17219 if (data.words_base < kernel_power_all)
17220 {
17221 if (quiet == 0)
17222 {
17223 log_info ("ATTENTION!");
17224 log_info (" The wordlist or mask you are using is too small.");
17225 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17226 log_info (" The cracking speed will drop.");
17227 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17228 log_info ("");
17229 }
17230 }
17231 }
17232
17233 /*
17234 * Update loopback file
17235 */
17236
17237 if (loopback == 1)
17238 {
17239 time_t now;
17240
17241 time (&now);
17242
17243 uint random_num = get_random_num (0, 9999);
17244
17245 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17246
17247 data.loopback_file = loopback_file;
17248 }
17249
17250 /*
17251 * Update dictionary statistic
17252 */
17253
17254 if (keyspace == 0)
17255 {
17256 dictstat_fp = fopen (dictstat, "wb");
17257
17258 if (dictstat_fp)
17259 {
17260 lock_file (dictstat_fp);
17261
17262 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17263
17264 fclose (dictstat_fp);
17265 }
17266 }
17267
17268 data.devices_status = STATUS_RUNNING;
17269
17270 if (initial_restore_done == 0)
17271 {
17272 if (data.restore_disable == 0) cycle_restore ();
17273
17274 initial_restore_done = 1;
17275 }
17276
17277 hc_timer_set (&data.timer_running);
17278
17279 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17280 {
17281 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17282 {
17283 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17284 if (quiet == 0) fflush (stdout);
17285 }
17286 }
17287 else if (wordlist_mode == WL_MODE_STDIN)
17288 {
17289 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17290 if (data.quiet == 0) log_info ("");
17291 }
17292
17293 time_t runtime_start;
17294
17295 time (&runtime_start);
17296
17297 data.runtime_start = runtime_start;
17298
17299 /**
17300 * create cracker threads
17301 */
17302
17303 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17304
17305 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17306 {
17307 hc_device_param_t *device_param = &devices_param[device_id];
17308
17309 if (wordlist_mode == WL_MODE_STDIN)
17310 {
17311 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17312 }
17313 else
17314 {
17315 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17316 }
17317 }
17318
17319 // wait for crack threads to exit
17320
17321 hc_thread_wait (data.devices_cnt, c_threads);
17322
17323 local_free (c_threads);
17324
17325 data.restore = 0;
17326
17327 // finalize task
17328
17329 logfile_sub_var_uint ("status-after-work", data.devices_status);
17330
17331 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17332
17333 if (data.devices_status == STATUS_CRACKED) break;
17334 if (data.devices_status == STATUS_ABORTED) break;
17335
17336 if (data.devices_status == STATUS_BYPASS)
17337 {
17338 data.devices_status = STATUS_RUNNING;
17339 }
17340
17341 if (induction_dictionaries_cnt)
17342 {
17343 unlink (induction_dictionaries[0]);
17344 }
17345
17346 free (induction_dictionaries);
17347
17348 if (attack_mode != ATTACK_MODE_BF)
17349 {
17350 induction_dictionaries = scan_directory (induction_directory);
17351
17352 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17353 }
17354
17355 if (benchmark == 0)
17356 {
17357 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17358 {
17359 if (quiet == 0) clear_prompt ();
17360
17361 if (quiet == 0) log_info ("");
17362
17363 if (status == 1)
17364 {
17365 status_display ();
17366 }
17367 else
17368 {
17369 if (quiet == 0) status_display ();
17370 }
17371
17372 if (quiet == 0) log_info ("");
17373 }
17374 }
17375
17376 if (attack_mode == ATTACK_MODE_BF)
17377 {
17378 dictpos++;
17379
17380 rd->dictpos = dictpos;
17381 }
17382 else
17383 {
17384 if (induction_dictionaries_cnt)
17385 {
17386 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17387 }
17388 else
17389 {
17390 dictpos++;
17391
17392 rd->dictpos = dictpos;
17393 }
17394 }
17395
17396 time_t runtime_stop;
17397
17398 time (&runtime_stop);
17399
17400 data.runtime_stop = runtime_stop;
17401
17402 logfile_sub_uint (runtime_start);
17403 logfile_sub_uint (runtime_stop);
17404
17405 logfile_sub_msg ("STOP");
17406
17407 global_free (subid);
17408 }
17409
17410 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17411
17412 if (data.devices_status == STATUS_CRACKED) break;
17413 if (data.devices_status == STATUS_ABORTED) break;
17414 if (data.devices_status == STATUS_QUIT) break;
17415
17416 if (data.devices_status == STATUS_BYPASS)
17417 {
17418 data.devices_status = STATUS_RUNNING;
17419 }
17420 }
17421
17422 // 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
17423
17424 if (attack_mode == ATTACK_MODE_STRAIGHT)
17425 {
17426 if (data.wordlist_mode == WL_MODE_FILE)
17427 {
17428 if (data.dictfile == NULL)
17429 {
17430 if (dictfiles != NULL)
17431 {
17432 data.dictfile = dictfiles[0];
17433
17434 hc_timer_set (&data.timer_running);
17435 }
17436 }
17437 }
17438 }
17439 // NOTE: combi is okay because it is already set beforehand
17440 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17441 {
17442 if (data.dictfile == NULL)
17443 {
17444 if (dictfiles != NULL)
17445 {
17446 hc_timer_set (&data.timer_running);
17447
17448 data.dictfile = dictfiles[0];
17449 }
17450 }
17451 }
17452 else if (attack_mode == ATTACK_MODE_BF)
17453 {
17454 if (data.mask == NULL)
17455 {
17456 hc_timer_set (&data.timer_running);
17457
17458 data.mask = masks[0];
17459 }
17460 }
17461
17462 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17463 {
17464 data.devices_status = STATUS_EXHAUSTED;
17465 }
17466
17467 // if cracked / aborted remove last induction dictionary
17468
17469 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17470 {
17471 struct stat induct_stat;
17472
17473 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17474 {
17475 unlink (induction_dictionaries[file_pos]);
17476 }
17477 }
17478
17479 // wait for non-interactive threads
17480
17481 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17482 {
17483 hc_thread_wait (1, &ni_threads[thread_idx]);
17484 }
17485
17486 local_free (ni_threads);
17487
17488 // wait for interactive threads
17489
17490 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17491 {
17492 hc_thread_wait (1, &i_thread);
17493 }
17494
17495 // we dont need restore file anymore
17496 if (data.restore_disable == 0)
17497 {
17498 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17499 {
17500 unlink (eff_restore_file);
17501 unlink (new_restore_file);
17502 }
17503 else
17504 {
17505 cycle_restore ();
17506 }
17507 }
17508
17509 // finally save left hashes
17510
17511 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17512 {
17513 save_hash ();
17514 }
17515
17516 /**
17517 * Clean up
17518 */
17519
17520 if (benchmark == 1)
17521 {
17522 status_benchmark ();
17523
17524 if (status_automate == 0)
17525 {
17526 log_info ("");
17527 }
17528 }
17529 else
17530 {
17531 if (quiet == 0) clear_prompt ();
17532
17533 if (quiet == 0) log_info ("");
17534
17535 if (status == 1)
17536 {
17537 status_display ();
17538 }
17539 else
17540 {
17541 if (quiet == 0) status_display ();
17542 }
17543
17544 if (quiet == 0) log_info ("");
17545 }
17546
17547 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17548 {
17549 hc_device_param_t *device_param = &data.devices_param[device_id];
17550
17551 if (device_param->skipped) continue;
17552
17553 local_free (device_param->combs_buf);
17554
17555 local_free (device_param->hooks_buf);
17556
17557 local_free (device_param->device_name);
17558
17559 local_free (device_param->device_name_chksum);
17560
17561 local_free (device_param->device_version);
17562
17563 local_free (device_param->driver_version);
17564
17565 if (device_param->pws_buf) myfree (device_param->pws_buf);
17566 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17567 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17568 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17569 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17570 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17571 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17572 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17573 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17574 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17575 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17576 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17577 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17578 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17579 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17580 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17581 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17582 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17583 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17584 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17585 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17586 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17587 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17588 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17589 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17590 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17591 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17592 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17593 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17594
17595 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17596 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17597 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17598 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17599 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17600 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17601 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17602 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17603 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17604 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17605
17606 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17607 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17608 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17609
17610 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17611 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17612 }
17613
17614 // reset default fan speed
17615
17616 #ifdef HAVE_HWMON
17617 if (gpu_temp_disable == 0)
17618 {
17619 #ifdef HAVE_ADL
17620 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17621 {
17622 hc_thread_mutex_lock (mux_adl);
17623
17624 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17625 {
17626 hc_device_param_t *device_param = &data.devices_param[device_id];
17627
17628 if (device_param->skipped) continue;
17629
17630 if (data.hm_device[device_id].fan_supported == 1)
17631 {
17632 int fanspeed = temp_retain_fanspeed_value[device_id];
17633
17634 if (fanspeed == -1) continue;
17635
17636 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17637
17638 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17639 }
17640 }
17641
17642 hc_thread_mutex_unlock (mux_adl);
17643 }
17644 #endif // HAVE_ADL
17645 }
17646
17647 #ifdef HAVE_ADL
17648 // reset power tuning
17649
17650 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17651 {
17652 hc_thread_mutex_lock (mux_adl);
17653
17654 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17655 {
17656 hc_device_param_t *device_param = &data.devices_param[device_id];
17657
17658 if (device_param->skipped) continue;
17659
17660 if (data.hm_device[device_id].od_version == 6)
17661 {
17662 // check powertune capabilities first, if not available then skip device
17663
17664 int powertune_supported = 0;
17665
17666 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17667 {
17668 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17669
17670 return (-1);
17671 }
17672
17673 if (powertune_supported != 0)
17674 {
17675 // powercontrol settings
17676
17677 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK)
17678 {
17679 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17680
17681 return (-1);
17682 }
17683
17684 // clocks
17685
17686 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17687
17688 performance_state->iNumberOfPerformanceLevels = 2;
17689
17690 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17691 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17692 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17693 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17694
17695 if ((hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
17696 {
17697 log_info ("ERROR: Failed to restore ADL performance state");
17698
17699 return (-1);
17700 }
17701
17702 local_free (performance_state);
17703 }
17704 }
17705 }
17706
17707 hc_thread_mutex_unlock (mux_adl);
17708 }
17709 #endif // HAVE_ADL
17710
17711 if (gpu_temp_disable == 0)
17712 {
17713 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17714 if (data.hm_nv)
17715 {
17716 #if defined(LINUX) && defined(HAVE_NVML)
17717
17718 hm_NVML_nvmlShutdown (data.hm_nv);
17719
17720 nvml_close (data.hm_nv);
17721
17722 #elif defined(WIN) && (HAVE_NVAPI)
17723
17724 hm_NvAPI_Unload (data.hm_nv);
17725
17726 nvapi_close (data.hm_nv);
17727
17728 #endif
17729
17730 data.hm_nv = NULL;
17731 }
17732 #endif
17733
17734 #ifdef HAVE_ADL
17735 if (data.hm_amd)
17736 {
17737 hm_ADL_Main_Control_Destroy (data.hm_amd);
17738
17739 adl_close (data.hm_amd);
17740 data.hm_amd = NULL;
17741 }
17742 #endif
17743 }
17744 #endif // HAVE_HWMON
17745
17746 // free memory
17747
17748 local_free (masks);
17749
17750 local_free (dictstat_base);
17751
17752 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17753 {
17754 pot_t *pot_ptr = &pot[pot_pos];
17755
17756 hash_t *hash = &pot_ptr->hash;
17757
17758 local_free (hash->digest);
17759
17760 if (isSalted)
17761 {
17762 local_free (hash->salt);
17763 }
17764 }
17765
17766 local_free (pot);
17767
17768 local_free (all_kernel_rules_cnt);
17769 local_free (all_kernel_rules_buf);
17770
17771 local_free (wl_data->buf);
17772 local_free (wl_data);
17773
17774 local_free (bitmap_s1_a);
17775 local_free (bitmap_s1_b);
17776 local_free (bitmap_s1_c);
17777 local_free (bitmap_s1_d);
17778 local_free (bitmap_s2_a);
17779 local_free (bitmap_s2_b);
17780 local_free (bitmap_s2_c);
17781 local_free (bitmap_s2_d);
17782
17783 #ifdef HAVE_HWMON
17784 local_free (temp_retain_fanspeed_value);
17785 #ifdef HAVE_ADL
17786 local_free (od_clock_mem_status);
17787 local_free (od_power_control_status);
17788 #endif // ADL
17789 #endif
17790
17791 global_free (devices_param);
17792
17793 global_free (kernel_rules_buf);
17794
17795 global_free (root_css_buf);
17796 global_free (markov_css_buf);
17797
17798 global_free (digests_buf);
17799 global_free (digests_shown);
17800 global_free (digests_shown_tmp);
17801
17802 global_free (salts_buf);
17803 global_free (salts_shown);
17804
17805 global_free (esalts_buf);
17806
17807 global_free (words_progress_done);
17808 global_free (words_progress_rejected);
17809 global_free (words_progress_restored);
17810
17811 if (pot_fp) fclose (pot_fp);
17812
17813 if (data.devices_status == STATUS_QUIT) break;
17814 }
17815
17816 // destroy others mutex
17817
17818 hc_thread_mutex_delete (mux_dispatcher);
17819 hc_thread_mutex_delete (mux_counter);
17820 hc_thread_mutex_delete (mux_display);
17821 hc_thread_mutex_delete (mux_adl);
17822
17823 // free memory
17824
17825 local_free (eff_restore_file);
17826 local_free (new_restore_file);
17827
17828 local_free (rd);
17829
17830 // tuning db
17831
17832 tuning_db_destroy (tuning_db);
17833
17834 // loopback
17835
17836 local_free (loopback_file);
17837
17838 if (loopback == 1) unlink (loopback_file);
17839
17840 // induction directory
17841
17842 if (induction_dir == NULL)
17843 {
17844 if (attack_mode != ATTACK_MODE_BF)
17845 {
17846 if (rmdir (induction_directory) == -1)
17847 {
17848 if (errno == ENOENT)
17849 {
17850 // good, we can ignore
17851 }
17852 else if (errno == ENOTEMPTY)
17853 {
17854 // good, we can ignore
17855 }
17856 else
17857 {
17858 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17859
17860 return (-1);
17861 }
17862 }
17863
17864 local_free (induction_directory);
17865 }
17866 }
17867
17868 // outfile-check directory
17869
17870 if (outfile_check_dir == NULL)
17871 {
17872 if (rmdir (outfile_check_directory) == -1)
17873 {
17874 if (errno == ENOENT)
17875 {
17876 // good, we can ignore
17877 }
17878 else if (errno == ENOTEMPTY)
17879 {
17880 // good, we can ignore
17881 }
17882 else
17883 {
17884 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17885
17886 return (-1);
17887 }
17888 }
17889
17890 local_free (outfile_check_directory);
17891 }
17892
17893 time_t proc_stop;
17894
17895 time (&proc_stop);
17896
17897 logfile_top_uint (proc_start);
17898 logfile_top_uint (proc_stop);
17899
17900 logfile_top_msg ("STOP");
17901
17902 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17903 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17904
17905 if (data.ocl) ocl_close (data.ocl);
17906
17907 if (data.devices_status == STATUS_ABORTED) return 2;
17908 if (data.devices_status == STATUS_QUIT) return 2;
17909 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17910 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17911 if (data.devices_status == STATUS_CRACKED) return 0;
17912
17913 return -1;
17914 }
Hashcat additions to support pwdhash