projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Only load ADL or NVML if we really need it
[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 MACHINE_READABLE 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 0
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 " --machine-readable | | 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 " --powertune-enable | | Enable power tuning, restores settings when finished |",
415 #endif
416 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
417 " -s, --skip | Num | Skip X words from the start | -s 1000000",
418 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
419 " --keyspace | | Show keyspace base:mod values and quit |",
420 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
421 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
422 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
423 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
424 " --generate-rules-func-min | Num | Force min X funcs per rule |",
425 " --generate-rules-func-max | Num | Force max X funcs per rule |",
426 " --generate-rules-seed | Num | Force RNG seed set to X |",
427 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
428 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
429 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
430 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
431 " -i, --increment | | Enable mask increment mode |",
432 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
433 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
434 "",
435 "- [ Hash modes ] -",
436 "",
437 " # | Name | Category",
438 " ======+==================================================+======================================",
439 " 900 | MD4 | Raw Hash",
440 " 0 | MD5 | Raw Hash",
441 " 5100 | Half MD5 | Raw Hash",
442 " 100 | SHA1 | Raw Hash",
443 " 10800 | SHA-384 | Raw Hash",
444 " 1400 | SHA-256 | Raw Hash",
445 " 1700 | SHA-512 | Raw Hash",
446 " 5000 | SHA-3(Keccak) | Raw Hash",
447 " 10100 | SipHash | Raw Hash",
448 " 6000 | RipeMD160 | Raw Hash",
449 " 6100 | Whirlpool | Raw Hash",
450 " 6900 | GOST R 34.11-94 | Raw Hash",
451 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
452 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
453 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
454 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
455 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
456 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
457 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
458 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
459 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
460 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
461 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
462 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
463 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
464 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
465 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
466 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
467 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
468 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
469 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
471 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
472 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
473 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
474 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
475 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
476 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
477 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
478 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
479 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
480 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
481 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
482 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
483 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
484 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
485 " 400 | phpass | Generic KDF",
486 " 8900 | scrypt | Generic KDF",
487 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
488 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
489 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
490 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
491 " 23 | Skype | Network protocols",
492 " 2500 | WPA/WPA2 | Network protocols",
493 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
494 " 5300 | IKE-PSK MD5 | Network protocols",
495 " 5400 | IKE-PSK SHA1 | Network protocols",
496 " 5500 | NetNTLMv1 | Network protocols",
497 " 5500 | NetNTLMv1 + ESS | Network protocols",
498 " 5600 | NetNTLMv2 | Network protocols",
499 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
500 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
501 " 8300 | DNSSEC (NSEC3) | Network protocols",
502 " 10200 | Cram MD5 | Network protocols",
503 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
504 " 11200 | MySQL CRAM (SHA1) | Network protocols",
505 " 11400 | SIP digest authentication (MD5) | Network protocols",
506 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
507 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
508 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
509 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
510 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
511 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
512 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
513 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
514 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
515 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
516 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
517 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
518 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
519 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
520 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
521 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
522 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
523 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
524 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
525 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
526 " 12 | PostgreSQL | Database Server",
527 " 131 | MSSQL(2000) | Database Server",
528 " 132 | MSSQL(2005) | Database Server",
529 " 1731 | MSSQL(2012) | Database Server",
530 " 1731 | MSSQL(2014) | Database Server",
531 " 200 | MySQL323 | Database Server",
532 " 300 | MySQL4.1/MySQL5 | Database Server",
533 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
534 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
535 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
536 " 8000 | Sybase ASE | Database Server",
537 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
538 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
539 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
540 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
541 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
542 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
543 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
544 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
545 " 11500 | CRC32 | Checksums",
546 " 3000 | LM | Operating-Systems",
547 " 1000 | NTLM | Operating-Systems",
548 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
549 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
550 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
551 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
552 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
553 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
554 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
555 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
556 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
557 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
558 " 1722 | OSX v10.7 | Operating-Systems",
559 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
560 " 6300 | AIX {smd5} | Operating-Systems",
561 " 6700 | AIX {ssha1} | Operating-Systems",
562 " 6400 | AIX {ssha256} | Operating-Systems",
563 " 6500 | AIX {ssha512} | Operating-Systems",
564 " 2400 | Cisco-PIX | Operating-Systems",
565 " 2410 | Cisco-ASA | Operating-Systems",
566 " 500 | Cisco-IOS $1$ | Operating-Systems",
567 " 5700 | Cisco-IOS $4$ | Operating-Systems",
568 " 9200 | Cisco-IOS $8$ | Operating-Systems",
569 " 9300 | Cisco-IOS $9$ | Operating-Systems",
570 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
571 " 501 | Juniper IVE | Operating-Systems",
572 " 5800 | Android PIN | Operating-Systems",
573 " 8100 | Citrix Netscaler | Operating-Systems",
574 " 8500 | RACF | Operating-Systems",
575 " 7200 | GRUB 2 | Operating-Systems",
576 " 9900 | Radmin2 | Operating-Systems",
577 " 125 | ArubaOS | Operating-Systems",
578 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
579 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
580 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
581 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
582 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
583 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
584 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
585 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
586 " 11600 | 7-Zip | Archives",
587 " 12500 | RAR3-hp | Archives",
588 " 13000 | RAR5 | Archives",
589 " 13200 | AxCrypt | Archives",
590 " 13300 | AxCrypt in memory SHA1 | Archives",
591 " 13600 | WinZip | Archives",
592 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
593 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
594 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
595 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
596 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
597 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
598 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
599 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
600 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
601 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
602 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
603 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
604 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
605 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
606 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
607 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
608 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
609 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
610 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
611 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
612 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
613 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
614 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
615 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
616 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
617 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
618 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
619 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
620 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
621 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
622 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
623 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
624 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
625 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
626 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
627 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
628 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
629 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
630 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
631 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
632 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
633 " 9400 | MS Office 2007 | Documents",
634 " 9500 | MS Office 2010 | Documents",
635 " 9600 | MS Office 2013 | Documents",
636 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
637 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
638 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
639 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
640 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
641 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
642 " 9000 | Password Safe v2 | Password Managers",
643 " 5200 | Password Safe v3 | Password Managers",
644 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
645 " 6600 | 1Password, agilekeychain | Password Managers",
646 " 8200 | 1Password, cloudkeychain | Password Managers",
647 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
648 " 12700 | Blockchain, My Wallet | Password Managers",
649 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
650 "",
651 "- [ Outfile Formats ] -",
652 "",
653 " # | Format",
654 " ===+========",
655 " 1 | hash[:salt]",
656 " 2 | plain",
657 " 3 | hash[:salt]:plain",
658 " 4 | hex_plain",
659 " 5 | hash[:salt]:hex_plain",
660 " 6 | plain:hex_plain",
661 " 7 | hash[:salt]:plain:hex_plain",
662 " 8 | crackpos",
663 " 9 | hash[:salt]:crack_pos",
664 " 10 | plain:crack_pos",
665 " 11 | hash[:salt]:plain:crack_pos",
666 " 12 | hex_plain:crack_pos",
667 " 13 | hash[:salt]:hex_plain:crack_pos",
668 " 14 | plain:hex_plain:crack_pos",
669 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
670 "",
671 "- [ Rule Debugging Modes ] -",
672 "",
673 " # | Format",
674 " ===+========",
675 " 1 | Finding-Rule",
676 " 2 | Original-Word",
677 " 3 | Original-Word:Finding-Rule",
678 " 4 | Original-Word:Finding-Rule:Processed-Word",
679 "",
680 "- [ Attack Modes ] -",
681 "",
682 " # | Mode",
683 " ===+======",
684 " 0 | Straight",
685 " 1 | Combination",
686 " 3 | Brute-force",
687 " 6 | Hybrid Wordlist + Mask",
688 " 7 | Hybrid Mask + Wordlist",
689 "",
690 "- [ Built-in Charsets ] -",
691 "",
692 " ? | Charset",
693 " ===+=========",
694 " l | abcdefghijklmnopqrstuvwxyz",
695 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
696 " d | 0123456789",
697 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
698 " a | ?l?u?d?s",
699 " b | 0x00 - 0xff",
700 "",
701 "- [ OpenCL Device Types ] -",
702 "",
703 " # | Device Type",
704 " ===+=============",
705 " 1 | CPU",
706 " 2 | GPU",
707 " 3 | FPGA, DSP, Co-Processor",
708 "",
709 "- [ Workload Profiles ] -",
710 "",
711 " # | Performance | Runtime | Power Consumption | Desktop Impact",
712 " ===+=============+=========+===================+=================",
713 " 1 | Low | 2 ms | Low | Minimal",
714 " 2 | Default | 12 ms | Economic | Noticeable",
715 " 3 | High | 96 ms | High | Unresponsive",
716 " 4 | Nightmare | 480 ms | Insane | Headless",
717 "",
718 "If you have no idea what just happened then visit the following pages:",
719 "",
720 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
721 "* https://hashcat.net/wiki/#frequently_asked_questions",
722 "",
723 NULL
724 };
725
726 /**
727 * hashcat specific functions
728 */
729
730 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
731 {
732 int exec_pos = (int) device_param->exec_pos - last_num_entries;
733
734 if (exec_pos < 0) exec_pos += EXEC_CACHE;
735
736 double exec_ms_sum = 0;
737
738 int exec_ms_cnt = 0;
739
740 for (int i = 0; i < last_num_entries; i++)
741 {
742 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
743
744 if (exec_ms)
745 {
746 exec_ms_sum += exec_ms;
747
748 exec_ms_cnt++;
749 }
750 }
751
752 if (exec_ms_cnt == 0) return 0;
753
754 return exec_ms_sum / exec_ms_cnt;
755 }
756
757 void status_display_machine_readable ()
758 {
759 FILE *out = stdout;
760
761 fprintf (out, "STATUS\t%u\t", data.devices_status);
762
763 /**
764 * speed new
765 */
766
767 fprintf (out, "SPEED\t");
768
769 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
770 {
771 hc_device_param_t *device_param = &data.devices_param[device_id];
772
773 if (device_param->skipped) continue;
774
775 u64 speed_cnt = 0;
776 double speed_ms = 0;
777
778 for (int i = 0; i < SPEED_CACHE; i++)
779 {
780 speed_cnt += device_param->speed_cnt[i];
781 speed_ms += device_param->speed_ms[i];
782 }
783
784 speed_cnt /= SPEED_CACHE;
785 speed_ms /= SPEED_CACHE;
786
787 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
788 }
789
790 /**
791 * exec time
792 */
793
794 fprintf (out, "EXEC_RUNTIME\t");
795
796 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
797 {
798 hc_device_param_t *device_param = &data.devices_param[device_id];
799
800 if (device_param->skipped) continue;
801
802 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
803
804 fprintf (out, "%f\t", exec_ms_avg);
805 }
806
807 /**
808 * words_cur
809 */
810
811 u64 words_cur = get_lowest_words_done ();
812
813 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
814
815 /**
816 * counter
817 */
818
819 u64 progress_total = data.words_cnt * data.salts_cnt;
820
821 u64 all_done = 0;
822 u64 all_rejected = 0;
823 u64 all_restored = 0;
824
825 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
826 {
827 all_done += data.words_progress_done[salt_pos];
828 all_rejected += data.words_progress_rejected[salt_pos];
829 all_restored += data.words_progress_restored[salt_pos];
830 }
831
832 u64 progress_cur = all_restored + all_done + all_rejected;
833 u64 progress_end = progress_total;
834
835 u64 progress_skip = 0;
836
837 if (data.skip)
838 {
839 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
840
841 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
842 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
843 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
844 }
845
846 if (data.limit)
847 {
848 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
849
850 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
851 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
852 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
853 }
854
855 u64 progress_cur_relative_skip = progress_cur - progress_skip;
856 u64 progress_end_relative_skip = progress_end - progress_skip;
857
858 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
859
860 /**
861 * cracks
862 */
863
864 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
865 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
866
867 /**
868 * temperature
869 */
870
871 #ifdef HAVE_HWMON
872 if (data.gpu_temp_disable == 0)
873 {
874 fprintf (out, "TEMP\t");
875
876 hc_thread_mutex_lock (mux_adl);
877
878 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
879 {
880 hc_device_param_t *device_param = &data.devices_param[device_id];
881
882 if (device_param->skipped) continue;
883
884 int temp = hm_get_temperature_with_device_id (device_id);
885
886 fprintf (out, "%d\t", temp);
887 }
888
889 hc_thread_mutex_unlock (mux_adl);
890 }
891 #endif // HAVE_HWMON
892
893 /**
894 * flush
895 */
896
897 #ifdef _WIN
898 fputc ('\r', out);
899 fputc ('\n', out);
900 #endif
901
902 #ifdef _POSIX
903 fputc ('\n', out);
904 #endif
905
906 fflush (out);
907 }
908
909 void status_display ()
910 {
911 if (data.devices_status == STATUS_INIT) return;
912 if (data.devices_status == STATUS_STARTING) return;
913 if (data.devices_status == STATUS_BYPASS) return;
914
915 if (data.machine_readable == 1)
916 {
917 status_display_machine_readable ();
918
919 return;
920 }
921
922 char tmp_buf[1000] = { 0 };
923
924 uint tmp_len = 0;
925
926 log_info ("Session.Name...: %s", data.session);
927
928 char *status_type = strstatus (data.devices_status);
929
930 uint hash_mode = data.hash_mode;
931
932 char *hash_type = strhashtype (hash_mode); // not a bug
933
934 log_info ("Status.........: %s", status_type);
935
936 /**
937 * show rules
938 */
939
940 if (data.rp_files_cnt)
941 {
942 uint i;
943
944 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
945 {
946 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
947 }
948
949 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
950
951 log_info ("Rules.Type.....: %s", tmp_buf);
952
953 tmp_len = 0;
954 }
955
956 if (data.rp_gen)
957 {
958 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
959
960 if (data.rp_gen_seed)
961 {
962 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
963 }
964 }
965
966 /**
967 * show input
968 */
969
970 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
971 {
972 if (data.wordlist_mode == WL_MODE_FILE)
973 {
974 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
975 }
976 else if (data.wordlist_mode == WL_MODE_STDIN)
977 {
978 log_info ("Input.Mode.....: Pipe");
979 }
980 }
981 else if (data.attack_mode == ATTACK_MODE_COMBI)
982 {
983 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
984 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
985 }
986 else if (data.attack_mode == ATTACK_MODE_BF)
987 {
988 char *mask = data.mask;
989
990 if (mask != NULL)
991 {
992 uint mask_len = data.css_cnt;
993
994 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
995
996 if (mask_len > 0)
997 {
998 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
999 {
1000 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1001 {
1002 mask_len -= data.salts_buf[0].salt_len;
1003 }
1004 }
1005
1006 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1007
1008 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1009 }
1010
1011 if (data.maskcnt > 1)
1012 {
1013 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1014
1015 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1016 }
1017
1018 log_info ("Input.Mode.....: %s", tmp_buf);
1019 }
1020
1021 tmp_len = 0;
1022 }
1023 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1024 {
1025 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1026 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1027 }
1028 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1029 {
1030 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1031 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1032 }
1033
1034 if (data.digests_cnt == 1)
1035 {
1036 if (data.hash_mode == 2500)
1037 {
1038 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1039
1040 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1041 (char *) data.salts_buf[0].salt_buf,
1042 wpa->orig_mac1[0],
1043 wpa->orig_mac1[1],
1044 wpa->orig_mac1[2],
1045 wpa->orig_mac1[3],
1046 wpa->orig_mac1[4],
1047 wpa->orig_mac1[5],
1048 wpa->orig_mac2[0],
1049 wpa->orig_mac2[1],
1050 wpa->orig_mac2[2],
1051 wpa->orig_mac2[3],
1052 wpa->orig_mac2[4],
1053 wpa->orig_mac2[5]);
1054 }
1055 else if (data.hash_mode == 5200)
1056 {
1057 log_info ("Hash.Target....: File (%s)", data.hashfile);
1058 }
1059 else if (data.hash_mode == 9000)
1060 {
1061 log_info ("Hash.Target....: File (%s)", data.hashfile);
1062 }
1063 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1064 {
1065 log_info ("Hash.Target....: File (%s)", data.hashfile);
1066 }
1067 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1068 {
1069 log_info ("Hash.Target....: File (%s)", data.hashfile);
1070 }
1071 else
1072 {
1073 char out_buf[HCBUFSIZ] = { 0 };
1074
1075 ascii_digest (out_buf, 0, 0);
1076
1077 // limit length
1078 if (strlen (out_buf) > 40)
1079 {
1080 out_buf[41] = '.';
1081 out_buf[42] = '.';
1082 out_buf[43] = '.';
1083 out_buf[44] = 0;
1084 }
1085
1086 log_info ("Hash.Target....: %s", out_buf);
1087 }
1088 }
1089 else
1090 {
1091 if (data.hash_mode == 3000)
1092 {
1093 char out_buf1[32] = { 0 };
1094 char out_buf2[32] = { 0 };
1095
1096 ascii_digest (out_buf1, 0, 0);
1097 ascii_digest (out_buf2, 0, 1);
1098
1099 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1100 }
1101 else
1102 {
1103 log_info ("Hash.Target....: File (%s)", data.hashfile);
1104 }
1105 }
1106
1107 log_info ("Hash.Type......: %s", hash_type);
1108
1109 /**
1110 * speed new
1111 */
1112
1113 u64 speed_cnt[DEVICES_MAX] = { 0 };
1114 double speed_ms[DEVICES_MAX] = { 0 };
1115
1116 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1117 {
1118 hc_device_param_t *device_param = &data.devices_param[device_id];
1119
1120 if (device_param->skipped) continue;
1121
1122 speed_cnt[device_id] = 0;
1123 speed_ms[device_id] = 0;
1124
1125 for (int i = 0; i < SPEED_CACHE; i++)
1126 {
1127 speed_cnt[device_id] += device_param->speed_cnt[i];
1128 speed_ms[device_id] += device_param->speed_ms[i];
1129 }
1130
1131 speed_cnt[device_id] /= SPEED_CACHE;
1132 speed_ms[device_id] /= SPEED_CACHE;
1133 }
1134
1135 double hashes_all_ms = 0;
1136
1137 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1138
1139 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1140 {
1141 hc_device_param_t *device_param = &data.devices_param[device_id];
1142
1143 if (device_param->skipped) continue;
1144
1145 hashes_dev_ms[device_id] = 0;
1146
1147 if (speed_ms[device_id])
1148 {
1149 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1150
1151 hashes_all_ms += hashes_dev_ms[device_id];
1152 }
1153 }
1154
1155 /**
1156 * exec time
1157 */
1158
1159 double exec_all_ms[DEVICES_MAX] = { 0 };
1160
1161 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1162 {
1163 hc_device_param_t *device_param = &data.devices_param[device_id];
1164
1165 if (device_param->skipped) continue;
1166
1167 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1168
1169 exec_all_ms[device_id] = exec_ms_avg;
1170 }
1171
1172 /**
1173 * timers
1174 */
1175
1176 double ms_running = 0;
1177
1178 hc_timer_get (data.timer_running, ms_running);
1179
1180 double ms_paused = data.ms_paused;
1181
1182 if (data.devices_status == STATUS_PAUSED)
1183 {
1184 double ms_paused_tmp = 0;
1185
1186 hc_timer_get (data.timer_paused, ms_paused_tmp);
1187
1188 ms_paused += ms_paused_tmp;
1189 }
1190
1191 #ifdef WIN
1192
1193 __time64_t sec_run = ms_running / 1000;
1194
1195 #else
1196
1197 time_t sec_run = ms_running / 1000;
1198
1199 #endif
1200
1201 if (sec_run)
1202 {
1203 char display_run[32] = { 0 };
1204
1205 struct tm tm_run;
1206
1207 struct tm *tmp = NULL;
1208
1209 #ifdef WIN
1210
1211 tmp = _gmtime64 (&sec_run);
1212
1213 #else
1214
1215 tmp = gmtime (&sec_run);
1216
1217 #endif
1218
1219 if (tmp != NULL)
1220 {
1221 memset (&tm_run, 0, sizeof (tm_run));
1222
1223 memcpy (&tm_run, tmp, sizeof (tm_run));
1224
1225 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1226
1227 char *start = ctime (&data.proc_start);
1228
1229 size_t start_len = strlen (start);
1230
1231 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1232 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1233
1234 log_info ("Time.Started...: %s (%s)", start, display_run);
1235 }
1236 }
1237 else
1238 {
1239 log_info ("Time.Started...: 0 secs");
1240 }
1241
1242 /**
1243 * counters
1244 */
1245
1246 u64 progress_total = data.words_cnt * data.salts_cnt;
1247
1248 u64 all_done = 0;
1249 u64 all_rejected = 0;
1250 u64 all_restored = 0;
1251
1252 u64 progress_noneed = 0;
1253
1254 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1255 {
1256 all_done += data.words_progress_done[salt_pos];
1257 all_rejected += data.words_progress_rejected[salt_pos];
1258 all_restored += data.words_progress_restored[salt_pos];
1259
1260 // Important for ETA only
1261
1262 if (data.salts_shown[salt_pos] == 1)
1263 {
1264 const u64 all = data.words_progress_done[salt_pos]
1265 + data.words_progress_rejected[salt_pos]
1266 + data.words_progress_restored[salt_pos];
1267
1268 const u64 left = data.words_cnt - all;
1269
1270 progress_noneed += left;
1271 }
1272 }
1273
1274 u64 progress_cur = all_restored + all_done + all_rejected;
1275 u64 progress_end = progress_total;
1276
1277 u64 progress_skip = 0;
1278
1279 if (data.skip)
1280 {
1281 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1282
1283 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1284 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1285 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1286 }
1287
1288 if (data.limit)
1289 {
1290 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1291
1292 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1293 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1294 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1295 }
1296
1297 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1298 u64 progress_end_relative_skip = progress_end - progress_skip;
1299
1300 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1301 {
1302 if (data.devices_status != STATUS_CRACKED)
1303 {
1304 #ifdef WIN
1305 __time64_t sec_etc = 0;
1306 #else
1307 time_t sec_etc = 0;
1308 #endif
1309
1310 if (hashes_all_ms)
1311 {
1312 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1313
1314 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1315
1316 sec_etc = ms_left / 1000;
1317 }
1318
1319 if (sec_etc == 0)
1320 {
1321 //log_info ("Time.Estimated.: 0 secs");
1322 }
1323 else if ((u64) sec_etc > ETC_MAX)
1324 {
1325 log_info ("Time.Estimated.: > 10 Years");
1326 }
1327 else
1328 {
1329 char display_etc[32] = { 0 };
1330
1331 struct tm tm_etc;
1332
1333 struct tm *tmp = NULL;
1334
1335 #ifdef WIN
1336
1337 tmp = _gmtime64 (&sec_etc);
1338
1339 #else
1340
1341 tmp = gmtime (&sec_etc);
1342
1343 #endif
1344
1345 if (tmp != NULL)
1346 {
1347 memset (&tm_etc, 0, sizeof (tm_etc));
1348
1349 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1350
1351 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1352
1353 time_t now;
1354
1355 time (&now);
1356
1357 now += sec_etc;
1358
1359 char *etc = ctime (&now);
1360
1361 size_t etc_len = strlen (etc);
1362
1363 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1364 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1365
1366 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1367 }
1368 }
1369 }
1370 }
1371
1372 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1373 {
1374 hc_device_param_t *device_param = &data.devices_param[device_id];
1375
1376 if (device_param->skipped) continue;
1377
1378 char display_dev_cur[16] = { 0 };
1379
1380 strncpy (display_dev_cur, "0.00", 4);
1381
1382 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1383
1384 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1385 }
1386
1387 char display_all_cur[16] = { 0 };
1388
1389 strncpy (display_all_cur, "0.00", 4);
1390
1391 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1392
1393 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1394
1395 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1396 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1397
1398 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);
1399
1400 // crack-per-time
1401
1402 if (data.digests_cnt > 100)
1403 {
1404 time_t now = time (NULL);
1405
1406 int cpt_cur_min = 0;
1407 int cpt_cur_hour = 0;
1408 int cpt_cur_day = 0;
1409
1410 for (int i = 0; i < CPT_BUF; i++)
1411 {
1412 const uint cracked = data.cpt_buf[i].cracked;
1413 const time_t timestamp = data.cpt_buf[i].timestamp;
1414
1415 if ((timestamp + 60) > now)
1416 {
1417 cpt_cur_min += cracked;
1418 }
1419
1420 if ((timestamp + 3600) > now)
1421 {
1422 cpt_cur_hour += cracked;
1423 }
1424
1425 if ((timestamp + 86400) > now)
1426 {
1427 cpt_cur_day += cracked;
1428 }
1429 }
1430
1431 double ms_real = ms_running - ms_paused;
1432
1433 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1434 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1435 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1436
1437 if ((data.cpt_start + 86400) < now)
1438 {
1439 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1440 cpt_cur_min,
1441 cpt_cur_hour,
1442 cpt_cur_day,
1443 cpt_avg_min,
1444 cpt_avg_hour,
1445 cpt_avg_day);
1446 }
1447 else if ((data.cpt_start + 3600) < now)
1448 {
1449 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1450 cpt_cur_min,
1451 cpt_cur_hour,
1452 cpt_avg_min,
1453 cpt_avg_hour,
1454 cpt_avg_day);
1455 }
1456 else if ((data.cpt_start + 60) < now)
1457 {
1458 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1459 cpt_cur_min,
1460 cpt_avg_min,
1461 cpt_avg_hour,
1462 cpt_avg_day);
1463 }
1464 else
1465 {
1466 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1467 cpt_avg_min,
1468 cpt_avg_hour,
1469 cpt_avg_day);
1470 }
1471 }
1472
1473 // Restore point
1474
1475 u64 restore_point = get_lowest_words_done ();
1476
1477 u64 restore_total = data.words_base;
1478
1479 float percent_restore = 0;
1480
1481 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1482
1483 if (progress_end_relative_skip)
1484 {
1485 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1486 {
1487 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1488 float percent_rejected = 0.0;
1489
1490 if (progress_cur)
1491 {
1492 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1493 }
1494
1495 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);
1496 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1497
1498 if (data.restore_disable == 0)
1499 {
1500 if (percent_finished != 1)
1501 {
1502 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1503 }
1504 }
1505 }
1506 }
1507 else
1508 {
1509 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1510 {
1511 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1512 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1513
1514 if (data.restore_disable == 0)
1515 {
1516 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1517 }
1518 }
1519 else
1520 {
1521 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1522 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1523
1524 // --restore not allowed if stdin is used -- really? why?
1525
1526 //if (data.restore_disable == 0)
1527 //{
1528 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1529 //}
1530 }
1531 }
1532
1533 #ifdef HAVE_HWMON
1534 if (data.gpu_temp_disable == 0)
1535 {
1536 hc_thread_mutex_lock (mux_adl);
1537
1538 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1539 {
1540 hc_device_param_t *device_param = &data.devices_param[device_id];
1541
1542 if (device_param->skipped) continue;
1543
1544 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1545 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1546 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1547 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1548 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1549 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1550 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1551
1552 char output_buf[256] = { 0 };
1553
1554 int output_len = 0;
1555
1556 if (num_temperature >= 0)
1557 {
1558 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1559
1560 output_len = strlen (output_buf);
1561 }
1562
1563 if (num_fanspeed >= 0)
1564 {
1565 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1566
1567 output_len = strlen (output_buf);
1568 }
1569
1570 if (num_utilization >= 0)
1571 {
1572 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1573
1574 output_len = strlen (output_buf);
1575 }
1576
1577 if (num_corespeed >= 0)
1578 {
1579 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1580
1581 output_len = strlen (output_buf);
1582 }
1583
1584 if (num_memoryspeed >= 0)
1585 {
1586 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1587
1588 output_len = strlen (output_buf);
1589 }
1590
1591 if (num_buslanes >= 0)
1592 {
1593 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1594
1595 output_len = strlen (output_buf);
1596 }
1597
1598 if (num_throttle == 1)
1599 {
1600 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1601
1602 output_len = strlen (output_buf);
1603 }
1604
1605 if (output_len == 0)
1606 {
1607 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1608
1609 output_len = strlen (output_buf);
1610 }
1611
1612 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1613 }
1614
1615 hc_thread_mutex_unlock (mux_adl);
1616 }
1617 #endif // HAVE_HWMON
1618 }
1619
1620 static void status_benchmark_automate ()
1621 {
1622 u64 speed_cnt[DEVICES_MAX] = { 0 };
1623 double speed_ms[DEVICES_MAX] = { 0 };
1624
1625 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1626 {
1627 hc_device_param_t *device_param = &data.devices_param[device_id];
1628
1629 if (device_param->skipped) continue;
1630
1631 speed_cnt[device_id] = device_param->speed_cnt[0];
1632 speed_ms[device_id] = device_param->speed_ms[0];
1633 }
1634
1635 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1636
1637 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1638 {
1639 hc_device_param_t *device_param = &data.devices_param[device_id];
1640
1641 if (device_param->skipped) continue;
1642
1643 hashes_dev_ms[device_id] = 0;
1644
1645 if (speed_ms[device_id])
1646 {
1647 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1648 }
1649 }
1650
1651 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1652 {
1653 hc_device_param_t *device_param = &data.devices_param[device_id];
1654
1655 if (device_param->skipped) continue;
1656
1657 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1658 }
1659 }
1660
1661 static void status_benchmark ()
1662 {
1663 if (data.devices_status == STATUS_INIT) return;
1664 if (data.devices_status == STATUS_STARTING) return;
1665 if (data.devices_status == STATUS_BYPASS) return;
1666
1667 if (data.machine_readable == 1)
1668 {
1669 status_benchmark_automate ();
1670
1671 return;
1672 }
1673
1674 u64 speed_cnt[DEVICES_MAX] = { 0 };
1675 double speed_ms[DEVICES_MAX] = { 0 };
1676
1677 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1678 {
1679 hc_device_param_t *device_param = &data.devices_param[device_id];
1680
1681 if (device_param->skipped) continue;
1682
1683 speed_cnt[device_id] = device_param->speed_cnt[0];
1684 speed_ms[device_id] = device_param->speed_ms[0];
1685 }
1686
1687 double hashes_all_ms = 0;
1688
1689 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1690
1691 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1692 {
1693 hc_device_param_t *device_param = &data.devices_param[device_id];
1694
1695 if (device_param->skipped) continue;
1696
1697 hashes_dev_ms[device_id] = 0;
1698
1699 if (speed_ms[device_id])
1700 {
1701 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1702
1703 hashes_all_ms += hashes_dev_ms[device_id];
1704 }
1705 }
1706
1707 /**
1708 * exec time
1709 */
1710
1711 double exec_all_ms[DEVICES_MAX] = { 0 };
1712
1713 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1714 {
1715 hc_device_param_t *device_param = &data.devices_param[device_id];
1716
1717 if (device_param->skipped) continue;
1718
1719 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1720
1721 exec_all_ms[device_id] = exec_ms_avg;
1722 }
1723
1724 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1725 {
1726 hc_device_param_t *device_param = &data.devices_param[device_id];
1727
1728 if (device_param->skipped) continue;
1729
1730 char display_dev_cur[16] = { 0 };
1731
1732 strncpy (display_dev_cur, "0.00", 4);
1733
1734 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1735
1736 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1737 }
1738
1739 char display_all_cur[16] = { 0 };
1740
1741 strncpy (display_all_cur, "0.00", 4);
1742
1743 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1744
1745 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1746 }
1747
1748 /**
1749 * hashcat -only- functions
1750 */
1751
1752 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1753 {
1754 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1755 {
1756 if (attack_kern == ATTACK_KERN_STRAIGHT)
1757 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1758 else if (attack_kern == ATTACK_KERN_COMBI)
1759 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1760 else if (attack_kern == ATTACK_KERN_BF)
1761 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1762 }
1763 else
1764 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1765 }
1766
1767 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)
1768 {
1769 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1770 {
1771 if (attack_kern == ATTACK_KERN_STRAIGHT)
1772 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1773 else if (attack_kern == ATTACK_KERN_COMBI)
1774 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1775 else if (attack_kern == ATTACK_KERN_BF)
1776 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1777 }
1778 else
1779 {
1780 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1781 }
1782 }
1783
1784 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1785 {
1786 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1787 {
1788 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1789 }
1790 else
1791 {
1792 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1793 }
1794 }
1795
1796 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)
1797 {
1798 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1799 {
1800 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1801 }
1802 else
1803 {
1804 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1805 }
1806 }
1807
1808 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1809 {
1810 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1811 }
1812
1813 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1814 {
1815 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1816 }
1817
1818 static uint convert_from_hex (char *line_buf, const uint line_len)
1819 {
1820 if (line_len & 1) return (line_len); // not in hex
1821
1822 if (data.hex_wordlist == 1)
1823 {
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836 else if (line_len >= 6) // $HEX[] = 6
1837 {
1838 if (line_buf[0] != '$') return (line_len);
1839 if (line_buf[1] != 'H') return (line_len);
1840 if (line_buf[2] != 'E') return (line_len);
1841 if (line_buf[3] != 'X') return (line_len);
1842 if (line_buf[4] != '[') return (line_len);
1843 if (line_buf[line_len - 1] != ']') return (line_len);
1844
1845 uint i;
1846 uint j;
1847
1848 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1849 {
1850 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1851 }
1852
1853 memset (line_buf + i, 0, line_len - i);
1854
1855 return (i);
1856 }
1857
1858 return (line_len);
1859 }
1860
1861 static void clear_prompt ()
1862 {
1863 fputc ('\r', stdout);
1864
1865 for (size_t i = 0; i < strlen (PROMPT); i++)
1866 {
1867 fputc (' ', stdout);
1868 }
1869
1870 fputc ('\r', stdout);
1871
1872 fflush (stdout);
1873 }
1874
1875 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1876 {
1877 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);
1878 }
1879
1880 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1881 {
1882 char *outfile = data.outfile;
1883 uint quiet = data.quiet;
1884 FILE *pot_fp = data.pot_fp;
1885 uint loopback = data.loopback;
1886 uint debug_mode = data.debug_mode;
1887 char *debug_file = data.debug_file;
1888
1889 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1890 int debug_rule_len = 0; // -1 error
1891 uint debug_plain_len = 0;
1892
1893 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1894
1895 // hash
1896
1897 char out_buf[HCBUFSIZ] = { 0 };
1898
1899 const u32 salt_pos = plain->salt_pos;
1900 const u32 digest_pos = plain->digest_pos; // relative
1901 const u32 gidvid = plain->gidvid;
1902 const u32 il_pos = plain->il_pos;
1903
1904 ascii_digest (out_buf, salt_pos, digest_pos);
1905
1906 // plain
1907
1908 u64 crackpos = device_param->words_off;
1909
1910 uint plain_buf[16] = { 0 };
1911
1912 u8 *plain_ptr = (u8 *) plain_buf;
1913
1914 unsigned int plain_len = 0;
1915
1916 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1917 {
1918 pw_t pw;
1919
1920 gidd_to_pw_t (device_param, gidvid, &pw);
1921
1922 for (int i = 0; i < 16; i++)
1923 {
1924 plain_buf[i] = pw.i[i];
1925 }
1926
1927 plain_len = pw.pw_len;
1928
1929 const uint off = device_param->innerloop_pos + il_pos;
1930
1931 if (debug_mode > 0)
1932 {
1933 debug_rule_len = 0;
1934
1935 // save rule
1936 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1937 {
1938 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1939
1940 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1941 }
1942
1943 // save plain
1944 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1945 {
1946 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1947
1948 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1949
1950 debug_plain_len = plain_len;
1951 }
1952 }
1953
1954 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1955
1956 crackpos += gidvid;
1957 crackpos *= data.kernel_rules_cnt;
1958 crackpos += device_param->innerloop_pos + il_pos;
1959
1960 if (plain_len > data.pw_max) plain_len = data.pw_max;
1961 }
1962 else if (data.attack_mode == ATTACK_MODE_COMBI)
1963 {
1964 pw_t pw;
1965
1966 gidd_to_pw_t (device_param, gidvid, &pw);
1967
1968 for (int i = 0; i < 16; i++)
1969 {
1970 plain_buf[i] = pw.i[i];
1971 }
1972
1973 plain_len = pw.pw_len;
1974
1975 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1976 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1977
1978 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1979 {
1980 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1981 }
1982 else
1983 {
1984 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1985
1986 memcpy (plain_ptr, comb_buf, comb_len);
1987 }
1988
1989 plain_len += comb_len;
1990
1991 crackpos += gidvid;
1992 crackpos *= data.combs_cnt;
1993 crackpos += device_param->innerloop_pos + il_pos;
1994
1995 if (data.pw_max != PW_DICTMAX1)
1996 {
1997 if (plain_len > data.pw_max) plain_len = data.pw_max;
1998 }
1999 }
2000 else if (data.attack_mode == ATTACK_MODE_BF)
2001 {
2002 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2003 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2004
2005 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2006 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2007
2008 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2009 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2010
2011 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2012 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2013
2014 plain_len = data.css_cnt;
2015
2016 crackpos += gidvid;
2017 crackpos *= data.bfs_cnt;
2018 crackpos += device_param->innerloop_pos + il_pos;
2019 }
2020 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2021 {
2022 pw_t pw;
2023
2024 gidd_to_pw_t (device_param, gidvid, &pw);
2025
2026 for (int i = 0; i < 16; i++)
2027 {
2028 plain_buf[i] = pw.i[i];
2029 }
2030
2031 plain_len = pw.pw_len;
2032
2033 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2034
2035 uint start = 0;
2036 uint stop = device_param->kernel_params_mp_buf32[4];
2037
2038 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2039
2040 plain_len += start + stop;
2041
2042 crackpos += gidvid;
2043 crackpos *= data.combs_cnt;
2044 crackpos += device_param->innerloop_pos + il_pos;
2045
2046 if (data.pw_max != PW_DICTMAX1)
2047 {
2048 if (plain_len > data.pw_max) plain_len = data.pw_max;
2049 }
2050 }
2051 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2052 {
2053 pw_t pw;
2054
2055 gidd_to_pw_t (device_param, gidvid, &pw);
2056
2057 for (int i = 0; i < 16; i++)
2058 {
2059 plain_buf[i] = pw.i[i];
2060 }
2061
2062 plain_len = pw.pw_len;
2063
2064 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2065
2066 uint start = 0;
2067 uint stop = device_param->kernel_params_mp_buf32[4];
2068
2069 memmove (plain_ptr + stop, plain_ptr, plain_len);
2070
2071 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2072
2073 plain_len += start + stop;
2074
2075 crackpos += gidvid;
2076 crackpos *= data.combs_cnt;
2077 crackpos += device_param->innerloop_pos + il_pos;
2078
2079 if (data.pw_max != PW_DICTMAX1)
2080 {
2081 if (plain_len > data.pw_max) plain_len = data.pw_max;
2082 }
2083 }
2084
2085 if (data.attack_mode == ATTACK_MODE_BF)
2086 {
2087 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2088 {
2089 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2090 {
2091 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2092 {
2093 plain_len = plain_len - data.salts_buf[0].salt_len;
2094 }
2095 }
2096
2097 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2098 {
2099 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2100 {
2101 plain_ptr[j] = plain_ptr[i];
2102 }
2103
2104 plain_len = plain_len / 2;
2105 }
2106 }
2107 }
2108
2109 // if enabled, update also the potfile
2110
2111 if (pot_fp)
2112 {
2113 lock_file (pot_fp);
2114
2115 fprintf (pot_fp, "%s:", out_buf);
2116
2117 format_plain (pot_fp, plain_ptr, plain_len, 1);
2118
2119 fputc ('\n', pot_fp);
2120
2121 fflush (pot_fp);
2122
2123 unlock_file (pot_fp);
2124 }
2125
2126 // outfile
2127
2128 FILE *out_fp = NULL;
2129
2130 if (outfile != NULL)
2131 {
2132 if ((out_fp = fopen (outfile, "ab")) == NULL)
2133 {
2134 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2135
2136 out_fp = stdout;
2137 }
2138
2139 lock_file (out_fp);
2140 }
2141 else
2142 {
2143 out_fp = stdout;
2144
2145 if (quiet == 0) clear_prompt ();
2146 }
2147
2148 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2149
2150 if (outfile != NULL)
2151 {
2152 if (out_fp != stdout)
2153 {
2154 fclose (out_fp);
2155 }
2156 }
2157 else
2158 {
2159 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2160 {
2161 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2162 {
2163 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2164 if (quiet == 0) fflush (stdout);
2165 }
2166 }
2167 }
2168
2169 // loopback
2170
2171 if (loopback)
2172 {
2173 char *loopback_file = data.loopback_file;
2174
2175 FILE *fb_fp = NULL;
2176
2177 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2178 {
2179 lock_file (fb_fp);
2180
2181 format_plain (fb_fp, plain_ptr, plain_len, 1);
2182
2183 fputc ('\n', fb_fp);
2184
2185 fclose (fb_fp);
2186 }
2187 }
2188
2189 // (rule) debug mode
2190
2191 // the next check implies that:
2192 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2193 // - debug_mode > 0
2194
2195 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2196 {
2197 if (debug_rule_len < 0) debug_rule_len = 0;
2198
2199 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2200
2201 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2202
2203 if ((quiet == 0) && (debug_file == NULL))
2204 {
2205 fprintf (stdout, "%s", PROMPT);
2206
2207 fflush (stdout);
2208 }
2209 }
2210 }
2211
2212 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2213 {
2214 salt_t *salt_buf = &data.salts_buf[salt_pos];
2215
2216 u32 num_cracked;
2217
2218 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2219
2220 if (num_cracked)
2221 {
2222 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2223
2224 log_info_nn ("");
2225
2226 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2227
2228 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);
2229
2230 uint cpt_cracked = 0;
2231
2232 for (uint i = 0; i < num_cracked; i++)
2233 {
2234 const uint hash_pos = cracked[i].hash_pos;
2235
2236 if (data.digests_shown[hash_pos] == 1) continue;
2237
2238 hc_thread_mutex_lock (mux_display);
2239
2240 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2241 {
2242 data.digests_shown[hash_pos] = 1;
2243
2244 data.digests_done++;
2245
2246 cpt_cracked++;
2247
2248 salt_buf->digests_done++;
2249
2250 if (salt_buf->digests_done == salt_buf->digests_cnt)
2251 {
2252 data.salts_shown[salt_pos] = 1;
2253
2254 data.salts_done++;
2255 }
2256 }
2257
2258 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2259
2260 hc_thread_mutex_unlock (mux_display);
2261
2262 check_hash (device_param, &cracked[i]);
2263 }
2264
2265 myfree (cracked);
2266
2267 if (cpt_cracked > 0)
2268 {
2269 hc_thread_mutex_lock (mux_display);
2270
2271 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2272 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2273
2274 data.cpt_pos++;
2275
2276 data.cpt_total += cpt_cracked;
2277
2278 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2279
2280 hc_thread_mutex_unlock (mux_display);
2281 }
2282
2283 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2284 {
2285 // we need to reset cracked state on the device
2286 // otherwise host thinks again and again the hash was cracked
2287 // and returns invalid password each time
2288
2289 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2290
2291 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);
2292 }
2293
2294 num_cracked = 0;
2295
2296 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2297 }
2298 }
2299
2300 static void save_hash ()
2301 {
2302 char *hashfile = data.hashfile;
2303
2304 char new_hashfile[256] = { 0 };
2305 char old_hashfile[256] = { 0 };
2306
2307 snprintf (new_hashfile, 255, "%s.new", hashfile);
2308 snprintf (old_hashfile, 255, "%s.old", hashfile);
2309
2310 unlink (new_hashfile);
2311
2312 char separator = data.separator;
2313
2314 FILE *fp = fopen (new_hashfile, "wb");
2315
2316 if (fp == NULL)
2317 {
2318 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2319
2320 exit (-1);
2321 }
2322
2323 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2324 {
2325 if (data.salts_shown[salt_pos] == 1) continue;
2326
2327 salt_t *salt_buf = &data.salts_buf[salt_pos];
2328
2329 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2330 {
2331 uint idx = salt_buf->digests_offset + digest_pos;
2332
2333 if (data.digests_shown[idx] == 1) continue;
2334
2335 if (data.hash_mode != 2500)
2336 {
2337 char out_buf[HCBUFSIZ] = { 0 };
2338
2339 if (data.username == 1)
2340 {
2341 user_t *user = data.hash_info[idx]->user;
2342
2343 uint i;
2344
2345 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2346
2347 fputc (separator, fp);
2348 }
2349
2350 ascii_digest (out_buf, salt_pos, digest_pos);
2351
2352 fputs (out_buf, fp);
2353
2354 log_out (fp, "");
2355 }
2356 else
2357 {
2358 hccap_t hccap;
2359
2360 to_hccap_t (&hccap, salt_pos, digest_pos);
2361
2362 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2363 }
2364 }
2365 }
2366
2367 fflush (fp);
2368
2369 fclose (fp);
2370
2371 unlink (old_hashfile);
2372
2373 if (rename (hashfile, old_hashfile) != 0)
2374 {
2375 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2376
2377 exit (-1);
2378 }
2379
2380 unlink (hashfile);
2381
2382 if (rename (new_hashfile, hashfile) != 0)
2383 {
2384 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2385
2386 exit (-1);
2387 }
2388
2389 unlink (old_hashfile);
2390 }
2391
2392 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2393 {
2394 // function called only in case kernel_power_all > words_left
2395
2396 float kernel_power_div = (float) (total_left) / kernel_power_all;
2397
2398 kernel_power_div += kernel_power_div / 100;
2399
2400 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2401
2402 while (kernel_power_new < total_left)
2403 {
2404 kernel_power_div += kernel_power_div / 100;
2405
2406 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2407 }
2408
2409 if (data.quiet == 0)
2410 {
2411 clear_prompt ();
2412
2413 //log_info ("");
2414
2415 log_info ("INFO: approaching final keyspace, workload adjusted");
2416 log_info ("");
2417
2418 fprintf (stdout, "%s", PROMPT);
2419
2420 fflush (stdout);
2421 }
2422
2423 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2424
2425 return kernel_power_div;
2426 }
2427
2428 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2429 {
2430 uint num_elements = num;
2431
2432 device_param->kernel_params_buf32[30] = data.combs_mode;
2433 device_param->kernel_params_buf32[31] = num;
2434
2435 uint kernel_threads = device_param->kernel_threads;
2436
2437 while (num_elements % kernel_threads) num_elements++;
2438
2439 cl_kernel kernel = NULL;
2440
2441 switch (kern_run)
2442 {
2443 case KERN_RUN_1: kernel = device_param->kernel1; break;
2444 case KERN_RUN_12: kernel = device_param->kernel12; break;
2445 case KERN_RUN_2: kernel = device_param->kernel2; break;
2446 case KERN_RUN_23: kernel = device_param->kernel23; break;
2447 case KERN_RUN_3: kernel = device_param->kernel3; break;
2448 }
2449
2450 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2451 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2452 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2453 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2454 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2455 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2456 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2457 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2458 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2459 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2460 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2461
2462 cl_event event;
2463
2464 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2465 {
2466 const size_t global_work_size[3] = { num_elements, 32, 1 };
2467 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2470 }
2471 else
2472 {
2473 if (kern_run == KERN_RUN_2)
2474 {
2475 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2476 {
2477 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2478 }
2479 }
2480
2481 while (num_elements % kernel_threads) num_elements++;
2482
2483 const size_t global_work_size[3] = { num_elements, 1, 1 };
2484 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2485
2486 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2487 }
2488
2489 hc_clFlush (data.ocl, device_param->command_queue);
2490
2491 hc_clWaitForEvents (data.ocl, 1, &event);
2492
2493 if (event_update)
2494 {
2495 cl_ulong time_start;
2496 cl_ulong time_end;
2497
2498 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2499 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2500
2501 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2502
2503 uint exec_pos = device_param->exec_pos;
2504
2505 device_param->exec_ms[exec_pos] = exec_time;
2506
2507 exec_pos++;
2508
2509 if (exec_pos == EXEC_CACHE)
2510 {
2511 exec_pos = 0;
2512 }
2513
2514 device_param->exec_pos = exec_pos;
2515 }
2516
2517 hc_clReleaseEvent (data.ocl, event);
2518
2519 hc_clFinish (data.ocl, device_param->command_queue);
2520 }
2521
2522 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2523 {
2524 uint num_elements = num;
2525
2526 switch (kern_run)
2527 {
2528 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2529 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2530 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2531 }
2532
2533 // causes problems with special threads like in bcrypt
2534 // const uint kernel_threads = device_param->kernel_threads;
2535
2536 uint kernel_threads = device_param->kernel_threads;
2537
2538 while (num_elements % kernel_threads) num_elements++;
2539
2540 cl_kernel kernel = NULL;
2541
2542 switch (kern_run)
2543 {
2544 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2545 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2546 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2547 }
2548
2549 switch (kern_run)
2550 {
2551 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2552 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2553 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2554 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2555 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2556 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2557 break;
2558 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2559 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2560 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2561 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2562 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2563 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2564 break;
2565 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2566 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2567 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2568 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2569 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2570 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2571 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2572 break;
2573 }
2574
2575 const size_t global_work_size[3] = { num_elements, 1, 1 };
2576 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2577
2578 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2579
2580 hc_clFlush (data.ocl, device_param->command_queue);
2581
2582 hc_clFinish (data.ocl, device_param->command_queue);
2583 }
2584
2585 static void run_kernel_tm (hc_device_param_t *device_param)
2586 {
2587 const uint num_elements = 1024; // fixed
2588
2589 uint kernel_threads = 32;
2590
2591 cl_kernel kernel = device_param->kernel_tm;
2592
2593 const size_t global_work_size[3] = { num_elements, 1, 1 };
2594 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2595
2596 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2597
2598 hc_clFlush (data.ocl, device_param->command_queue);
2599
2600 hc_clFinish (data.ocl, device_param->command_queue);
2601 }
2602
2603 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2604 {
2605 uint num_elements = num;
2606
2607 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2608 device_param->kernel_params_amp_buf32[6] = num_elements;
2609
2610 // causes problems with special threads like in bcrypt
2611 // const uint kernel_threads = device_param->kernel_threads;
2612
2613 uint kernel_threads = device_param->kernel_threads;
2614
2615 while (num_elements % kernel_threads) num_elements++;
2616
2617 cl_kernel kernel = device_param->kernel_amp;
2618
2619 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2620 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2621
2622 const size_t global_work_size[3] = { num_elements, 1, 1 };
2623 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2624
2625 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2626
2627 hc_clFlush (data.ocl, device_param->command_queue);
2628
2629 hc_clFinish (data.ocl, device_param->command_queue);
2630 }
2631
2632 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2633 {
2634 const u32 num16d = num / 16;
2635 const u32 num16m = num % 16;
2636
2637 if (num16d)
2638 {
2639 device_param->kernel_params_memset_buf32[1] = value;
2640 device_param->kernel_params_memset_buf32[2] = num16d;
2641
2642 uint kernel_threads = device_param->kernel_threads;
2643
2644 uint num_elements = num16d;
2645
2646 while (num_elements % kernel_threads) num_elements++;
2647
2648 cl_kernel kernel = device_param->kernel_memset;
2649
2650 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2651 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2652 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2653
2654 const size_t global_work_size[3] = { num_elements, 1, 1 };
2655 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2656
2657 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2658
2659 hc_clFlush (data.ocl, device_param->command_queue);
2660
2661 hc_clFinish (data.ocl, device_param->command_queue);
2662 }
2663
2664 if (num16m)
2665 {
2666 u32 tmp[4];
2667
2668 tmp[0] = value;
2669 tmp[1] = value;
2670 tmp[2] = value;
2671 tmp[3] = value;
2672
2673 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2674 }
2675 }
2676
2677 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2678 {
2679 run_kernel_memset (device_param, buf, 0, size);
2680
2681 /*
2682 int rc = -1;
2683
2684 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2685 {
2686 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2687
2688 const cl_uchar zero = 0;
2689
2690 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2691 }
2692
2693 if (rc != 0)
2694 {
2695 // NOTE: clEnqueueFillBuffer () always fails with -59
2696 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2697 // How's that possible, OpenCL 1.2 support is advertised??
2698 // We need to workaround...
2699
2700 #define FILLSZ 0x100000
2701
2702 char *tmp = (char *) mymalloc (FILLSZ);
2703
2704 for (size_t i = 0; i < size; i += FILLSZ)
2705 {
2706 const size_t left = size - i;
2707
2708 const size_t fillsz = MIN (FILLSZ, left);
2709
2710 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2711 }
2712
2713 myfree (tmp);
2714 }
2715 */
2716 }
2717
2718 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)
2719 {
2720 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2721 {
2722 if (attack_mode == ATTACK_MODE_BF)
2723 {
2724 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2725 {
2726 const uint size_tm = 32 * sizeof (bs_word_t);
2727
2728 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2729
2730 run_kernel_tm (device_param);
2731
2732 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);
2733 }
2734 }
2735
2736 if (highest_pw_len < 16)
2737 {
2738 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2739 }
2740 else if (highest_pw_len < 32)
2741 {
2742 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2743 }
2744 else
2745 {
2746 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2747 }
2748 }
2749 else
2750 {
2751 run_kernel_amp (device_param, pws_cnt);
2752
2753 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2754
2755 if (opts_type & OPTS_TYPE_HOOK12)
2756 {
2757 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2758 }
2759
2760 uint iter = salt_buf->salt_iter;
2761
2762 uint loop_step = device_param->kernel_loops;
2763
2764 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2765 {
2766 uint loop_left = iter - loop_pos;
2767
2768 loop_left = MIN (loop_left, loop_step);
2769
2770 device_param->kernel_params_buf32[25] = loop_pos;
2771 device_param->kernel_params_buf32[26] = loop_left;
2772
2773 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2774
2775 if (data.devices_status == STATUS_CRACKED) break;
2776 if (data.devices_status == STATUS_ABORTED) break;
2777 if (data.devices_status == STATUS_QUIT) break;
2778
2779 /**
2780 * speed
2781 */
2782
2783 const float iter_part = (float) (loop_pos + loop_left) / iter;
2784
2785 const u64 perf_sum_all = pws_cnt * iter_part;
2786
2787 double speed_ms;
2788
2789 hc_timer_get (device_param->timer_speed, speed_ms);
2790
2791 const u32 speed_pos = device_param->speed_pos;
2792
2793 device_param->speed_cnt[speed_pos] = perf_sum_all;
2794
2795 device_param->speed_ms[speed_pos] = speed_ms;
2796
2797 if (data.benchmark == 1)
2798 {
2799 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2800 }
2801 }
2802
2803 if (opts_type & OPTS_TYPE_HOOK23)
2804 {
2805 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2806
2807 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);
2808
2809 // do something with data
2810
2811 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);
2812 }
2813
2814 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2815 }
2816 }
2817
2818 static int run_rule_engine (const int rule_len, const char *rule_buf)
2819 {
2820 if (rule_len == 0)
2821 {
2822 return 0;
2823 }
2824 else if (rule_len == 1)
2825 {
2826 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2827 }
2828
2829 return 1;
2830 }
2831
2832 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2833 {
2834 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2835 {
2836 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);
2837 }
2838 else if (data.attack_kern == ATTACK_KERN_COMBI)
2839 {
2840 if (data.attack_mode == ATTACK_MODE_COMBI)
2841 {
2842 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2843 {
2844 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2845 {
2846 for (u32 i = 0; i < pws_cnt; i++)
2847 {
2848 const u32 pw_len = device_param->pws_buf[i].pw_len;
2849
2850 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2851
2852 ptr[pw_len] = 0x01;
2853 }
2854 }
2855 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2856 {
2857 for (u32 i = 0; i < pws_cnt; i++)
2858 {
2859 const u32 pw_len = device_param->pws_buf[i].pw_len;
2860
2861 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2862
2863 ptr[pw_len] = 0x80;
2864 }
2865 }
2866 }
2867 }
2868 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2869 {
2870 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2871 {
2872 for (u32 i = 0; i < pws_cnt; i++)
2873 {
2874 const u32 pw_len = device_param->pws_buf[i].pw_len;
2875
2876 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2877
2878 ptr[pw_len] = 0x01;
2879 }
2880 }
2881 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2882 {
2883 for (u32 i = 0; i < pws_cnt; i++)
2884 {
2885 const u32 pw_len = device_param->pws_buf[i].pw_len;
2886
2887 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2888
2889 ptr[pw_len] = 0x80;
2890 }
2891 }
2892 }
2893
2894 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);
2895 }
2896 else if (data.attack_kern == ATTACK_KERN_BF)
2897 {
2898 const u64 off = device_param->words_off;
2899
2900 device_param->kernel_params_mp_l_buf64[3] = off;
2901
2902 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2903 }
2904 }
2905
2906 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2907 {
2908 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2909
2910 device_param->kernel_params_buf32[25] = 0;
2911 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2912 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2913
2914 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2915 {
2916 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2917 }
2918 else
2919 {
2920 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2921 }
2922
2923 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2924
2925 return exec_ms_prev;
2926 }
2927
2928 static void autotune (hc_device_param_t *device_param)
2929 {
2930 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2931
2932 const u32 kernel_accel_min = device_param->kernel_accel_min;
2933 const u32 kernel_accel_max = device_param->kernel_accel_max;
2934
2935 const u32 kernel_loops_min = device_param->kernel_loops_min;
2936 const u32 kernel_loops_max = device_param->kernel_loops_max;
2937
2938 u32 kernel_accel = kernel_accel_min;
2939 u32 kernel_loops = kernel_loops_min;
2940
2941 // in this case the user specified a fixed -u and -n on the commandline
2942 // no way to tune anything
2943 // but we need to run a few caching rounds
2944
2945 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2946 {
2947 try_run (device_param, kernel_accel, kernel_loops);
2948 try_run (device_param, kernel_accel, kernel_loops);
2949 try_run (device_param, kernel_accel, kernel_loops);
2950 try_run (device_param, kernel_accel, kernel_loops);
2951
2952 device_param->kernel_accel = kernel_accel;
2953 device_param->kernel_loops = kernel_loops;
2954
2955 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2956
2957 device_param->kernel_power = kernel_power;
2958
2959 return;
2960 }
2961
2962 // from here it's clear we are allowed to autotune
2963 // so let's init some fake words
2964
2965 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2966
2967 if (data.attack_kern == ATTACK_KERN_BF)
2968 {
2969 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2970 }
2971 else
2972 {
2973 for (u32 i = 0; i < kernel_power_max; i++)
2974 {
2975 device_param->pws_buf[i].i[0] = i;
2976 device_param->pws_buf[i].i[1] = 0x01234567;
2977 device_param->pws_buf[i].pw_len = 7 + (i & 7);
2978 }
2979
2980 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);
2981 }
2982
2983 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2984 {
2985 if (data.kernel_rules_cnt > 1)
2986 {
2987 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, MIN (kernel_loops_max, KERNEL_RULES) * sizeof (kernel_rule_t), 0, NULL, NULL);
2988 }
2989 }
2990 else
2991 {
2992 run_kernel_amp (device_param, kernel_power_max);
2993 }
2994
2995 #define VERIFIER_CNT 1
2996
2997 // first find out highest kernel-loops that stays below target_ms
2998
2999 if (kernel_loops_min < kernel_loops_max)
3000 {
3001 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3002 {
3003 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3004
3005 for (int i = 0; i < VERIFIER_CNT; i++)
3006 {
3007 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3008
3009 exec_ms = MIN (exec_ms, exec_ms_v);
3010 }
3011
3012 if (exec_ms < target_ms) break;
3013 }
3014 }
3015
3016 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3017
3018 #define STEPS_CNT 10
3019
3020 if (kernel_accel_min < kernel_accel_max)
3021 {
3022 for (int i = 0; i < STEPS_CNT; i++)
3023 {
3024 const u32 kernel_accel_try = 1 << i;
3025
3026 if (kernel_accel_try < kernel_accel_min) continue;
3027 if (kernel_accel_try > kernel_accel_max) break;
3028
3029 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3030
3031 for (int i = 0; i < VERIFIER_CNT; i++)
3032 {
3033 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3034
3035 exec_ms = MIN (exec_ms, exec_ms_v);
3036 }
3037
3038 if (exec_ms > target_ms) break;
3039
3040 kernel_accel = kernel_accel_try;
3041 }
3042 }
3043
3044 // at this point we want to know the actual runtime for the following reason:
3045 // we need a reference for the balancing loop following up, and this
3046 // the balancing loop can have an effect that the creates a new opportunity, for example:
3047 // if the target is 95 ms and the current runtime is 48ms the above loop
3048 // stopped the execution because the previous exec_ms was > 95ms
3049 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3050 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3051
3052 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3053
3054 for (int i = 0; i < VERIFIER_CNT; i++)
3055 {
3056 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3057
3058 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3059 }
3060
3061 u32 diff = kernel_loops - kernel_accel;
3062
3063 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3064 {
3065 u32 kernel_accel_orig = kernel_accel;
3066 u32 kernel_loops_orig = kernel_loops;
3067
3068 for (u32 f = 1; f < 1024; f++)
3069 {
3070 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3071 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3072
3073 if (kernel_accel_try > kernel_accel_max) break;
3074 if (kernel_loops_try < kernel_loops_min) break;
3075
3076 u32 diff_new = kernel_loops_try - kernel_accel_try;
3077
3078 if (diff_new > diff) break;
3079
3080 diff_new = diff;
3081
3082 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3083
3084 for (int i = 0; i < VERIFIER_CNT; i++)
3085 {
3086 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3087
3088 exec_ms = MIN (exec_ms, exec_ms_v);
3089 }
3090
3091 if (exec_ms < exec_ms_pre_final)
3092 {
3093 exec_ms_pre_final = exec_ms;
3094
3095 kernel_accel = kernel_accel_try;
3096 kernel_loops = kernel_loops_try;
3097 }
3098 }
3099 }
3100
3101 const double exec_left = target_ms / exec_ms_pre_final;
3102
3103 const double accel_left = kernel_accel_max / kernel_accel;
3104
3105 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3106
3107 if (exec_accel_min >= 1.0)
3108 {
3109 // this is safe to not overflow kernel_accel_max because of accel_left
3110
3111 kernel_accel = (double) kernel_accel * exec_accel_min;
3112 }
3113
3114 // reset them fake words
3115
3116 /*
3117 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3118
3119 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);
3120 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);
3121 */
3122
3123 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3124
3125 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3126 {
3127 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3128 }
3129
3130 // reset timer
3131
3132 device_param->exec_pos = 0;
3133
3134 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3135
3136 // store
3137
3138 device_param->kernel_accel = kernel_accel;
3139 device_param->kernel_loops = kernel_loops;
3140
3141 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3142
3143 device_param->kernel_power = kernel_power;
3144
3145 #ifdef DEBUG
3146
3147 if (data.quiet == 0)
3148 {
3149 clear_prompt ();
3150
3151 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3152 "Device #%u: autotuned kernel-loops to %u\n",
3153 device_param->device_id + 1, kernel_accel,
3154 device_param->device_id + 1, kernel_loops);
3155
3156 fprintf (stdout, "%s", PROMPT);
3157
3158 fflush (stdout);
3159 }
3160
3161 #endif
3162 }
3163
3164 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3165 {
3166 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3167
3168 // init speed timer
3169
3170 uint speed_pos = device_param->speed_pos;
3171
3172 #ifdef _POSIX
3173 if (device_param->timer_speed.tv_sec == 0)
3174 {
3175 hc_timer_set (&device_param->timer_speed);
3176 }
3177 #endif
3178
3179 #ifdef _WIN
3180 if (device_param->timer_speed.QuadPart == 0)
3181 {
3182 hc_timer_set (&device_param->timer_speed);
3183 }
3184 #endif
3185
3186 // find higest password length, this is for optimization stuff
3187
3188 uint highest_pw_len = 0;
3189
3190 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3191 {
3192 }
3193 else if (data.attack_kern == ATTACK_KERN_COMBI)
3194 {
3195 }
3196 else if (data.attack_kern == ATTACK_KERN_BF)
3197 {
3198 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3199 + device_param->kernel_params_mp_l_buf32[5];
3200 }
3201
3202 // iteration type
3203
3204 uint innerloop_step = 0;
3205 uint innerloop_cnt = 0;
3206
3207 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3208 else innerloop_step = 1;
3209
3210 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3211 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3212 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3213
3214 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3215
3216 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3217 {
3218 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3219
3220 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3221
3222 if (data.devices_status == STATUS_CRACKED) break;
3223 if (data.devices_status == STATUS_ABORTED) break;
3224 if (data.devices_status == STATUS_QUIT) break;
3225 if (data.devices_status == STATUS_BYPASS) break;
3226
3227 salt_t *salt_buf = &data.salts_buf[salt_pos];
3228
3229 device_param->kernel_params_buf32[24] = salt_pos;
3230 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3231 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3232
3233 FILE *combs_fp = device_param->combs_fp;
3234
3235 if (data.attack_mode == ATTACK_MODE_COMBI)
3236 {
3237 rewind (combs_fp);
3238 }
3239
3240 // innerloops
3241
3242 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3243 {
3244 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3245
3246 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3247
3248 if (data.devices_status == STATUS_CRACKED) break;
3249 if (data.devices_status == STATUS_ABORTED) break;
3250 if (data.devices_status == STATUS_QUIT) break;
3251 if (data.devices_status == STATUS_BYPASS) break;
3252
3253 uint innerloop_left = innerloop_cnt - innerloop_pos;
3254
3255 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3256
3257 device_param->innerloop_pos = innerloop_pos;
3258 device_param->innerloop_left = innerloop_left;
3259
3260 device_param->kernel_params_buf32[27] = innerloop_left;
3261
3262 // i think we can get rid of this
3263 if (innerloop_left == 0)
3264 {
3265 puts ("bug, how should this happen????\n");
3266
3267 continue;
3268 }
3269
3270 if (data.salts_shown[salt_pos] == 1)
3271 {
3272 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3273
3274 continue;
3275 }
3276
3277 // initialize amplifiers
3278
3279 if (data.attack_mode == ATTACK_MODE_COMBI)
3280 {
3281 uint i = 0;
3282
3283 while (i < innerloop_left)
3284 {
3285 if (feof (combs_fp)) break;
3286
3287 int line_len = fgetl (combs_fp, line_buf);
3288
3289 if (line_len >= PW_MAX1) continue;
3290
3291 line_len = convert_from_hex (line_buf, line_len);
3292
3293 char *line_buf_new = line_buf;
3294
3295 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3296 {
3297 char rule_buf_out[BLOCK_SIZE] = { 0 };
3298
3299 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3300
3301 if (rule_len_out < 0)
3302 {
3303 data.words_progress_rejected[salt_pos] += pws_cnt;
3304
3305 continue;
3306 }
3307
3308 line_len = rule_len_out;
3309
3310 line_buf_new = rule_buf_out;
3311 }
3312
3313 line_len = MIN (line_len, PW_DICTMAX);
3314
3315 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3316
3317 memcpy (ptr, line_buf_new, line_len);
3318
3319 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3320
3321 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3322 {
3323 uppercase (ptr, line_len);
3324 }
3325
3326 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3327 {
3328 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3329 {
3330 ptr[line_len] = 0x80;
3331 }
3332
3333 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3334 {
3335 ptr[line_len] = 0x01;
3336 }
3337 }
3338
3339 device_param->combs_buf[i].pw_len = line_len;
3340
3341 i++;
3342 }
3343
3344 for (uint j = i; j < innerloop_left; j++)
3345 {
3346 device_param->combs_buf[j].i[0] = 0;
3347 device_param->combs_buf[j].i[1] = 0;
3348 device_param->combs_buf[j].i[2] = 0;
3349 device_param->combs_buf[j].i[3] = 0;
3350 device_param->combs_buf[j].i[4] = 0;
3351 device_param->combs_buf[j].i[5] = 0;
3352 device_param->combs_buf[j].i[6] = 0;
3353 device_param->combs_buf[j].i[7] = 0;
3354
3355 device_param->combs_buf[j].pw_len = 0;
3356 }
3357
3358 innerloop_left = i;
3359 }
3360 else if (data.attack_mode == ATTACK_MODE_BF)
3361 {
3362 u64 off = innerloop_pos;
3363
3364 device_param->kernel_params_mp_r_buf64[3] = off;
3365
3366 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3367 }
3368 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3369 {
3370 u64 off = innerloop_pos;
3371
3372 device_param->kernel_params_mp_buf64[3] = off;
3373
3374 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3375 }
3376 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3377 {
3378 u64 off = innerloop_pos;
3379
3380 device_param->kernel_params_mp_buf64[3] = off;
3381
3382 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3383 }
3384
3385 // copy amplifiers
3386
3387 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3388 {
3389 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);
3390 }
3391 else if (data.attack_mode == ATTACK_MODE_COMBI)
3392 {
3393 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);
3394 }
3395 else if (data.attack_mode == ATTACK_MODE_BF)
3396 {
3397 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);
3398 }
3399 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3400 {
3401 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);
3402 }
3403 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3404 {
3405 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);
3406 }
3407
3408 if (data.benchmark == 1)
3409 {
3410 hc_timer_set (&device_param->timer_speed);
3411 }
3412
3413 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3414
3415 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3416
3417 if (data.devices_status == STATUS_CRACKED) break;
3418 if (data.devices_status == STATUS_ABORTED) break;
3419 if (data.devices_status == STATUS_QUIT) break;
3420
3421 /**
3422 * result
3423 */
3424
3425 check_cracked (device_param, salt_pos);
3426
3427 /**
3428 * progress
3429 */
3430
3431 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3432
3433 hc_thread_mutex_lock (mux_counter);
3434
3435 data.words_progress_done[salt_pos] += perf_sum_all;
3436
3437 hc_thread_mutex_unlock (mux_counter);
3438
3439 /**
3440 * speed
3441 */
3442
3443 double speed_ms;
3444
3445 hc_timer_get (device_param->timer_speed, speed_ms);
3446
3447 hc_timer_set (&device_param->timer_speed);
3448
3449 // current speed
3450
3451 //hc_thread_mutex_lock (mux_display);
3452
3453 device_param->speed_cnt[speed_pos] = perf_sum_all;
3454
3455 device_param->speed_ms[speed_pos] = speed_ms;
3456
3457 //hc_thread_mutex_unlock (mux_display);
3458
3459 speed_pos++;
3460
3461 if (speed_pos == SPEED_CACHE)
3462 {
3463 speed_pos = 0;
3464 }
3465
3466 /**
3467 * benchmark
3468 */
3469
3470 if (data.benchmark == 1) break;
3471 }
3472 }
3473
3474 device_param->speed_pos = speed_pos;
3475
3476 myfree (line_buf);
3477 }
3478
3479 static void load_segment (wl_data_t *wl_data, FILE *fd)
3480 {
3481 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3482
3483 wl_data->pos = 0;
3484
3485 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3486
3487 wl_data->buf[wl_data->cnt] = 0;
3488
3489 if (wl_data->cnt == 0) return;
3490
3491 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3492
3493 while (!feof (fd))
3494 {
3495 if (wl_data->cnt == wl_data->avail)
3496 {
3497 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3498
3499 wl_data->avail += wl_data->incr;
3500 }
3501
3502 const int c = fgetc (fd);
3503
3504 if (c == EOF) break;
3505
3506 wl_data->buf[wl_data->cnt] = (char) c;
3507
3508 wl_data->cnt++;
3509
3510 if (c == '\n') break;
3511 }
3512
3513 // ensure stream ends with a newline
3514
3515 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3516 {
3517 wl_data->cnt++;
3518
3519 wl_data->buf[wl_data->cnt - 1] = '\n';
3520 }
3521
3522 return;
3523 }
3524
3525 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3526 {
3527 char *ptr = buf;
3528
3529 for (u32 i = 0; i < sz; i++, ptr++)
3530 {
3531 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3532
3533 if (i == 7)
3534 {
3535 *off = i;
3536 *len = i;
3537
3538 return;
3539 }
3540
3541 if (*ptr != '\n') continue;
3542
3543 *off = i + 1;
3544
3545 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3546
3547 *len = i;
3548
3549 return;
3550 }
3551
3552 *off = sz;
3553 *len = sz;
3554 }
3555
3556 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3557 {
3558 char *ptr = buf;
3559
3560 for (u32 i = 0; i < sz; i++, ptr++)
3561 {
3562 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3563
3564 if (*ptr != '\n') continue;
3565
3566 *off = i + 1;
3567
3568 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3569
3570 *len = i;
3571
3572 return;
3573 }
3574
3575 *off = sz;
3576 *len = sz;
3577 }
3578
3579 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3580 {
3581 char *ptr = buf;
3582
3583 for (u32 i = 0; i < sz; i++, ptr++)
3584 {
3585 if (*ptr != '\n') continue;
3586
3587 *off = i + 1;
3588
3589 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3590
3591 *len = i;
3592
3593 return;
3594 }
3595
3596 *off = sz;
3597 *len = sz;
3598 }
3599
3600 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3601 {
3602 while (wl_data->pos < wl_data->cnt)
3603 {
3604 uint off;
3605 uint len;
3606
3607 char *ptr = wl_data->buf + wl_data->pos;
3608
3609 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3610
3611 wl_data->pos += off;
3612
3613 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3614 {
3615 char rule_buf_out[BLOCK_SIZE] = { 0 };
3616
3617 int rule_len_out = -1;
3618
3619 if (len < BLOCK_SIZE)
3620 {
3621 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3622 }
3623
3624 if (rule_len_out < 0)
3625 {
3626 continue;
3627 }
3628
3629 if (rule_len_out > PW_MAX)
3630 {
3631 continue;
3632 }
3633 }
3634 else
3635 {
3636 if (len > PW_MAX)
3637 {
3638 continue;
3639 }
3640 }
3641
3642 *out_buf = ptr;
3643 *out_len = len;
3644
3645 return;
3646 }
3647
3648 if (feof (fd))
3649 {
3650 fprintf (stderr, "BUG feof()!!\n");
3651
3652 return;
3653 }
3654
3655 load_segment (wl_data, fd);
3656
3657 get_next_word (wl_data, fd, out_buf, out_len);
3658 }
3659
3660 #ifdef _POSIX
3661 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3662 #endif
3663
3664 #ifdef _WIN
3665 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3666 #endif
3667 {
3668 hc_signal (NULL);
3669
3670 dictstat_t d;
3671
3672 d.cnt = 0;
3673
3674 #ifdef _POSIX
3675 fstat (fileno (fd), &d.stat);
3676 #endif
3677
3678 #ifdef _WIN
3679 _fstat64 (fileno (fd), &d.stat);
3680 #endif
3681
3682 d.stat.st_mode = 0;
3683 d.stat.st_nlink = 0;
3684 d.stat.st_uid = 0;
3685 d.stat.st_gid = 0;
3686 d.stat.st_rdev = 0;
3687 d.stat.st_atime = 0;
3688
3689 #ifdef _POSIX
3690 d.stat.st_blksize = 0;
3691 d.stat.st_blocks = 0;
3692 #endif
3693
3694 if (d.stat.st_size == 0) return 0;
3695
3696 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3697
3698 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3699 {
3700 if (d_cache)
3701 {
3702 u64 cnt = d_cache->cnt;
3703
3704 u64 keyspace = cnt;
3705
3706 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3707 {
3708 keyspace *= data.kernel_rules_cnt;
3709 }
3710 else if (data.attack_kern == ATTACK_KERN_COMBI)
3711 {
3712 keyspace *= data.combs_cnt;
3713 }
3714
3715 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);
3716 if (data.quiet == 0) log_info ("");
3717
3718 hc_signal (sigHandler_default);
3719
3720 return (keyspace);
3721 }
3722 }
3723
3724 time_t now = 0;
3725 time_t prev = 0;
3726
3727 u64 comp = 0;
3728 u64 cnt = 0;
3729 u64 cnt2 = 0;
3730
3731 while (!feof (fd))
3732 {
3733 load_segment (wl_data, fd);
3734
3735 comp += wl_data->cnt;
3736
3737 u32 i = 0;
3738
3739 while (i < wl_data->cnt)
3740 {
3741 u32 len;
3742 u32 off;
3743
3744 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3745
3746 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3747 {
3748 char rule_buf_out[BLOCK_SIZE] = { 0 };
3749
3750 int rule_len_out = -1;
3751
3752 if (len < BLOCK_SIZE)
3753 {
3754 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3755 }
3756
3757 if (rule_len_out < 0)
3758 {
3759 len = PW_MAX1;
3760 }
3761 else
3762 {
3763 len = rule_len_out;
3764 }
3765 }
3766
3767 if (len < PW_MAX1)
3768 {
3769 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3770 {
3771 cnt += data.kernel_rules_cnt;
3772 }
3773 else if (data.attack_kern == ATTACK_KERN_COMBI)
3774 {
3775 cnt += data.combs_cnt;
3776 }
3777
3778 d.cnt++;
3779 }
3780
3781 i += off;
3782
3783 cnt2++;
3784 }
3785
3786 time (&now);
3787
3788 if ((now - prev) == 0) continue;
3789
3790 float percent = (float) comp / (float) d.stat.st_size;
3791
3792 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);
3793
3794 time (&prev);
3795 }
3796
3797 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);
3798 if (data.quiet == 0) log_info ("");
3799
3800 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3801
3802 hc_signal (sigHandler_default);
3803
3804 return (cnt);
3805 }
3806
3807 static void *thread_monitor (void *p)
3808 {
3809 uint runtime_check = 0;
3810 uint remove_check = 0;
3811 uint status_check = 0;
3812 uint restore_check = 0;
3813
3814 uint restore_left = data.restore_timer;
3815 uint remove_left = data.remove_timer;
3816 uint status_left = data.status_timer;
3817
3818 #ifdef HAVE_HWMON
3819 uint hwmon_check = 0;
3820
3821 int slowdown_warnings = 0;
3822
3823 // these variables are mainly used for fan control
3824
3825 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3826
3827 // temperature controller "loopback" values
3828
3829 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3830 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3831
3832 int temp_threshold = 1; // degrees celcius
3833
3834 int fan_speed_min = 15; // in percentage
3835 int fan_speed_max = 100;
3836
3837 time_t last_temp_check_time;
3838 #endif // HAVE_HWMON
3839
3840 uint sleep_time = 1;
3841
3842 if (data.runtime)
3843 {
3844 runtime_check = 1;
3845 }
3846
3847 if (data.restore_timer)
3848 {
3849 restore_check = 1;
3850 }
3851
3852 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3853 {
3854 remove_check = 1;
3855 }
3856
3857 if (data.status == 1)
3858 {
3859 status_check = 1;
3860 }
3861
3862 #ifdef HAVE_HWMON
3863 if (data.gpu_temp_disable == 0)
3864 {
3865 time (&last_temp_check_time);
3866
3867 hwmon_check = 1;
3868 }
3869 #endif
3870
3871 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3872 {
3873 #ifdef HAVE_HWMON
3874 if (hwmon_check == 0)
3875 #endif
3876 return (p);
3877 }
3878
3879 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3880 {
3881 hc_sleep (sleep_time);
3882
3883 if (data.devices_status != STATUS_RUNNING) continue;
3884
3885 #ifdef HAVE_HWMON
3886
3887 if (1)
3888 {
3889 hc_thread_mutex_lock (mux_adl);
3890
3891 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3892 {
3893 hc_device_param_t *device_param = &data.devices_param[device_id];
3894
3895 if (device_param->skipped) continue;
3896
3897 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3898
3899 const int temperature = hm_get_temperature_with_device_id (device_id);
3900
3901 const int threshold = data.hm_device[device_id].gpu_temp_threshold_slowdown;
3902
3903 if (temperature >= threshold)
3904 {
3905 if (slowdown_warnings < 3)
3906 {
3907 if (data.quiet == 0) clear_prompt ();
3908
3909 log_info ("WARNING: Drivers temperature threshold (%dc) hit on GPU #%d, expect performance to drop...", threshold, device_id + 1);
3910
3911 if (slowdown_warnings == 2)
3912 {
3913 log_info ("");
3914 }
3915
3916 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3917 if (data.quiet == 0) fflush (stdout);
3918
3919 slowdown_warnings++;
3920 }
3921 }
3922 else
3923 {
3924 slowdown_warnings = 0;
3925 }
3926 }
3927
3928 hc_thread_mutex_unlock (mux_adl);
3929 }
3930
3931 if (hwmon_check == 1)
3932 {
3933 hc_thread_mutex_lock (mux_adl);
3934
3935 time_t temp_check_time;
3936
3937 time (&temp_check_time);
3938
3939 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3940
3941 if (Ta == 0) Ta = 1;
3942
3943 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3944 {
3945 hc_device_param_t *device_param = &data.devices_param[device_id];
3946
3947 if (device_param->skipped) continue;
3948
3949 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3950
3951 const int temperature = hm_get_temperature_with_device_id (device_id);
3952
3953 if (temperature > (int) data.gpu_temp_abort)
3954 {
3955 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3956
3957 if (data.devices_status != STATUS_QUIT) myabort ();
3958
3959 break;
3960 }
3961
3962 const int gpu_temp_retain = data.gpu_temp_retain;
3963
3964 if (gpu_temp_retain)
3965 {
3966 if (data.hm_device[device_id].fan_set_supported == 1)
3967 {
3968 int temp_cur = temperature;
3969
3970 int temp_diff_new = gpu_temp_retain - temp_cur;
3971
3972 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3973
3974 // calculate Ta value (time difference in seconds between the last check and this check)
3975
3976 last_temp_check_time = temp_check_time;
3977
3978 float Kp = 1.8;
3979 float Ki = 0.005;
3980 float Kd = 6;
3981
3982 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3983
3984 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);
3985
3986 if (abs (fan_diff_required) >= temp_threshold)
3987 {
3988 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3989
3990 int fan_speed_level = fan_speed_cur;
3991
3992 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3993
3994 int fan_speed_new = fan_speed_level - fan_diff_required;
3995
3996 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3997 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3998
3999 if (fan_speed_new != fan_speed_cur)
4000 {
4001 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4002 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4003
4004 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4005 {
4006 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4007 {
4008 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new, 1);
4009 }
4010 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4011 {
4012
4013 }
4014
4015 fan_speed_chgd[device_id] = 1;
4016 }
4017
4018 temp_diff_old[device_id] = temp_diff_new;
4019 }
4020 }
4021 }
4022 }
4023 }
4024
4025 hc_thread_mutex_unlock (mux_adl);
4026 }
4027 #endif // HAVE_HWMON
4028
4029 if (restore_check == 1)
4030 {
4031 restore_left--;
4032
4033 if (restore_left == 0)
4034 {
4035 if (data.restore_disable == 0) cycle_restore ();
4036
4037 restore_left = data.restore_timer;
4038 }
4039 }
4040
4041 if ((runtime_check == 1) && (data.runtime_start > 0))
4042 {
4043 time_t runtime_cur;
4044
4045 time (&runtime_cur);
4046
4047 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4048
4049 if (runtime_left <= 0)
4050 {
4051 if (data.benchmark == 0)
4052 {
4053 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4054 }
4055
4056 if (data.devices_status != STATUS_QUIT) myabort ();
4057 }
4058 }
4059
4060 if (remove_check == 1)
4061 {
4062 remove_left--;
4063
4064 if (remove_left == 0)
4065 {
4066 if (data.digests_saved != data.digests_done)
4067 {
4068 data.digests_saved = data.digests_done;
4069
4070 save_hash ();
4071 }
4072
4073 remove_left = data.remove_timer;
4074 }
4075 }
4076
4077 if (status_check == 1)
4078 {
4079 status_left--;
4080
4081 if (status_left == 0)
4082 {
4083 //hc_thread_mutex_lock (mux_display);
4084
4085 if (data.quiet == 0) clear_prompt ();
4086
4087 if (data.quiet == 0) log_info ("");
4088
4089 status_display ();
4090
4091 if (data.quiet == 0) log_info ("");
4092
4093 //hc_thread_mutex_unlock (mux_display);
4094
4095 status_left = data.status_timer;
4096 }
4097 }
4098 }
4099
4100 #ifdef HAVE_HWMON
4101 myfree (fan_speed_chgd);
4102
4103 myfree (temp_diff_old);
4104 myfree (temp_diff_sum);
4105 #endif
4106
4107 p = NULL;
4108
4109 return (p);
4110 }
4111
4112 static void *thread_outfile_remove (void *p)
4113 {
4114 // some hash-dependent constants
4115 char *outfile_dir = data.outfile_check_directory;
4116 uint dgst_size = data.dgst_size;
4117 uint isSalted = data.isSalted;
4118 uint esalt_size = data.esalt_size;
4119 uint hash_mode = data.hash_mode;
4120
4121 uint outfile_check_timer = data.outfile_check_timer;
4122
4123 char separator = data.separator;
4124
4125 // some hash-dependent functions
4126 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4127 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4128
4129 // buffers
4130 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4131
4132 hash_buf.digest = mymalloc (dgst_size);
4133
4134 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4135
4136 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4137
4138 uint digest_buf[64] = { 0 };
4139
4140 outfile_data_t *out_info = NULL;
4141
4142 char **out_files = NULL;
4143
4144 time_t folder_mtime = 0;
4145
4146 int out_cnt = 0;
4147
4148 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4149
4150 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4151 {
4152 hc_sleep (1);
4153
4154 if (data.devices_status != STATUS_RUNNING) continue;
4155
4156 check_left--;
4157
4158 if (check_left == 0)
4159 {
4160 struct stat outfile_check_stat;
4161
4162 if (stat (outfile_dir, &outfile_check_stat) == 0)
4163 {
4164 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4165
4166 if (is_dir == 1)
4167 {
4168 if (outfile_check_stat.st_mtime > folder_mtime)
4169 {
4170 char **out_files_new = scan_directory (outfile_dir);
4171
4172 int out_cnt_new = count_dictionaries (out_files_new);
4173
4174 outfile_data_t *out_info_new = NULL;
4175
4176 if (out_cnt_new > 0)
4177 {
4178 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4179
4180 for (int i = 0; i < out_cnt_new; i++)
4181 {
4182 out_info_new[i].file_name = out_files_new[i];
4183
4184 // check if there are files that we have seen/checked before (and not changed)
4185
4186 for (int j = 0; j < out_cnt; j++)
4187 {
4188 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4189 {
4190 struct stat outfile_stat;
4191
4192 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4193 {
4194 if (outfile_stat.st_ctime == out_info[j].ctime)
4195 {
4196 out_info_new[i].ctime = out_info[j].ctime;
4197 out_info_new[i].seek = out_info[j].seek;
4198 }
4199 }
4200 }
4201 }
4202 }
4203 }
4204
4205 local_free (out_info);
4206 local_free (out_files);
4207
4208 out_files = out_files_new;
4209 out_cnt = out_cnt_new;
4210 out_info = out_info_new;
4211
4212 folder_mtime = outfile_check_stat.st_mtime;
4213 }
4214
4215 for (int j = 0; j < out_cnt; j++)
4216 {
4217 FILE *fp = fopen (out_info[j].file_name, "rb");
4218
4219 if (fp != NULL)
4220 {
4221 //hc_thread_mutex_lock (mux_display);
4222
4223 #ifdef _POSIX
4224 struct stat outfile_stat;
4225
4226 fstat (fileno (fp), &outfile_stat);
4227 #endif
4228
4229 #ifdef _WIN
4230 struct stat64 outfile_stat;
4231
4232 _fstat64 (fileno (fp), &outfile_stat);
4233 #endif
4234
4235 if (outfile_stat.st_ctime > out_info[j].ctime)
4236 {
4237 out_info[j].ctime = outfile_stat.st_ctime;
4238 out_info[j].seek = 0;
4239 }
4240
4241 fseek (fp, out_info[j].seek, SEEK_SET);
4242
4243 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4244
4245 while (!feof (fp))
4246 {
4247 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4248
4249 if (ptr == NULL) break;
4250
4251 int line_len = strlen (line_buf);
4252
4253 if (line_len <= 0) continue;
4254
4255 int iter = MAX_CUT_TRIES;
4256
4257 for (uint i = line_len - 1; i && iter; i--, line_len--)
4258 {
4259 if (line_buf[i] != separator) continue;
4260
4261 int parser_status = PARSER_OK;
4262
4263 if ((hash_mode != 2500) && (hash_mode != 6800))
4264 {
4265 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4266 }
4267
4268 uint found = 0;
4269
4270 if (parser_status == PARSER_OK)
4271 {
4272 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4273 {
4274 if (data.salts_shown[salt_pos] == 1) continue;
4275
4276 salt_t *salt_buf = &data.salts_buf[salt_pos];
4277
4278 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4279 {
4280 uint idx = salt_buf->digests_offset + digest_pos;
4281
4282 if (data.digests_shown[idx] == 1) continue;
4283
4284 uint cracked = 0;
4285
4286 if (hash_mode == 6800)
4287 {
4288 if (i == salt_buf->salt_len)
4289 {
4290 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4291 }
4292 }
4293 else if (hash_mode == 2500)
4294 {
4295 // BSSID : MAC1 : MAC2 (:plain)
4296 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4297 {
4298 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4299
4300 if (!cracked) continue;
4301
4302 // now compare MAC1 and MAC2 too, since we have this additional info
4303 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4304 char *mac2_pos = mac1_pos + 12 + 1;
4305
4306 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4307 wpa_t *wpa = &wpas[salt_pos];
4308
4309 // compare hex string(s) vs binary MAC address(es)
4310
4311 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4312 {
4313 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4314 {
4315 cracked = 0;
4316
4317 break;
4318 }
4319 }
4320
4321 // early skip ;)
4322 if (!cracked) continue;
4323
4324 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4325 {
4326 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4327 {
4328 cracked = 0;
4329
4330 break;
4331 }
4332 }
4333 }
4334 }
4335 else
4336 {
4337 char *digests_buf_ptr = (char *) data.digests_buf;
4338
4339 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4340
4341 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4342 }
4343
4344 if (cracked == 1)
4345 {
4346 found = 1;
4347
4348 data.digests_shown[idx] = 1;
4349
4350 data.digests_done++;
4351
4352 salt_buf->digests_done++;
4353
4354 if (salt_buf->digests_done == salt_buf->digests_cnt)
4355 {
4356 data.salts_shown[salt_pos] = 1;
4357
4358 data.salts_done++;
4359
4360 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4361 }
4362 }
4363 }
4364
4365 if (data.devices_status == STATUS_CRACKED) break;
4366 }
4367 }
4368
4369 if (found) break;
4370
4371 if (data.devices_status == STATUS_CRACKED) break;
4372
4373 iter--;
4374 }
4375
4376 if (data.devices_status == STATUS_CRACKED) break;
4377 }
4378
4379 myfree (line_buf);
4380
4381 out_info[j].seek = ftell (fp);
4382
4383 //hc_thread_mutex_unlock (mux_display);
4384
4385 fclose (fp);
4386 }
4387 }
4388 }
4389 }
4390
4391 check_left = outfile_check_timer;
4392 }
4393 }
4394
4395 if (esalt_size) local_free (hash_buf.esalt);
4396
4397 if (isSalted) local_free (hash_buf.salt);
4398
4399 local_free (hash_buf.digest);
4400
4401 local_free (out_info);
4402
4403 local_free (out_files);
4404
4405 p = NULL;
4406
4407 return (p);
4408 }
4409
4410 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4411 {
4412 if (device_param->pws_cnt < device_param->kernel_power)
4413 {
4414 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4415
4416 u8 *ptr = (u8 *) pw->i;
4417
4418 memcpy (ptr, pw_buf, pw_len);
4419
4420 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4421
4422 pw->pw_len = pw_len;
4423
4424 device_param->pws_cnt++;
4425 }
4426 else
4427 {
4428 fprintf (stderr, "BUG pw_add()!!\n");
4429
4430 return;
4431 }
4432 }
4433
4434 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4435 {
4436 hc_thread_mutex_lock (mux_dispatcher);
4437
4438 const u64 words_cur = data.words_cur;
4439 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4440
4441 device_param->words_off = words_cur;
4442
4443 const u64 words_left = words_base - words_cur;
4444
4445 if (allow_div)
4446 {
4447 if (data.kernel_power_all > words_left)
4448 {
4449 if (data.kernel_power_div == 0)
4450 {
4451 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4452 }
4453 }
4454
4455 if (data.kernel_power_div)
4456 {
4457 if (device_param->kernel_power == device_param->kernel_power_user)
4458 {
4459 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4460
4461 if (kernel_power_new < device_param->kernel_power)
4462 {
4463 device_param->kernel_power = kernel_power_new;
4464 }
4465 }
4466 }
4467 }
4468
4469 const uint kernel_power = device_param->kernel_power;
4470
4471 uint work = MIN (words_left, kernel_power);
4472
4473 work = MIN (work, max);
4474
4475 data.words_cur += work;
4476
4477 hc_thread_mutex_unlock (mux_dispatcher);
4478
4479 return work;
4480 }
4481
4482 static void *thread_calc_stdin (void *p)
4483 {
4484 hc_device_param_t *device_param = (hc_device_param_t *) p;
4485
4486 if (device_param->skipped) return NULL;
4487
4488 autotune (device_param);
4489
4490 char *buf = (char *) mymalloc (HCBUFSIZ);
4491
4492 const uint attack_kern = data.attack_kern;
4493
4494 const uint kernel_power = device_param->kernel_power;
4495
4496 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4497 {
4498 hc_thread_mutex_lock (mux_dispatcher);
4499
4500 if (feof (stdin) != 0)
4501 {
4502 hc_thread_mutex_unlock (mux_dispatcher);
4503
4504 break;
4505 }
4506
4507 uint words_cur = 0;
4508
4509 while (words_cur < kernel_power)
4510 {
4511 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4512
4513 if (line_buf == NULL) break;
4514
4515 uint line_len = in_superchop (line_buf);
4516
4517 line_len = convert_from_hex (line_buf, line_len);
4518
4519 // post-process rule engine
4520
4521 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4522 {
4523 char rule_buf_out[BLOCK_SIZE] = { 0 };
4524
4525 int rule_len_out = -1;
4526
4527 if (line_len < BLOCK_SIZE)
4528 {
4529 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4530 }
4531
4532 if (rule_len_out < 0) continue;
4533
4534 line_buf = rule_buf_out;
4535 line_len = rule_len_out;
4536 }
4537
4538 if (line_len > PW_MAX)
4539 {
4540 continue;
4541 }
4542
4543 if (attack_kern == ATTACK_KERN_STRAIGHT)
4544 {
4545 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4546 {
4547 hc_thread_mutex_lock (mux_counter);
4548
4549 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4550 {
4551 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4552 }
4553
4554 hc_thread_mutex_unlock (mux_counter);
4555
4556 continue;
4557 }
4558 }
4559 else if (attack_kern == ATTACK_KERN_COMBI)
4560 {
4561 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4562 // since we still need to combine the plains
4563
4564 if (line_len > data.pw_max)
4565 {
4566 hc_thread_mutex_lock (mux_counter);
4567
4568 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4569 {
4570 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4571 }
4572
4573 hc_thread_mutex_unlock (mux_counter);
4574
4575 continue;
4576 }
4577 }
4578
4579 pw_add (device_param, (u8 *) line_buf, line_len);
4580
4581 words_cur++;
4582
4583 if (data.devices_status == STATUS_CRACKED) break;
4584 if (data.devices_status == STATUS_ABORTED) break;
4585 if (data.devices_status == STATUS_QUIT) break;
4586 if (data.devices_status == STATUS_BYPASS) break;
4587 }
4588
4589 hc_thread_mutex_unlock (mux_dispatcher);
4590
4591 if (data.devices_status == STATUS_CRACKED) break;
4592 if (data.devices_status == STATUS_ABORTED) break;
4593 if (data.devices_status == STATUS_QUIT) break;
4594 if (data.devices_status == STATUS_BYPASS) break;
4595
4596 // flush
4597
4598 const uint pws_cnt = device_param->pws_cnt;
4599
4600 if (pws_cnt)
4601 {
4602 run_copy (device_param, pws_cnt);
4603
4604 run_cracker (device_param, pws_cnt);
4605
4606 device_param->pws_cnt = 0;
4607
4608 /*
4609 still required?
4610 if (attack_kern == ATTACK_KERN_STRAIGHT)
4611 {
4612 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4613 }
4614 else if (attack_kern == ATTACK_KERN_COMBI)
4615 {
4616 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4617 }
4618 */
4619 }
4620 }
4621
4622 device_param->kernel_accel = 0;
4623 device_param->kernel_loops = 0;
4624
4625 myfree (buf);
4626
4627 return NULL;
4628 }
4629
4630 static void *thread_calc (void *p)
4631 {
4632 hc_device_param_t *device_param = (hc_device_param_t *) p;
4633
4634 if (device_param->skipped) return NULL;
4635
4636 autotune (device_param);
4637
4638 const uint attack_mode = data.attack_mode;
4639 const uint attack_kern = data.attack_kern;
4640
4641 if (attack_mode == ATTACK_MODE_BF)
4642 {
4643 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4644 {
4645 const uint work = get_work (device_param, -1, true);
4646
4647 if (work == 0) break;
4648
4649 const u64 words_off = device_param->words_off;
4650 const u64 words_fin = words_off + work;
4651
4652 const uint pws_cnt = work;
4653
4654 device_param->pws_cnt = pws_cnt;
4655
4656 if (pws_cnt)
4657 {
4658 run_copy (device_param, pws_cnt);
4659
4660 run_cracker (device_param, pws_cnt);
4661
4662 device_param->pws_cnt = 0;
4663
4664 /*
4665 still required?
4666 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4667 */
4668 }
4669
4670 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4671
4672 if (data.devices_status == STATUS_CRACKED) break;
4673 if (data.devices_status == STATUS_ABORTED) break;
4674 if (data.devices_status == STATUS_QUIT) break;
4675 if (data.devices_status == STATUS_BYPASS) break;
4676
4677 if (data.benchmark == 1) break;
4678
4679 device_param->words_done = words_fin;
4680 }
4681 }
4682 else
4683 {
4684 const uint segment_size = data.segment_size;
4685
4686 char *dictfile = data.dictfile;
4687
4688 if (attack_mode == ATTACK_MODE_COMBI)
4689 {
4690 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4691 {
4692 dictfile = data.dictfile2;
4693 }
4694 }
4695
4696 FILE *fd = fopen (dictfile, "rb");
4697
4698 if (fd == NULL)
4699 {
4700 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4701
4702 return NULL;
4703 }
4704
4705 if (attack_mode == ATTACK_MODE_COMBI)
4706 {
4707 const uint combs_mode = data.combs_mode;
4708
4709 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4710 {
4711 const char *dictfilec = data.dictfile2;
4712
4713 FILE *combs_fp = fopen (dictfilec, "rb");
4714
4715 if (combs_fp == NULL)
4716 {
4717 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4718
4719 fclose (fd);
4720
4721 return NULL;
4722 }
4723
4724 device_param->combs_fp = combs_fp;
4725 }
4726 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4727 {
4728 const char *dictfilec = data.dictfile;
4729
4730 FILE *combs_fp = fopen (dictfilec, "rb");
4731
4732 if (combs_fp == NULL)
4733 {
4734 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4735
4736 fclose (fd);
4737
4738 return NULL;
4739 }
4740
4741 device_param->combs_fp = combs_fp;
4742 }
4743 }
4744
4745 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4746
4747 wl_data->buf = (char *) mymalloc (segment_size);
4748 wl_data->avail = segment_size;
4749 wl_data->incr = segment_size;
4750 wl_data->cnt = 0;
4751 wl_data->pos = 0;
4752
4753 u64 words_cur = 0;
4754
4755 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4756 {
4757 u64 words_off = 0;
4758 u64 words_fin = 0;
4759
4760 bool allow_div = true;
4761
4762 u64 max = -1;
4763
4764 while (max)
4765 {
4766 const uint work = get_work (device_param, max, allow_div);
4767
4768 allow_div = false;
4769
4770 if (work == 0) break;
4771
4772 words_off = device_param->words_off;
4773 words_fin = words_off + work;
4774
4775 char *line_buf;
4776 uint line_len;
4777
4778 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4779
4780 max = 0;
4781
4782 for ( ; words_cur < words_fin; words_cur++)
4783 {
4784 get_next_word (wl_data, fd, &line_buf, &line_len);
4785
4786 line_len = convert_from_hex (line_buf, line_len);
4787
4788 // post-process rule engine
4789
4790 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4791 {
4792 char rule_buf_out[BLOCK_SIZE] = { 0 };
4793
4794 int rule_len_out = -1;
4795
4796 if (line_len < BLOCK_SIZE)
4797 {
4798 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4799 }
4800
4801 if (rule_len_out < 0) continue;
4802
4803 line_buf = rule_buf_out;
4804 line_len = rule_len_out;
4805 }
4806
4807 if (attack_kern == ATTACK_KERN_STRAIGHT)
4808 {
4809 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4810 {
4811 max++;
4812
4813 hc_thread_mutex_lock (mux_counter);
4814
4815 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4816 {
4817 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4818 }
4819
4820 hc_thread_mutex_unlock (mux_counter);
4821
4822 continue;
4823 }
4824 }
4825 else if (attack_kern == ATTACK_KERN_COMBI)
4826 {
4827 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4828 // since we still need to combine the plains
4829
4830 if (line_len > data.pw_max)
4831 {
4832 max++;
4833
4834 hc_thread_mutex_lock (mux_counter);
4835
4836 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4837 {
4838 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4839 }
4840
4841 hc_thread_mutex_unlock (mux_counter);
4842
4843 continue;
4844 }
4845 }
4846
4847 pw_add (device_param, (u8 *) line_buf, line_len);
4848
4849 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4850
4851 if (data.devices_status == STATUS_CRACKED) break;
4852 if (data.devices_status == STATUS_ABORTED) break;
4853 if (data.devices_status == STATUS_QUIT) break;
4854 if (data.devices_status == STATUS_BYPASS) break;
4855 }
4856
4857 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4858
4859 if (data.devices_status == STATUS_CRACKED) break;
4860 if (data.devices_status == STATUS_ABORTED) break;
4861 if (data.devices_status == STATUS_QUIT) break;
4862 if (data.devices_status == STATUS_BYPASS) break;
4863 }
4864
4865 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4866
4867 if (data.devices_status == STATUS_CRACKED) break;
4868 if (data.devices_status == STATUS_ABORTED) break;
4869 if (data.devices_status == STATUS_QUIT) break;
4870 if (data.devices_status == STATUS_BYPASS) break;
4871
4872 //
4873 // flush
4874 //
4875
4876 const uint pws_cnt = device_param->pws_cnt;
4877
4878 if (pws_cnt)
4879 {
4880 run_copy (device_param, pws_cnt);
4881
4882 run_cracker (device_param, pws_cnt);
4883
4884 device_param->pws_cnt = 0;
4885
4886 /*
4887 still required?
4888 if (attack_kern == ATTACK_KERN_STRAIGHT)
4889 {
4890 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4891 }
4892 else if (attack_kern == ATTACK_KERN_COMBI)
4893 {
4894 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4895 }
4896 */
4897 }
4898
4899 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4900
4901 if (data.devices_status == STATUS_CRACKED) break;
4902 if (data.devices_status == STATUS_ABORTED) break;
4903 if (data.devices_status == STATUS_QUIT) break;
4904 if (data.devices_status == STATUS_BYPASS) break;
4905
4906 if (words_fin == 0) break;
4907
4908 device_param->words_done = words_fin;
4909 }
4910
4911 if (attack_mode == ATTACK_MODE_COMBI)
4912 {
4913 fclose (device_param->combs_fp);
4914 }
4915
4916 free (wl_data->buf);
4917 free (wl_data);
4918
4919 fclose (fd);
4920 }
4921
4922 device_param->kernel_accel = 0;
4923 device_param->kernel_loops = 0;
4924
4925 return NULL;
4926 }
4927
4928 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4929 {
4930 if (!device_param)
4931 {
4932 log_error ("ERROR: %s : Invalid argument", __func__);
4933
4934 exit (-1);
4935 }
4936
4937 salt_t *salt_buf = &data.salts_buf[salt_pos];
4938
4939 device_param->kernel_params_buf32[24] = salt_pos;
4940 device_param->kernel_params_buf32[27] = 1;
4941 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4942 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4943 device_param->kernel_params_buf32[30] = 0;
4944 device_param->kernel_params_buf32[31] = 1;
4945
4946 char *dictfile_old = data.dictfile;
4947
4948 const char *weak_hash_check = "weak-hash-check";
4949
4950 data.dictfile = (char *) weak_hash_check;
4951
4952 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4953
4954 data.kernel_rules_buf[0].cmds[0] = 0;
4955
4956 /**
4957 * run the kernel
4958 */
4959
4960 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4961 {
4962 run_kernel (KERN_RUN_1, device_param, 1, false);
4963 }
4964 else
4965 {
4966 run_kernel (KERN_RUN_1, device_param, 1, false);
4967
4968 uint loop_step = 16;
4969
4970 const uint iter = salt_buf->salt_iter;
4971
4972 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4973 {
4974 uint loop_left = iter - loop_pos;
4975
4976 loop_left = MIN (loop_left, loop_step);
4977
4978 device_param->kernel_params_buf32[25] = loop_pos;
4979 device_param->kernel_params_buf32[26] = loop_left;
4980
4981 run_kernel (KERN_RUN_2, device_param, 1, false);
4982 }
4983
4984 run_kernel (KERN_RUN_3, device_param, 1, false);
4985 }
4986
4987 /**
4988 * result
4989 */
4990
4991 check_cracked (device_param, salt_pos);
4992
4993 /**
4994 * cleanup
4995 */
4996
4997 device_param->kernel_params_buf32[24] = 0;
4998 device_param->kernel_params_buf32[25] = 0;
4999 device_param->kernel_params_buf32[26] = 0;
5000 device_param->kernel_params_buf32[27] = 0;
5001 device_param->kernel_params_buf32[28] = 0;
5002 device_param->kernel_params_buf32[29] = 0;
5003 device_param->kernel_params_buf32[30] = 0;
5004 device_param->kernel_params_buf32[31] = 0;
5005
5006 data.dictfile = dictfile_old;
5007
5008 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5009 }
5010
5011 // hlfmt hashcat
5012
5013 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5014 {
5015 if (data.username == 0)
5016 {
5017 *hashbuf_pos = line_buf;
5018 *hashbuf_len = line_len;
5019 }
5020 else
5021 {
5022 char *pos = line_buf;
5023 int len = line_len;
5024
5025 for (int i = 0; i < line_len; i++, pos++, len--)
5026 {
5027 if (line_buf[i] == data.separator)
5028 {
5029 pos++;
5030
5031 len--;
5032
5033 break;
5034 }
5035 }
5036
5037 *hashbuf_pos = pos;
5038 *hashbuf_len = len;
5039 }
5040 }
5041
5042 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5043 {
5044 char *pos = NULL;
5045 int len = 0;
5046
5047 int sep_cnt = 0;
5048
5049 for (int i = 0; i < line_len; i++)
5050 {
5051 if (line_buf[i] == data.separator)
5052 {
5053 sep_cnt++;
5054
5055 continue;
5056 }
5057
5058 if (sep_cnt == 0)
5059 {
5060 if (pos == NULL) pos = line_buf + i;
5061
5062 len++;
5063 }
5064 }
5065
5066 *userbuf_pos = pos;
5067 *userbuf_len = len;
5068 }
5069
5070 // hlfmt pwdump
5071
5072 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5073 {
5074 int sep_cnt = 0;
5075
5076 int sep2_len = 0;
5077 int sep3_len = 0;
5078
5079 for (int i = 0; i < line_len; i++)
5080 {
5081 if (line_buf[i] == ':')
5082 {
5083 sep_cnt++;
5084
5085 continue;
5086 }
5087
5088 if (sep_cnt == 2) sep2_len++;
5089 if (sep_cnt == 3) sep3_len++;
5090 }
5091
5092 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5093
5094 return 0;
5095 }
5096
5097 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5098 {
5099 char *pos = NULL;
5100 int len = 0;
5101
5102 int sep_cnt = 0;
5103
5104 for (int i = 0; i < line_len; i++)
5105 {
5106 if (line_buf[i] == ':')
5107 {
5108 sep_cnt++;
5109
5110 continue;
5111 }
5112
5113 if (data.hash_mode == 1000)
5114 {
5115 if (sep_cnt == 3)
5116 {
5117 if (pos == NULL) pos = line_buf + i;
5118
5119 len++;
5120 }
5121 }
5122 else if (data.hash_mode == 3000)
5123 {
5124 if (sep_cnt == 2)
5125 {
5126 if (pos == NULL) pos = line_buf + i;
5127
5128 len++;
5129 }
5130 }
5131 }
5132
5133 *hashbuf_pos = pos;
5134 *hashbuf_len = len;
5135 }
5136
5137 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5138 {
5139 char *pos = NULL;
5140 int len = 0;
5141
5142 int sep_cnt = 0;
5143
5144 for (int i = 0; i < line_len; i++)
5145 {
5146 if (line_buf[i] == ':')
5147 {
5148 sep_cnt++;
5149
5150 continue;
5151 }
5152
5153 if (sep_cnt == 0)
5154 {
5155 if (pos == NULL) pos = line_buf + i;
5156
5157 len++;
5158 }
5159 }
5160
5161 *userbuf_pos = pos;
5162 *userbuf_len = len;
5163 }
5164
5165 // hlfmt passwd
5166
5167 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5168 {
5169 int sep_cnt = 0;
5170
5171 char sep5_first = 0;
5172 char sep6_first = 0;
5173
5174 for (int i = 0; i < line_len; i++)
5175 {
5176 if (line_buf[i] == ':')
5177 {
5178 sep_cnt++;
5179
5180 continue;
5181 }
5182
5183 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5184 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5185 }
5186
5187 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5188
5189 return 0;
5190 }
5191
5192 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5193 {
5194 char *pos = NULL;
5195 int len = 0;
5196
5197 int sep_cnt = 0;
5198
5199 for (int i = 0; i < line_len; i++)
5200 {
5201 if (line_buf[i] == ':')
5202 {
5203 sep_cnt++;
5204
5205 continue;
5206 }
5207
5208 if (sep_cnt == 1)
5209 {
5210 if (pos == NULL) pos = line_buf + i;
5211
5212 len++;
5213 }
5214 }
5215
5216 *hashbuf_pos = pos;
5217 *hashbuf_len = len;
5218 }
5219
5220 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5221 {
5222 char *pos = NULL;
5223 int len = 0;
5224
5225 int sep_cnt = 0;
5226
5227 for (int i = 0; i < line_len; i++)
5228 {
5229 if (line_buf[i] == ':')
5230 {
5231 sep_cnt++;
5232
5233 continue;
5234 }
5235
5236 if (sep_cnt == 0)
5237 {
5238 if (pos == NULL) pos = line_buf + i;
5239
5240 len++;
5241 }
5242 }
5243
5244 *userbuf_pos = pos;
5245 *userbuf_len = len;
5246 }
5247
5248 // hlfmt shadow
5249
5250 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5251 {
5252 int sep_cnt = 0;
5253
5254 for (int i = 0; i < line_len; i++)
5255 {
5256 if (line_buf[i] == ':') sep_cnt++;
5257 }
5258
5259 if (sep_cnt == 8) return 1;
5260
5261 return 0;
5262 }
5263
5264 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5265 {
5266 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5267 }
5268
5269 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5270 {
5271 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5272 }
5273
5274 // hlfmt main
5275
5276 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5277 {
5278 switch (hashfile_format)
5279 {
5280 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5281 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5282 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5283 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5284 }
5285 }
5286
5287 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5288 {
5289 switch (hashfile_format)
5290 {
5291 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5292 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5293 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5294 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5295 }
5296 }
5297
5298 char *strhlfmt (const uint hashfile_format)
5299 {
5300 switch (hashfile_format)
5301 {
5302 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5303 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5304 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5305 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5306 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5307 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5308 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5309 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5310 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5311 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5312 }
5313
5314 return ((char *) "Unknown");
5315 }
5316
5317 static uint hlfmt_detect (FILE *fp, uint max_check)
5318 {
5319 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5320
5321 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5322 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5323
5324 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5325
5326 uint num_check = 0;
5327
5328 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5329
5330 while (!feof (fp))
5331 {
5332 int line_len = fgetl (fp, line_buf);
5333
5334 if (line_len == 0) continue;
5335
5336 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5337 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5338 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5339
5340 if (num_check == max_check) break;
5341
5342 num_check++;
5343 }
5344
5345 myfree (line_buf);
5346
5347 uint hashlist_format = HLFMT_HASHCAT;
5348
5349 for (int i = 1; i < HLFMTS_CNT; i++)
5350 {
5351 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5352
5353 hashlist_format = i;
5354 }
5355
5356 free (formats_cnt);
5357
5358 return hashlist_format;
5359 }
5360
5361 /**
5362 * some further helper function
5363 */
5364
5365 // wrapper around mymalloc for ADL
5366
5367 #if defined(HAVE_HWMON)
5368 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5369 {
5370 return mymalloc (iSize);
5371 }
5372 #endif
5373
5374 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)
5375 {
5376 u64 collisions = 0;
5377
5378 const uint dgst_pos0 = data.dgst_pos0;
5379 const uint dgst_pos1 = data.dgst_pos1;
5380 const uint dgst_pos2 = data.dgst_pos2;
5381 const uint dgst_pos3 = data.dgst_pos3;
5382
5383 memset (bitmap_a, 0, bitmap_size);
5384 memset (bitmap_b, 0, bitmap_size);
5385 memset (bitmap_c, 0, bitmap_size);
5386 memset (bitmap_d, 0, bitmap_size);
5387
5388 for (uint i = 0; i < digests_cnt; i++)
5389 {
5390 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5391
5392 uint *digest_ptr = (uint *) digests_buf_ptr;
5393
5394 digests_buf_ptr += dgst_size;
5395
5396 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5397 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5398 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5399 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5400
5401 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5402 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5403 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5404 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5405
5406 if (bitmap_a[idx0] & val0) collisions++;
5407 if (bitmap_b[idx1] & val1) collisions++;
5408 if (bitmap_c[idx2] & val2) collisions++;
5409 if (bitmap_d[idx3] & val3) collisions++;
5410
5411 bitmap_a[idx0] |= val0;
5412 bitmap_b[idx1] |= val1;
5413 bitmap_c[idx2] |= val2;
5414 bitmap_d[idx3] |= val3;
5415
5416 if (collisions >= collisions_max) return 0x7fffffff;
5417 }
5418
5419 return collisions;
5420 }
5421
5422 /**
5423 * main
5424 */
5425
5426 #ifdef _WIN
5427 void SetConsoleWindowSize (const int x)
5428 {
5429 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5430
5431 if (h == INVALID_HANDLE_VALUE) return;
5432
5433 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5434
5435 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5436
5437 SMALL_RECT *sr = &bufferInfo.srWindow;
5438
5439 sr->Right = MAX (sr->Right, x - 1);
5440
5441 COORD co;
5442
5443 co.X = sr->Right + 1;
5444 co.Y = sr->Bottom + 1;
5445
5446 if (!SetConsoleScreenBufferSize (h, co)) return;
5447
5448 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5449 }
5450 #endif
5451
5452 int main (int argc, char **argv)
5453 {
5454 #ifdef _WIN
5455 SetConsoleWindowSize (132);
5456 #endif
5457
5458 /**
5459 * To help users a bit
5460 */
5461
5462 char *compute = getenv ("COMPUTE");
5463
5464 if (compute)
5465 {
5466 static char display[100];
5467
5468 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5469
5470 putenv (display);
5471 }
5472 else
5473 {
5474 if (getenv ("DISPLAY") == NULL)
5475 putenv ((char *) "DISPLAY=:0");
5476 }
5477
5478 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5479 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5480
5481 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5482 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5483
5484 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5485 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5486
5487 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5488 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5489
5490 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5491 putenv ((char *) "POCL_KERNEL_CACHE=0");
5492
5493 umask (077);
5494
5495 /**
5496 * Real init
5497 */
5498
5499 memset (&data, 0, sizeof (hc_global_data_t));
5500
5501 time_t proc_start;
5502
5503 time (&proc_start);
5504
5505 data.proc_start = proc_start;
5506
5507 int myargc = argc;
5508 char **myargv = argv;
5509
5510 hc_thread_mutex_init (mux_dispatcher);
5511 hc_thread_mutex_init (mux_counter);
5512 hc_thread_mutex_init (mux_display);
5513 hc_thread_mutex_init (mux_adl);
5514
5515 /**
5516 * commandline parameters
5517 */
5518
5519 uint usage = USAGE;
5520 uint version = VERSION;
5521 uint quiet = QUIET;
5522 uint benchmark = BENCHMARK;
5523 uint show = SHOW;
5524 uint left = LEFT;
5525 uint username = USERNAME;
5526 uint remove = REMOVE;
5527 uint remove_timer = REMOVE_TIMER;
5528 u64 skip = SKIP;
5529 u64 limit = LIMIT;
5530 uint keyspace = KEYSPACE;
5531 uint potfile_disable = POTFILE_DISABLE;
5532 char *potfile_path = NULL;
5533 uint debug_mode = DEBUG_MODE;
5534 char *debug_file = NULL;
5535 char *induction_dir = NULL;
5536 char *outfile_check_dir = NULL;
5537 uint force = FORCE;
5538 uint runtime = RUNTIME;
5539 uint hash_mode = HASH_MODE;
5540 uint attack_mode = ATTACK_MODE;
5541 uint markov_disable = MARKOV_DISABLE;
5542 uint markov_classic = MARKOV_CLASSIC;
5543 uint markov_threshold = MARKOV_THRESHOLD;
5544 char *markov_hcstat = NULL;
5545 char *outfile = NULL;
5546 uint outfile_format = OUTFILE_FORMAT;
5547 uint outfile_autohex = OUTFILE_AUTOHEX;
5548 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5549 uint restore = RESTORE;
5550 uint restore_timer = RESTORE_TIMER;
5551 uint restore_disable = RESTORE_DISABLE;
5552 uint status = STATUS;
5553 uint status_timer = STATUS_TIMER;
5554 uint machine_readable = MACHINE_READABLE;
5555 uint loopback = LOOPBACK;
5556 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5557 char *session = NULL;
5558 uint hex_charset = HEX_CHARSET;
5559 uint hex_salt = HEX_SALT;
5560 uint hex_wordlist = HEX_WORDLIST;
5561 uint rp_gen = RP_GEN;
5562 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5563 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5564 uint rp_gen_seed = RP_GEN_SEED;
5565 char *rule_buf_l = (char *) RULE_BUF_L;
5566 char *rule_buf_r = (char *) RULE_BUF_R;
5567 uint increment = INCREMENT;
5568 uint increment_min = INCREMENT_MIN;
5569 uint increment_max = INCREMENT_MAX;
5570 char *cpu_affinity = NULL;
5571 OCL_PTR *ocl = NULL;
5572 char *opencl_devices = NULL;
5573 char *opencl_platforms = NULL;
5574 char *opencl_device_types = NULL;
5575 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5576 char *truecrypt_keyfiles = NULL;
5577 char *veracrypt_keyfiles = NULL;
5578 uint veracrypt_pim = 0;
5579 uint workload_profile = WORKLOAD_PROFILE;
5580 uint kernel_accel = KERNEL_ACCEL;
5581 uint kernel_loops = KERNEL_LOOPS;
5582 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5583 #ifdef HAVE_HWMON
5584 uint gpu_temp_abort = GPU_TEMP_ABORT;
5585 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5586 uint powertune_enable = POWERTUNE_ENABLE;
5587 #endif
5588 uint logfile_disable = LOGFILE_DISABLE;
5589 uint segment_size = SEGMENT_SIZE;
5590 uint scrypt_tmto = SCRYPT_TMTO;
5591 char separator = SEPARATOR;
5592 uint bitmap_min = BITMAP_MIN;
5593 uint bitmap_max = BITMAP_MAX;
5594 char *custom_charset_1 = NULL;
5595 char *custom_charset_2 = NULL;
5596 char *custom_charset_3 = NULL;
5597 char *custom_charset_4 = NULL;
5598
5599 #define IDX_HELP 'h'
5600 #define IDX_VERSION 'V'
5601 #define IDX_VERSION_LOWER 'v'
5602 #define IDX_QUIET 0xff02
5603 #define IDX_SHOW 0xff03
5604 #define IDX_LEFT 0xff04
5605 #define IDX_REMOVE 0xff05
5606 #define IDX_REMOVE_TIMER 0xff37
5607 #define IDX_SKIP 's'
5608 #define IDX_LIMIT 'l'
5609 #define IDX_KEYSPACE 0xff35
5610 #define IDX_POTFILE_DISABLE 0xff06
5611 #define IDX_POTFILE_PATH 0xffe0
5612 #define IDX_DEBUG_MODE 0xff43
5613 #define IDX_DEBUG_FILE 0xff44
5614 #define IDX_INDUCTION_DIR 0xff46
5615 #define IDX_OUTFILE_CHECK_DIR 0xff47
5616 #define IDX_USERNAME 0xff07
5617 #define IDX_FORCE 0xff08
5618 #define IDX_RUNTIME 0xff09
5619 #define IDX_BENCHMARK 'b'
5620 #define IDX_HASH_MODE 'm'
5621 #define IDX_ATTACK_MODE 'a'
5622 #define IDX_RP_FILE 'r'
5623 #define IDX_RP_GEN 'g'
5624 #define IDX_RP_GEN_FUNC_MIN 0xff10
5625 #define IDX_RP_GEN_FUNC_MAX 0xff11
5626 #define IDX_RP_GEN_SEED 0xff34
5627 #define IDX_RULE_BUF_L 'j'
5628 #define IDX_RULE_BUF_R 'k'
5629 #define IDX_INCREMENT 'i'
5630 #define IDX_INCREMENT_MIN 0xff12
5631 #define IDX_INCREMENT_MAX 0xff13
5632 #define IDX_OUTFILE 'o'
5633 #define IDX_OUTFILE_FORMAT 0xff14
5634 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5635 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5636 #define IDX_RESTORE 0xff15
5637 #define IDX_RESTORE_DISABLE 0xff27
5638 #define IDX_STATUS 0xff17
5639 #define IDX_STATUS_TIMER 0xff18
5640 #define IDX_MACHINE_READABLE 0xff50
5641 #define IDX_LOOPBACK 0xff38
5642 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5643 #define IDX_SESSION 0xff19
5644 #define IDX_HEX_CHARSET 0xff20
5645 #define IDX_HEX_SALT 0xff21
5646 #define IDX_HEX_WORDLIST 0xff40
5647 #define IDX_MARKOV_DISABLE 0xff22
5648 #define IDX_MARKOV_CLASSIC 0xff23
5649 #define IDX_MARKOV_THRESHOLD 't'
5650 #define IDX_MARKOV_HCSTAT 0xff24
5651 #define IDX_CPU_AFFINITY 0xff25
5652 #define IDX_OPENCL_DEVICES 'd'
5653 #define IDX_OPENCL_PLATFORMS 0xff72
5654 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5655 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5656 #define IDX_WORKLOAD_PROFILE 'w'
5657 #define IDX_KERNEL_ACCEL 'n'
5658 #define IDX_KERNEL_LOOPS 'u'
5659 #define IDX_GPU_TEMP_DISABLE 0xff29
5660 #define IDX_GPU_TEMP_ABORT 0xff30
5661 #define IDX_GPU_TEMP_RETAIN 0xff31
5662 #define IDX_POWERTUNE_ENABLE 0xff41
5663 #define IDX_LOGFILE_DISABLE 0xff51
5664 #define IDX_TRUECRYPT_KEYFILES 0xff52
5665 #define IDX_VERACRYPT_KEYFILES 0xff53
5666 #define IDX_VERACRYPT_PIM 0xff54
5667 #define IDX_SCRYPT_TMTO 0xff61
5668 #define IDX_SEGMENT_SIZE 'c'
5669 #define IDX_SEPARATOR 'p'
5670 #define IDX_BITMAP_MIN 0xff70
5671 #define IDX_BITMAP_MAX 0xff71
5672 #define IDX_CUSTOM_CHARSET_1 '1'
5673 #define IDX_CUSTOM_CHARSET_2 '2'
5674 #define IDX_CUSTOM_CHARSET_3 '3'
5675 #define IDX_CUSTOM_CHARSET_4 '4'
5676
5677 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5678
5679 struct option long_options[] =
5680 {
5681 {"help", no_argument, 0, IDX_HELP},
5682 {"version", no_argument, 0, IDX_VERSION},
5683 {"quiet", no_argument, 0, IDX_QUIET},
5684 {"show", no_argument, 0, IDX_SHOW},
5685 {"left", no_argument, 0, IDX_LEFT},
5686 {"username", no_argument, 0, IDX_USERNAME},
5687 {"remove", no_argument, 0, IDX_REMOVE},
5688 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5689 {"skip", required_argument, 0, IDX_SKIP},
5690 {"limit", required_argument, 0, IDX_LIMIT},
5691 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5692 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5693 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5694 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5695 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5696 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5697 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5698 {"force", no_argument, 0, IDX_FORCE},
5699 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5700 {"restore", no_argument, 0, IDX_RESTORE},
5701 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5702 {"status", no_argument, 0, IDX_STATUS},
5703 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5704 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5705 {"loopback", no_argument, 0, IDX_LOOPBACK},
5706 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5707 {"session", required_argument, 0, IDX_SESSION},
5708 {"runtime", required_argument, 0, IDX_RUNTIME},
5709 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5710 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5711 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5712 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5713 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5714 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5715 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5716 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5717 {"rules-file", required_argument, 0, IDX_RP_FILE},
5718 {"outfile", required_argument, 0, IDX_OUTFILE},
5719 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5720 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5721 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5722 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5723 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5724 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5725 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5726 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5727 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5728 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5729 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5730 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5731 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5732 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5733 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5734 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5735 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5736 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5737 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5738 #ifdef HAVE_HWMON
5739 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5740 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5741 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5742 #endif // HAVE_HWMON
5743 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5744 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5745 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5746 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5747 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5748 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5749 {"seperator", required_argument, 0, IDX_SEPARATOR},
5750 {"separator", required_argument, 0, IDX_SEPARATOR},
5751 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5752 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5753 {"increment", no_argument, 0, IDX_INCREMENT},
5754 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5755 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5756 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5757 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5758 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5759 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5760 {0, 0, 0, 0}
5761 };
5762
5763 uint rp_files_cnt = 0;
5764
5765 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5766
5767 int option_index = 0;
5768 int c = -1;
5769
5770 optind = 1;
5771 optopt = 0;
5772
5773 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5774 {
5775 switch (c)
5776 {
5777 case IDX_HELP: usage = 1; break;
5778 case IDX_VERSION:
5779 case IDX_VERSION_LOWER: version = 1; break;
5780 case IDX_RESTORE: restore = 1; break;
5781 case IDX_SESSION: session = optarg; break;
5782 case IDX_SHOW: show = 1; break;
5783 case IDX_LEFT: left = 1; break;
5784 case '?': return (-1);
5785 }
5786 }
5787
5788 if (optopt != 0)
5789 {
5790 log_error ("ERROR: Invalid argument specified");
5791
5792 return (-1);
5793 }
5794
5795 /**
5796 * exit functions
5797 */
5798
5799 if (version)
5800 {
5801 log_info ("%s", VERSION_TAG);
5802
5803 return (0);
5804 }
5805
5806 if (usage)
5807 {
5808 usage_big_print (PROGNAME);
5809
5810 return (0);
5811 }
5812
5813 /**
5814 * session needs to be set, always!
5815 */
5816
5817 if (session == NULL) session = (char *) PROGNAME;
5818
5819 /**
5820 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5821 */
5822
5823 char *exec_path = get_exec_path ();
5824
5825 #ifdef LINUX
5826
5827 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5828 char *resolved_exec_path = realpath (exec_path, NULL);
5829
5830 char *install_dir = get_install_dir (resolved_exec_path);
5831 char *profile_dir = NULL;
5832 char *session_dir = NULL;
5833 char *shared_dir = NULL;
5834
5835 if (strcmp (install_dir, resolved_install_folder) == 0)
5836 {
5837 struct passwd *pw = getpwuid (getuid ());
5838
5839 const char *homedir = pw->pw_dir;
5840
5841 profile_dir = get_profile_dir (homedir);
5842 session_dir = get_session_dir (profile_dir);
5843 shared_dir = strdup (SHARED_FOLDER);
5844
5845 mkdir (profile_dir, 0700);
5846 mkdir (session_dir, 0700);
5847 }
5848 else
5849 {
5850 profile_dir = install_dir;
5851 session_dir = install_dir;
5852 shared_dir = install_dir;
5853 }
5854
5855 myfree (resolved_install_folder);
5856 myfree (resolved_exec_path);
5857
5858 #else
5859
5860 char *install_dir = get_install_dir (exec_path);
5861 char *profile_dir = install_dir;
5862 char *session_dir = install_dir;
5863 char *shared_dir = install_dir;
5864
5865 #endif
5866
5867 data.install_dir = install_dir;
5868 data.profile_dir = profile_dir;
5869 data.session_dir = session_dir;
5870 data.shared_dir = shared_dir;
5871
5872 myfree (exec_path);
5873
5874 /**
5875 * kernel cache, we need to make sure folder exist
5876 */
5877
5878 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5879
5880 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5881
5882 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5883
5884 mkdir (kernels_folder, 0700);
5885
5886 myfree (kernels_folder);
5887
5888 /**
5889 * session
5890 */
5891
5892 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5893
5894 data.session = session;
5895
5896 char *eff_restore_file = (char *) mymalloc (session_size);
5897 char *new_restore_file = (char *) mymalloc (session_size);
5898
5899 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5900 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5901
5902 data.eff_restore_file = eff_restore_file;
5903 data.new_restore_file = new_restore_file;
5904
5905 if (((show == 1) || (left == 1)) && (restore == 1))
5906 {
5907 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5908 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5909
5910 return (-1);
5911 }
5912
5913 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5914 if ((show == 1) || (left == 1))
5915 {
5916 restore_disable = 1;
5917
5918 restore = 0;
5919 }
5920
5921 data.restore_disable = restore_disable;
5922
5923 restore_data_t *rd = init_restore (argc, argv);
5924
5925 data.rd = rd;
5926
5927 /**
5928 * restore file
5929 */
5930
5931 if (restore == 1)
5932 {
5933 read_restore (eff_restore_file, rd);
5934
5935 if (rd->version_bin < RESTORE_MIN)
5936 {
5937 log_error ("ERROR: Incompatible restore-file version");
5938
5939 return (-1);
5940 }
5941
5942 myargc = rd->argc;
5943 myargv = rd->argv;
5944
5945 #ifdef _POSIX
5946 rd->pid = getpid ();
5947 #elif _WIN
5948 rd->pid = GetCurrentProcessId ();
5949 #endif
5950 }
5951
5952 uint hash_mode_chgd = 0;
5953 uint runtime_chgd = 0;
5954 uint kernel_loops_chgd = 0;
5955 uint kernel_accel_chgd = 0;
5956 uint attack_mode_chgd = 0;
5957 uint outfile_format_chgd = 0;
5958 uint rp_gen_seed_chgd = 0;
5959 uint remove_timer_chgd = 0;
5960 uint increment_min_chgd = 0;
5961 uint increment_max_chgd = 0;
5962 uint workload_profile_chgd = 0;
5963 uint opencl_vector_width_chgd = 0;
5964
5965 optind = 1;
5966 optopt = 0;
5967 option_index = 0;
5968
5969 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5970 {
5971 switch (c)
5972 {
5973 //case IDX_HELP: usage = 1; break;
5974 //case IDX_VERSION: version = 1; break;
5975 //case IDX_RESTORE: restore = 1; break;
5976 case IDX_QUIET: quiet = 1; break;
5977 //case IDX_SHOW: show = 1; break;
5978 case IDX_SHOW: break;
5979 //case IDX_LEFT: left = 1; break;
5980 case IDX_LEFT: break;
5981 case IDX_USERNAME: username = 1; break;
5982 case IDX_REMOVE: remove = 1; break;
5983 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5984 remove_timer_chgd = 1; break;
5985 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5986 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5987 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5988 case IDX_DEBUG_FILE: debug_file = optarg; break;
5989 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5990 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5991 case IDX_FORCE: force = 1; break;
5992 case IDX_SKIP: skip = atoll (optarg); break;
5993 case IDX_LIMIT: limit = atoll (optarg); break;
5994 case IDX_KEYSPACE: keyspace = 1; break;
5995 case IDX_BENCHMARK: benchmark = 1; break;
5996 case IDX_RESTORE: break;
5997 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5998 case IDX_STATUS: status = 1; break;
5999 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6000 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6001 case IDX_LOOPBACK: loopback = 1; break;
6002 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6003 //case IDX_SESSION: session = optarg; break;
6004 case IDX_SESSION: break;
6005 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6006 hash_mode_chgd = 1; break;
6007 case IDX_RUNTIME: runtime = atoi (optarg);
6008 runtime_chgd = 1; break;
6009 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6010 attack_mode_chgd = 1; break;
6011 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6012 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6013 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6014 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6015 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6016 rp_gen_seed_chgd = 1; break;
6017 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6018 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6019 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6020 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6021 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6022 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6023 case IDX_OUTFILE: outfile = optarg; break;
6024 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6025 outfile_format_chgd = 1; break;
6026 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6027 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6028 case IDX_HEX_CHARSET: hex_charset = 1; break;
6029 case IDX_HEX_SALT: hex_salt = 1; break;
6030 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6031 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6032 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6033 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6034 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6035 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6036 opencl_vector_width_chgd = 1; break;
6037 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6038 workload_profile_chgd = 1; break;
6039 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6040 kernel_accel_chgd = 1; break;
6041 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6042 kernel_loops_chgd = 1; break;
6043 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6044 #ifdef HAVE_HWMON
6045 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6046 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6047 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6048 #endif // HAVE_HWMON
6049 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6050 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6051 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6052 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6053 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6054 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6055 case IDX_SEPARATOR: separator = optarg[0]; break;
6056 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6057 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6058 case IDX_INCREMENT: increment = 1; break;
6059 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6060 increment_min_chgd = 1; break;
6061 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6062 increment_max_chgd = 1; break;
6063 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6064 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6065 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6066 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6067
6068 default:
6069 log_error ("ERROR: Invalid argument specified");
6070 return (-1);
6071 }
6072 }
6073
6074 if (optopt != 0)
6075 {
6076 log_error ("ERROR: Invalid argument specified");
6077
6078 return (-1);
6079 }
6080
6081 /**
6082 * Inform user things getting started,
6083 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6084 * - we do not need to check algorithm_pos
6085 */
6086
6087 if (quiet == 0)
6088 {
6089 if (benchmark == 1)
6090 {
6091 if (machine_readable == 0)
6092 {
6093 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6094 log_info ("");
6095 }
6096 else
6097 {
6098 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6099 }
6100 }
6101 else if (restore == 1)
6102 {
6103 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6104 log_info ("");
6105 }
6106 else
6107 {
6108 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6109 log_info ("");
6110 }
6111 }
6112
6113 /**
6114 * sanity check
6115 */
6116
6117 if (attack_mode > 7)
6118 {
6119 log_error ("ERROR: Invalid attack-mode specified");
6120
6121 return (-1);
6122 }
6123
6124 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6125 {
6126 log_error ("ERROR: Invalid runtime specified");
6127
6128 return (-1);
6129 }
6130
6131 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6132 {
6133 log_error ("ERROR: Invalid hash-type specified");
6134
6135 return (-1);
6136 }
6137
6138 // renamed hash modes
6139
6140 if (hash_mode_chgd)
6141 {
6142 int n = -1;
6143
6144 switch (hash_mode)
6145 {
6146 case 123: n = 124;
6147 break;
6148 }
6149
6150 if (n >= 0)
6151 {
6152 log_error ("Old -m specified, use -m %d instead", n);
6153
6154 return (-1);
6155 }
6156 }
6157
6158 if (username == 1)
6159 {
6160 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6161 {
6162 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6163
6164 return (-1);
6165 }
6166 }
6167
6168 if (outfile_format > 16)
6169 {
6170 log_error ("ERROR: Invalid outfile-format specified");
6171
6172 return (-1);
6173 }
6174
6175 if (left == 1)
6176 {
6177 if (outfile_format_chgd == 1)
6178 {
6179 if (outfile_format > 1)
6180 {
6181 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6182
6183 return (-1);
6184 }
6185 }
6186 else
6187 {
6188 outfile_format = OUTFILE_FMT_HASH;
6189 }
6190 }
6191
6192 if (show == 1)
6193 {
6194 if (outfile_format_chgd == 1)
6195 {
6196 if ((outfile_format > 7) && (outfile_format < 16))
6197 {
6198 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6199
6200 return (-1);
6201 }
6202 }
6203 }
6204
6205 if (increment_min < INCREMENT_MIN)
6206 {
6207 log_error ("ERROR: Invalid increment-min specified");
6208
6209 return (-1);
6210 }
6211
6212 if (increment_max > INCREMENT_MAX)
6213 {
6214 log_error ("ERROR: Invalid increment-max specified");
6215
6216 return (-1);
6217 }
6218
6219 if (increment_min > increment_max)
6220 {
6221 log_error ("ERROR: Invalid increment-min specified");
6222
6223 return (-1);
6224 }
6225
6226 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6227 {
6228 log_error ("ERROR: increment is not allowed in attack-mode 0");
6229
6230 return (-1);
6231 }
6232
6233 if ((increment == 0) && (increment_min_chgd == 1))
6234 {
6235 log_error ("ERROR: increment-min is only supported together with increment switch");
6236
6237 return (-1);
6238 }
6239
6240 if ((increment == 0) && (increment_max_chgd == 1))
6241 {
6242 log_error ("ERROR: increment-max is only supported together with increment switch");
6243
6244 return (-1);
6245 }
6246
6247 if (rp_files_cnt && rp_gen)
6248 {
6249 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6250
6251 return (-1);
6252 }
6253
6254 if (rp_files_cnt || rp_gen)
6255 {
6256 if (attack_mode != ATTACK_MODE_STRAIGHT)
6257 {
6258 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6259
6260 return (-1);
6261 }
6262 }
6263
6264 if (rp_gen_func_min > rp_gen_func_max)
6265 {
6266 log_error ("ERROR: Invalid rp-gen-func-min specified");
6267
6268 return (-1);
6269 }
6270
6271 if (kernel_accel_chgd == 1)
6272 {
6273 if (force == 0)
6274 {
6275 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6276 log_info ("Please consider using the option -w instead");
6277 log_info ("You can use --force to override this but do not post error reports if you do so");
6278 log_info ("");
6279
6280 return (-1);
6281 }
6282
6283 if (kernel_accel < 1)
6284 {
6285 log_error ("ERROR: Invalid kernel-accel specified");
6286
6287 return (-1);
6288 }
6289
6290 if (kernel_accel > 1024)
6291 {
6292 log_error ("ERROR: Invalid kernel-accel specified");
6293
6294 return (-1);
6295 }
6296 }
6297
6298 if (kernel_loops_chgd == 1)
6299 {
6300 if (force == 0)
6301 {
6302 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6303 log_info ("Please consider using the option -w instead");
6304 log_info ("You can use --force to override this but do not post error reports if you do so");
6305 log_info ("");
6306
6307 return (-1);
6308 }
6309
6310 if (kernel_loops < 1)
6311 {
6312 log_error ("ERROR: Invalid kernel-loops specified");
6313
6314 return (-1);
6315 }
6316
6317 if (kernel_loops > 1024)
6318 {
6319 log_error ("ERROR: Invalid kernel-loops specified");
6320
6321 return (-1);
6322 }
6323 }
6324
6325 if ((workload_profile < 1) || (workload_profile > 4))
6326 {
6327 log_error ("ERROR: workload-profile %i not available", workload_profile);
6328
6329 return (-1);
6330 }
6331
6332 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6333 {
6334 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6335
6336 return (-1);
6337 }
6338
6339 if (show == 1 || left == 1)
6340 {
6341 attack_mode = ATTACK_MODE_NONE;
6342
6343 if (remove == 1)
6344 {
6345 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6346
6347 return (-1);
6348 }
6349
6350 if (potfile_disable == 1)
6351 {
6352 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6353
6354 return (-1);
6355 }
6356 }
6357
6358 uint attack_kern = ATTACK_KERN_NONE;
6359
6360 switch (attack_mode)
6361 {
6362 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6363 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6364 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6365 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6366 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6367 }
6368
6369 if (benchmark == 0)
6370 {
6371 if (keyspace == 1)
6372 {
6373 int num_additional_params = 1;
6374
6375 if (attack_kern == ATTACK_KERN_COMBI)
6376 {
6377 num_additional_params = 2;
6378 }
6379
6380 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6381
6382 if (keyspace_wordlist_specified == 0) optind--;
6383 }
6384
6385 if (attack_kern == ATTACK_KERN_NONE)
6386 {
6387 if ((optind + 1) != myargc)
6388 {
6389 usage_mini_print (myargv[0]);
6390
6391 return (-1);
6392 }
6393 }
6394 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6395 {
6396 if ((optind + 1) > myargc)
6397 {
6398 usage_mini_print (myargv[0]);
6399
6400 return (-1);
6401 }
6402 }
6403 else if (attack_kern == ATTACK_KERN_COMBI)
6404 {
6405 if ((optind + 3) != myargc)
6406 {
6407 usage_mini_print (myargv[0]);
6408
6409 return (-1);
6410 }
6411 }
6412 else if (attack_kern == ATTACK_KERN_BF)
6413 {
6414 if ((optind + 1) > myargc)
6415 {
6416 usage_mini_print (myargv[0]);
6417
6418 return (-1);
6419 }
6420 }
6421 else
6422 {
6423 usage_mini_print (myargv[0]);
6424
6425 return (-1);
6426 }
6427 }
6428 else
6429 {
6430 if (myargv[optind] != 0)
6431 {
6432 log_error ("ERROR: Invalid argument for benchmark mode specified");
6433
6434 return (-1);
6435 }
6436
6437 if (attack_mode_chgd == 1)
6438 {
6439 if (attack_mode != ATTACK_MODE_BF)
6440 {
6441 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6442
6443 return (-1);
6444 }
6445 }
6446 }
6447
6448 if (skip != 0 && limit != 0)
6449 {
6450 limit += skip;
6451 }
6452
6453 if (keyspace == 1)
6454 {
6455 if (show == 1)
6456 {
6457 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6458
6459 return (-1);
6460 }
6461 else if (left == 1)
6462 {
6463 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6464
6465 return (-1);
6466 }
6467
6468 potfile_disable = 1;
6469
6470 restore_disable = 1;
6471
6472 restore = 0;
6473
6474 weak_hash_threshold = 0;
6475
6476 quiet = 1;
6477 }
6478
6479 if (remove_timer_chgd == 1)
6480 {
6481 if (remove == 0)
6482 {
6483 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6484
6485 return (-1);
6486 }
6487
6488 if (remove_timer < 1)
6489 {
6490 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6491
6492 return (-1);
6493 }
6494 }
6495
6496 if (loopback == 1)
6497 {
6498 if (attack_mode == ATTACK_MODE_STRAIGHT)
6499 {
6500 if ((rp_files_cnt == 0) && (rp_gen == 0))
6501 {
6502 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6503
6504 return (-1);
6505 }
6506 }
6507 else
6508 {
6509 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6510
6511 return (-1);
6512 }
6513 }
6514
6515 if (debug_mode > 0)
6516 {
6517 if (attack_mode != ATTACK_MODE_STRAIGHT)
6518 {
6519 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6520
6521 return (-1);
6522 }
6523
6524 if ((rp_files_cnt == 0) && (rp_gen == 0))
6525 {
6526 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6527
6528 return (-1);
6529 }
6530 }
6531
6532 if (debug_mode > 4)
6533 {
6534 log_error ("ERROR: Invalid debug-mode specified");
6535
6536 return (-1);
6537 }
6538
6539 if (debug_file != NULL)
6540 {
6541 if (debug_mode < 1)
6542 {
6543 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6544
6545 return (-1);
6546 }
6547 }
6548
6549 if (induction_dir != NULL)
6550 {
6551 if (attack_mode == ATTACK_MODE_BF)
6552 {
6553 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6554
6555 return (-1);
6556 }
6557 }
6558
6559 if (attack_mode != ATTACK_MODE_STRAIGHT)
6560 {
6561 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6562 {
6563 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6564
6565 return (-1);
6566 }
6567
6568 weak_hash_threshold = 0;
6569 }
6570
6571 /**
6572 * induction directory
6573 */
6574
6575 char *induction_directory = NULL;
6576
6577 if (attack_mode != ATTACK_MODE_BF)
6578 {
6579 if (induction_dir == NULL)
6580 {
6581 induction_directory = (char *) mymalloc (session_size);
6582
6583 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6584
6585 // create induction folder if it does not already exist
6586
6587 if (keyspace == 0)
6588 {
6589 if (rmdir (induction_directory) == -1)
6590 {
6591 if (errno == ENOENT)
6592 {
6593 // good, we can ignore
6594 }
6595 else if (errno == ENOTEMPTY)
6596 {
6597 char *induction_directory_mv = (char *) mymalloc (session_size);
6598
6599 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6600
6601 if (rename (induction_directory, induction_directory_mv) != 0)
6602 {
6603 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6604
6605 return (-1);
6606 }
6607 }
6608 else
6609 {
6610 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6611
6612 return (-1);
6613 }
6614 }
6615
6616 if (mkdir (induction_directory, 0700) == -1)
6617 {
6618 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6619
6620 return (-1);
6621 }
6622 }
6623 }
6624 else
6625 {
6626 induction_directory = induction_dir;
6627 }
6628 }
6629
6630 data.induction_directory = induction_directory;
6631
6632 /**
6633 * loopback
6634 */
6635
6636 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6637
6638 char *loopback_file = (char *) mymalloc (loopback_size);
6639
6640 /**
6641 * tuning db
6642 */
6643
6644 char tuning_db_file[256] = { 0 };
6645
6646 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6647
6648 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6649
6650 /**
6651 * outfile-check directory
6652 */
6653
6654 char *outfile_check_directory = NULL;
6655
6656 if (outfile_check_dir == NULL)
6657 {
6658 outfile_check_directory = (char *) mymalloc (session_size);
6659
6660 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6661 }
6662 else
6663 {
6664 outfile_check_directory = outfile_check_dir;
6665 }
6666
6667 data.outfile_check_directory = outfile_check_directory;
6668
6669 if (keyspace == 0)
6670 {
6671 struct stat outfile_check_stat;
6672
6673 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6674 {
6675 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6676
6677 if (is_dir == 0)
6678 {
6679 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6680
6681 return (-1);
6682 }
6683 }
6684 else if (outfile_check_dir == NULL)
6685 {
6686 if (mkdir (outfile_check_directory, 0700) == -1)
6687 {
6688 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6689
6690 return (-1);
6691 }
6692 }
6693 }
6694
6695 /**
6696 * special other stuff
6697 */
6698
6699 if (hash_mode == 9710)
6700 {
6701 outfile_format = 5;
6702 outfile_format_chgd = 1;
6703 }
6704
6705 if (hash_mode == 9810)
6706 {
6707 outfile_format = 5;
6708 outfile_format_chgd = 1;
6709 }
6710
6711 if (hash_mode == 10410)
6712 {
6713 outfile_format = 5;
6714 outfile_format_chgd = 1;
6715 }
6716
6717 /**
6718 * store stuff
6719 */
6720
6721 data.hash_mode = hash_mode;
6722 data.restore = restore;
6723 data.restore_timer = restore_timer;
6724 data.restore_disable = restore_disable;
6725 data.status = status;
6726 data.status_timer = status_timer;
6727 data.machine_readable = machine_readable;
6728 data.loopback = loopback;
6729 data.runtime = runtime;
6730 data.remove = remove;
6731 data.remove_timer = remove_timer;
6732 data.debug_mode = debug_mode;
6733 data.debug_file = debug_file;
6734 data.username = username;
6735 data.quiet = quiet;
6736 data.outfile = outfile;
6737 data.outfile_format = outfile_format;
6738 data.outfile_autohex = outfile_autohex;
6739 data.hex_charset = hex_charset;
6740 data.hex_salt = hex_salt;
6741 data.hex_wordlist = hex_wordlist;
6742 data.separator = separator;
6743 data.rp_files = rp_files;
6744 data.rp_files_cnt = rp_files_cnt;
6745 data.rp_gen = rp_gen;
6746 data.rp_gen_seed = rp_gen_seed;
6747 data.force = force;
6748 data.benchmark = benchmark;
6749 data.skip = skip;
6750 data.limit = limit;
6751 #ifdef HAVE_HWMON
6752 data.powertune_enable = powertune_enable;
6753 #endif
6754 data.logfile_disable = logfile_disable;
6755 data.truecrypt_keyfiles = truecrypt_keyfiles;
6756 data.veracrypt_keyfiles = veracrypt_keyfiles;
6757 data.veracrypt_pim = veracrypt_pim;
6758 data.scrypt_tmto = scrypt_tmto;
6759 data.workload_profile = workload_profile;
6760
6761 /**
6762 * cpu affinity
6763 */
6764
6765 if (cpu_affinity)
6766 {
6767 set_cpu_affinity (cpu_affinity);
6768 }
6769
6770 if (rp_gen_seed_chgd == 0)
6771 {
6772 srand (proc_start);
6773 }
6774 else
6775 {
6776 srand (rp_gen_seed);
6777 }
6778
6779 /**
6780 * logfile init
6781 */
6782
6783 if (logfile_disable == 0)
6784 {
6785 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6786
6787 char *logfile = (char *) mymalloc (logfile_size);
6788
6789 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6790
6791 data.logfile = logfile;
6792
6793 char *topid = logfile_generate_topid ();
6794
6795 data.topid = topid;
6796 }
6797
6798 // logfile_append() checks for logfile_disable internally to make it easier from here
6799
6800 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6801 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6802 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6803 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6804 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6805 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6806 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6807 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6808 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6809 #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));
6810
6811 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6812 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6813 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6814 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6815 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6816 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6817 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6818 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6819
6820 logfile_top_msg ("START");
6821
6822 logfile_top_uint (attack_mode);
6823 logfile_top_uint (attack_kern);
6824 logfile_top_uint (benchmark);
6825 logfile_top_uint (bitmap_min);
6826 logfile_top_uint (bitmap_max);
6827 logfile_top_uint (debug_mode);
6828 logfile_top_uint (force);
6829 logfile_top_uint (kernel_accel);
6830 logfile_top_uint (kernel_loops);
6831 logfile_top_uint (gpu_temp_disable);
6832 #ifdef HAVE_HWMON
6833 logfile_top_uint (gpu_temp_abort);
6834 logfile_top_uint (gpu_temp_retain);
6835 #endif
6836 logfile_top_uint (hash_mode);
6837 logfile_top_uint (hex_charset);
6838 logfile_top_uint (hex_salt);
6839 logfile_top_uint (hex_wordlist);
6840 logfile_top_uint (increment);
6841 logfile_top_uint (increment_max);
6842 logfile_top_uint (increment_min);
6843 logfile_top_uint (keyspace);
6844 logfile_top_uint (left);
6845 logfile_top_uint (logfile_disable);
6846 logfile_top_uint (loopback);
6847 logfile_top_uint (markov_classic);
6848 logfile_top_uint (markov_disable);
6849 logfile_top_uint (markov_threshold);
6850 logfile_top_uint (outfile_autohex);
6851 logfile_top_uint (outfile_check_timer);
6852 logfile_top_uint (outfile_format);
6853 logfile_top_uint (potfile_disable);
6854 logfile_top_string (potfile_path);
6855 #if defined(HAVE_HWMON)
6856 logfile_top_uint (powertune_enable);
6857 #endif
6858 logfile_top_uint (scrypt_tmto);
6859 logfile_top_uint (quiet);
6860 logfile_top_uint (remove);
6861 logfile_top_uint (remove_timer);
6862 logfile_top_uint (restore);
6863 logfile_top_uint (restore_disable);
6864 logfile_top_uint (restore_timer);
6865 logfile_top_uint (rp_gen);
6866 logfile_top_uint (rp_gen_func_max);
6867 logfile_top_uint (rp_gen_func_min);
6868 logfile_top_uint (rp_gen_seed);
6869 logfile_top_uint (runtime);
6870 logfile_top_uint (segment_size);
6871 logfile_top_uint (show);
6872 logfile_top_uint (status);
6873 logfile_top_uint (machine_readable);
6874 logfile_top_uint (status_timer);
6875 logfile_top_uint (usage);
6876 logfile_top_uint (username);
6877 logfile_top_uint (version);
6878 logfile_top_uint (weak_hash_threshold);
6879 logfile_top_uint (workload_profile);
6880 logfile_top_uint64 (limit);
6881 logfile_top_uint64 (skip);
6882 logfile_top_char (separator);
6883 logfile_top_string (cpu_affinity);
6884 logfile_top_string (custom_charset_1);
6885 logfile_top_string (custom_charset_2);
6886 logfile_top_string (custom_charset_3);
6887 logfile_top_string (custom_charset_4);
6888 logfile_top_string (debug_file);
6889 logfile_top_string (opencl_devices);
6890 logfile_top_string (opencl_platforms);
6891 logfile_top_string (opencl_device_types);
6892 logfile_top_uint (opencl_vector_width);
6893 logfile_top_string (induction_dir);
6894 logfile_top_string (markov_hcstat);
6895 logfile_top_string (outfile);
6896 logfile_top_string (outfile_check_dir);
6897 logfile_top_string (rule_buf_l);
6898 logfile_top_string (rule_buf_r);
6899 logfile_top_string (session);
6900 logfile_top_string (truecrypt_keyfiles);
6901 logfile_top_string (veracrypt_keyfiles);
6902 logfile_top_uint (veracrypt_pim);
6903
6904 /**
6905 * Init OpenCL library loader
6906 */
6907
6908 if (keyspace == 0)
6909 {
6910 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6911
6912 ocl_init (ocl);
6913
6914 data.ocl = ocl;
6915 }
6916
6917 /**
6918 * OpenCL platform selection
6919 */
6920
6921 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6922
6923 /**
6924 * OpenCL device selection
6925 */
6926
6927 u32 devices_filter = setup_devices_filter (opencl_devices);
6928
6929 /**
6930 * OpenCL device type selection
6931 */
6932
6933 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6934
6935 /**
6936 * benchmark
6937 */
6938
6939 if (benchmark == 1)
6940 {
6941 /**
6942 * disable useless stuff for benchmark
6943 */
6944
6945 status_timer = 0;
6946 restore_timer = 0;
6947 restore_disable = 1;
6948 potfile_disable = 1;
6949 weak_hash_threshold = 0;
6950 gpu_temp_disable = 1;
6951
6952 #ifdef HAVE_HWMON
6953 powertune_enable = 1;
6954 #endif
6955
6956 data.status_timer = status_timer;
6957 data.restore_timer = restore_timer;
6958 data.restore_disable = restore_disable;
6959
6960 /**
6961 * force attack mode to be bruteforce
6962 */
6963
6964 attack_mode = ATTACK_MODE_BF;
6965 attack_kern = ATTACK_KERN_BF;
6966
6967 if (workload_profile_chgd == 0)
6968 {
6969 workload_profile = 3;
6970
6971 data.workload_profile = workload_profile;
6972 }
6973 }
6974
6975 /**
6976 * config
6977 */
6978
6979 uint hash_type = 0;
6980 uint salt_type = 0;
6981 uint attack_exec = 0;
6982 uint opts_type = 0;
6983 uint kern_type = 0;
6984 uint dgst_size = 0;
6985 uint esalt_size = 0;
6986 uint opti_type = 0;
6987 uint dgst_pos0 = -1;
6988 uint dgst_pos1 = -1;
6989 uint dgst_pos2 = -1;
6990 uint dgst_pos3 = -1;
6991
6992 int (*parse_func) (char *, uint, hash_t *);
6993 int (*sort_by_digest) (const void *, const void *);
6994
6995 uint algorithm_pos = 0;
6996 uint algorithm_max = 1;
6997
6998 uint *algorithms = default_benchmark_algorithms;
6999
7000 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7001
7002 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7003 {
7004 /*
7005 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7006 * the following algos are skipped entirely
7007 */
7008
7009 if (algorithm_pos > 0)
7010 {
7011 local_free (rd);
7012
7013 rd = init_restore (argc, argv);
7014
7015 data.rd = rd;
7016 }
7017
7018 /**
7019 * update hash_mode in case of multihash benchmark
7020 */
7021
7022 if (benchmark == 1)
7023 {
7024 if (hash_mode_chgd == 0)
7025 {
7026 hash_mode = algorithms[algorithm_pos];
7027
7028 data.hash_mode = hash_mode;
7029 }
7030
7031 quiet = 1;
7032
7033 data.quiet = quiet;
7034 }
7035
7036 switch (hash_mode)
7037 {
7038 case 0: hash_type = HASH_TYPE_MD5;
7039 salt_type = SALT_TYPE_NONE;
7040 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7041 opts_type = OPTS_TYPE_PT_GENERATE_LE
7042 | OPTS_TYPE_PT_ADD80
7043 | OPTS_TYPE_PT_ADDBITS14;
7044 kern_type = KERN_TYPE_MD5;
7045 dgst_size = DGST_SIZE_4_4;
7046 parse_func = md5_parse_hash;
7047 sort_by_digest = sort_by_digest_4_4;
7048 opti_type = OPTI_TYPE_ZERO_BYTE
7049 | OPTI_TYPE_PRECOMPUTE_INIT
7050 | OPTI_TYPE_PRECOMPUTE_MERKLE
7051 | OPTI_TYPE_MEET_IN_MIDDLE
7052 | OPTI_TYPE_EARLY_SKIP
7053 | OPTI_TYPE_NOT_ITERATED
7054 | OPTI_TYPE_NOT_SALTED
7055 | OPTI_TYPE_RAW_HASH;
7056 dgst_pos0 = 0;
7057 dgst_pos1 = 3;
7058 dgst_pos2 = 2;
7059 dgst_pos3 = 1;
7060 break;
7061
7062 case 10: hash_type = HASH_TYPE_MD5;
7063 salt_type = SALT_TYPE_INTERN;
7064 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7065 opts_type = OPTS_TYPE_PT_GENERATE_LE
7066 | OPTS_TYPE_ST_ADD80
7067 | OPTS_TYPE_ST_ADDBITS14;
7068 kern_type = KERN_TYPE_MD5_PWSLT;
7069 dgst_size = DGST_SIZE_4_4;
7070 parse_func = md5s_parse_hash;
7071 sort_by_digest = sort_by_digest_4_4;
7072 opti_type = OPTI_TYPE_ZERO_BYTE
7073 | OPTI_TYPE_PRECOMPUTE_INIT
7074 | OPTI_TYPE_PRECOMPUTE_MERKLE
7075 | OPTI_TYPE_MEET_IN_MIDDLE
7076 | OPTI_TYPE_EARLY_SKIP
7077 | OPTI_TYPE_NOT_ITERATED
7078 | OPTI_TYPE_APPENDED_SALT
7079 | OPTI_TYPE_RAW_HASH;
7080 dgst_pos0 = 0;
7081 dgst_pos1 = 3;
7082 dgst_pos2 = 2;
7083 dgst_pos3 = 1;
7084 break;
7085
7086 case 11: hash_type = HASH_TYPE_MD5;
7087 salt_type = SALT_TYPE_INTERN;
7088 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7089 opts_type = OPTS_TYPE_PT_GENERATE_LE
7090 | OPTS_TYPE_ST_ADD80
7091 | OPTS_TYPE_ST_ADDBITS14;
7092 kern_type = KERN_TYPE_MD5_PWSLT;
7093 dgst_size = DGST_SIZE_4_4;
7094 parse_func = joomla_parse_hash;
7095 sort_by_digest = sort_by_digest_4_4;
7096 opti_type = OPTI_TYPE_ZERO_BYTE
7097 | OPTI_TYPE_PRECOMPUTE_INIT
7098 | OPTI_TYPE_PRECOMPUTE_MERKLE
7099 | OPTI_TYPE_MEET_IN_MIDDLE
7100 | OPTI_TYPE_EARLY_SKIP
7101 | OPTI_TYPE_NOT_ITERATED
7102 | OPTI_TYPE_APPENDED_SALT
7103 | OPTI_TYPE_RAW_HASH;
7104 dgst_pos0 = 0;
7105 dgst_pos1 = 3;
7106 dgst_pos2 = 2;
7107 dgst_pos3 = 1;
7108 break;
7109
7110 case 12: hash_type = HASH_TYPE_MD5;
7111 salt_type = SALT_TYPE_INTERN;
7112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7113 opts_type = OPTS_TYPE_PT_GENERATE_LE
7114 | OPTS_TYPE_ST_ADD80
7115 | OPTS_TYPE_ST_ADDBITS14;
7116 kern_type = KERN_TYPE_MD5_PWSLT;
7117 dgst_size = DGST_SIZE_4_4;
7118 parse_func = postgresql_parse_hash;
7119 sort_by_digest = sort_by_digest_4_4;
7120 opti_type = OPTI_TYPE_ZERO_BYTE
7121 | OPTI_TYPE_PRECOMPUTE_INIT
7122 | OPTI_TYPE_PRECOMPUTE_MERKLE
7123 | OPTI_TYPE_MEET_IN_MIDDLE
7124 | OPTI_TYPE_EARLY_SKIP
7125 | OPTI_TYPE_NOT_ITERATED
7126 | OPTI_TYPE_APPENDED_SALT
7127 | OPTI_TYPE_RAW_HASH;
7128 dgst_pos0 = 0;
7129 dgst_pos1 = 3;
7130 dgst_pos2 = 2;
7131 dgst_pos3 = 1;
7132 break;
7133
7134 case 20: hash_type = HASH_TYPE_MD5;
7135 salt_type = SALT_TYPE_INTERN;
7136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7137 opts_type = OPTS_TYPE_PT_GENERATE_LE
7138 | OPTS_TYPE_PT_ADD80
7139 | OPTS_TYPE_PT_ADDBITS14;
7140 kern_type = KERN_TYPE_MD5_SLTPW;
7141 dgst_size = DGST_SIZE_4_4;
7142 parse_func = md5s_parse_hash;
7143 sort_by_digest = sort_by_digest_4_4;
7144 opti_type = OPTI_TYPE_ZERO_BYTE
7145 | OPTI_TYPE_PRECOMPUTE_INIT
7146 | OPTI_TYPE_PRECOMPUTE_MERKLE
7147 | OPTI_TYPE_EARLY_SKIP
7148 | OPTI_TYPE_NOT_ITERATED
7149 | OPTI_TYPE_PREPENDED_SALT
7150 | OPTI_TYPE_RAW_HASH;
7151 dgst_pos0 = 0;
7152 dgst_pos1 = 3;
7153 dgst_pos2 = 2;
7154 dgst_pos3 = 1;
7155 break;
7156
7157 case 21: hash_type = HASH_TYPE_MD5;
7158 salt_type = SALT_TYPE_INTERN;
7159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7160 opts_type = OPTS_TYPE_PT_GENERATE_LE
7161 | OPTS_TYPE_PT_ADD80
7162 | OPTS_TYPE_PT_ADDBITS14;
7163 kern_type = KERN_TYPE_MD5_SLTPW;
7164 dgst_size = DGST_SIZE_4_4;
7165 parse_func = osc_parse_hash;
7166 sort_by_digest = sort_by_digest_4_4;
7167 opti_type = OPTI_TYPE_ZERO_BYTE
7168 | OPTI_TYPE_PRECOMPUTE_INIT
7169 | OPTI_TYPE_PRECOMPUTE_MERKLE
7170 | OPTI_TYPE_EARLY_SKIP
7171 | OPTI_TYPE_NOT_ITERATED
7172 | OPTI_TYPE_PREPENDED_SALT
7173 | OPTI_TYPE_RAW_HASH;
7174 dgst_pos0 = 0;
7175 dgst_pos1 = 3;
7176 dgst_pos2 = 2;
7177 dgst_pos3 = 1;
7178 break;
7179
7180 case 22: hash_type = HASH_TYPE_MD5;
7181 salt_type = SALT_TYPE_EMBEDDED;
7182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7183 opts_type = OPTS_TYPE_PT_GENERATE_LE
7184 | OPTS_TYPE_PT_ADD80
7185 | OPTS_TYPE_PT_ADDBITS14;
7186 kern_type = KERN_TYPE_MD5_SLTPW;
7187 dgst_size = DGST_SIZE_4_4;
7188 parse_func = netscreen_parse_hash;
7189 sort_by_digest = sort_by_digest_4_4;
7190 opti_type = OPTI_TYPE_ZERO_BYTE
7191 | OPTI_TYPE_PRECOMPUTE_INIT
7192 | OPTI_TYPE_PRECOMPUTE_MERKLE
7193 | OPTI_TYPE_EARLY_SKIP
7194 | OPTI_TYPE_NOT_ITERATED
7195 | OPTI_TYPE_PREPENDED_SALT
7196 | OPTI_TYPE_RAW_HASH;
7197 dgst_pos0 = 0;
7198 dgst_pos1 = 3;
7199 dgst_pos2 = 2;
7200 dgst_pos3 = 1;
7201 break;
7202
7203 case 23: hash_type = HASH_TYPE_MD5;
7204 salt_type = SALT_TYPE_EMBEDDED;
7205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7206 opts_type = OPTS_TYPE_PT_GENERATE_LE
7207 | OPTS_TYPE_PT_ADD80
7208 | OPTS_TYPE_PT_ADDBITS14;
7209 kern_type = KERN_TYPE_MD5_SLTPW;
7210 dgst_size = DGST_SIZE_4_4;
7211 parse_func = skype_parse_hash;
7212 sort_by_digest = sort_by_digest_4_4;
7213 opti_type = OPTI_TYPE_ZERO_BYTE
7214 | OPTI_TYPE_PRECOMPUTE_INIT
7215 | OPTI_TYPE_PRECOMPUTE_MERKLE
7216 | OPTI_TYPE_EARLY_SKIP
7217 | OPTI_TYPE_NOT_ITERATED
7218 | OPTI_TYPE_PREPENDED_SALT
7219 | OPTI_TYPE_RAW_HASH;
7220 dgst_pos0 = 0;
7221 dgst_pos1 = 3;
7222 dgst_pos2 = 2;
7223 dgst_pos3 = 1;
7224 break;
7225
7226 case 30: hash_type = HASH_TYPE_MD5;
7227 salt_type = SALT_TYPE_INTERN;
7228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7229 opts_type = OPTS_TYPE_PT_GENERATE_LE
7230 | OPTS_TYPE_PT_UNICODE
7231 | OPTS_TYPE_ST_ADD80
7232 | OPTS_TYPE_ST_ADDBITS14;
7233 kern_type = KERN_TYPE_MD5_PWUSLT;
7234 dgst_size = DGST_SIZE_4_4;
7235 parse_func = md5s_parse_hash;
7236 sort_by_digest = sort_by_digest_4_4;
7237 opti_type = OPTI_TYPE_ZERO_BYTE
7238 | OPTI_TYPE_PRECOMPUTE_INIT
7239 | OPTI_TYPE_PRECOMPUTE_MERKLE
7240 | OPTI_TYPE_MEET_IN_MIDDLE
7241 | OPTI_TYPE_EARLY_SKIP
7242 | OPTI_TYPE_NOT_ITERATED
7243 | OPTI_TYPE_APPENDED_SALT
7244 | OPTI_TYPE_RAW_HASH;
7245 dgst_pos0 = 0;
7246 dgst_pos1 = 3;
7247 dgst_pos2 = 2;
7248 dgst_pos3 = 1;
7249 break;
7250
7251 case 40: hash_type = HASH_TYPE_MD5;
7252 salt_type = SALT_TYPE_INTERN;
7253 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7254 opts_type = OPTS_TYPE_PT_GENERATE_LE
7255 | OPTS_TYPE_PT_ADD80
7256 | OPTS_TYPE_PT_ADDBITS14
7257 | OPTS_TYPE_PT_UNICODE;
7258 kern_type = KERN_TYPE_MD5_SLTPWU;
7259 dgst_size = DGST_SIZE_4_4;
7260 parse_func = md5s_parse_hash;
7261 sort_by_digest = sort_by_digest_4_4;
7262 opti_type = OPTI_TYPE_ZERO_BYTE
7263 | OPTI_TYPE_PRECOMPUTE_INIT
7264 | OPTI_TYPE_PRECOMPUTE_MERKLE
7265 | OPTI_TYPE_EARLY_SKIP
7266 | OPTI_TYPE_NOT_ITERATED
7267 | OPTI_TYPE_PREPENDED_SALT
7268 | OPTI_TYPE_RAW_HASH;
7269 dgst_pos0 = 0;
7270 dgst_pos1 = 3;
7271 dgst_pos2 = 2;
7272 dgst_pos3 = 1;
7273 break;
7274
7275 case 50: hash_type = HASH_TYPE_MD5;
7276 salt_type = SALT_TYPE_INTERN;
7277 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7278 opts_type = OPTS_TYPE_PT_GENERATE_LE
7279 | OPTS_TYPE_ST_ADD80
7280 | OPTS_TYPE_ST_ADDBITS14;
7281 kern_type = KERN_TYPE_HMACMD5_PW;
7282 dgst_size = DGST_SIZE_4_4;
7283 parse_func = hmacmd5_parse_hash;
7284 sort_by_digest = sort_by_digest_4_4;
7285 opti_type = OPTI_TYPE_ZERO_BYTE
7286 | OPTI_TYPE_NOT_ITERATED;
7287 dgst_pos0 = 0;
7288 dgst_pos1 = 3;
7289 dgst_pos2 = 2;
7290 dgst_pos3 = 1;
7291 break;
7292
7293 case 60: hash_type = HASH_TYPE_MD5;
7294 salt_type = SALT_TYPE_INTERN;
7295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7296 opts_type = OPTS_TYPE_PT_GENERATE_LE
7297 | OPTS_TYPE_PT_ADD80
7298 | OPTS_TYPE_PT_ADDBITS14;
7299 kern_type = KERN_TYPE_HMACMD5_SLT;
7300 dgst_size = DGST_SIZE_4_4;
7301 parse_func = hmacmd5_parse_hash;
7302 sort_by_digest = sort_by_digest_4_4;
7303 opti_type = OPTI_TYPE_ZERO_BYTE
7304 | OPTI_TYPE_NOT_ITERATED;
7305 dgst_pos0 = 0;
7306 dgst_pos1 = 3;
7307 dgst_pos2 = 2;
7308 dgst_pos3 = 1;
7309 break;
7310
7311 case 100: hash_type = HASH_TYPE_SHA1;
7312 salt_type = SALT_TYPE_NONE;
7313 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7314 opts_type = OPTS_TYPE_PT_GENERATE_BE
7315 | OPTS_TYPE_PT_ADD80
7316 | OPTS_TYPE_PT_ADDBITS15;
7317 kern_type = KERN_TYPE_SHA1;
7318 dgst_size = DGST_SIZE_4_5;
7319 parse_func = sha1_parse_hash;
7320 sort_by_digest = sort_by_digest_4_5;
7321 opti_type = OPTI_TYPE_ZERO_BYTE
7322 | OPTI_TYPE_PRECOMPUTE_INIT
7323 | OPTI_TYPE_PRECOMPUTE_MERKLE
7324 | OPTI_TYPE_EARLY_SKIP
7325 | OPTI_TYPE_NOT_ITERATED
7326 | OPTI_TYPE_NOT_SALTED
7327 | OPTI_TYPE_RAW_HASH;
7328 dgst_pos0 = 3;
7329 dgst_pos1 = 4;
7330 dgst_pos2 = 2;
7331 dgst_pos3 = 1;
7332 break;
7333
7334 case 101: hash_type = HASH_TYPE_SHA1;
7335 salt_type = SALT_TYPE_NONE;
7336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7337 opts_type = OPTS_TYPE_PT_GENERATE_BE
7338 | OPTS_TYPE_PT_ADD80
7339 | OPTS_TYPE_PT_ADDBITS15;
7340 kern_type = KERN_TYPE_SHA1;
7341 dgst_size = DGST_SIZE_4_5;
7342 parse_func = sha1b64_parse_hash;
7343 sort_by_digest = sort_by_digest_4_5;
7344 opti_type = OPTI_TYPE_ZERO_BYTE
7345 | OPTI_TYPE_PRECOMPUTE_INIT
7346 | OPTI_TYPE_PRECOMPUTE_MERKLE
7347 | OPTI_TYPE_EARLY_SKIP
7348 | OPTI_TYPE_NOT_ITERATED
7349 | OPTI_TYPE_NOT_SALTED
7350 | OPTI_TYPE_RAW_HASH;
7351 dgst_pos0 = 3;
7352 dgst_pos1 = 4;
7353 dgst_pos2 = 2;
7354 dgst_pos3 = 1;
7355 break;
7356
7357 case 110: hash_type = HASH_TYPE_SHA1;
7358 salt_type = SALT_TYPE_INTERN;
7359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7360 opts_type = OPTS_TYPE_PT_GENERATE_BE
7361 | OPTS_TYPE_ST_ADD80
7362 | OPTS_TYPE_ST_ADDBITS15;
7363 kern_type = KERN_TYPE_SHA1_PWSLT;
7364 dgst_size = DGST_SIZE_4_5;
7365 parse_func = sha1s_parse_hash;
7366 sort_by_digest = sort_by_digest_4_5;
7367 opti_type = OPTI_TYPE_ZERO_BYTE
7368 | OPTI_TYPE_PRECOMPUTE_INIT
7369 | OPTI_TYPE_PRECOMPUTE_MERKLE
7370 | OPTI_TYPE_EARLY_SKIP
7371 | OPTI_TYPE_NOT_ITERATED
7372 | OPTI_TYPE_APPENDED_SALT
7373 | OPTI_TYPE_RAW_HASH;
7374 dgst_pos0 = 3;
7375 dgst_pos1 = 4;
7376 dgst_pos2 = 2;
7377 dgst_pos3 = 1;
7378 break;
7379
7380 case 111: hash_type = HASH_TYPE_SHA1;
7381 salt_type = SALT_TYPE_EMBEDDED;
7382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7383 opts_type = OPTS_TYPE_PT_GENERATE_BE
7384 | OPTS_TYPE_ST_ADD80
7385 | OPTS_TYPE_ST_ADDBITS15;
7386 kern_type = KERN_TYPE_SHA1_PWSLT;
7387 dgst_size = DGST_SIZE_4_5;
7388 parse_func = sha1b64s_parse_hash;
7389 sort_by_digest = sort_by_digest_4_5;
7390 opti_type = OPTI_TYPE_ZERO_BYTE
7391 | OPTI_TYPE_PRECOMPUTE_INIT
7392 | OPTI_TYPE_PRECOMPUTE_MERKLE
7393 | OPTI_TYPE_EARLY_SKIP
7394 | OPTI_TYPE_NOT_ITERATED
7395 | OPTI_TYPE_APPENDED_SALT
7396 | OPTI_TYPE_RAW_HASH;
7397 dgst_pos0 = 3;
7398 dgst_pos1 = 4;
7399 dgst_pos2 = 2;
7400 dgst_pos3 = 1;
7401 break;
7402
7403 case 112: hash_type = HASH_TYPE_SHA1;
7404 salt_type = SALT_TYPE_INTERN;
7405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7406 opts_type = OPTS_TYPE_PT_GENERATE_BE
7407 | OPTS_TYPE_ST_ADD80
7408 | OPTS_TYPE_ST_ADDBITS15
7409 | OPTS_TYPE_ST_HEX;
7410 kern_type = KERN_TYPE_SHA1_PWSLT;
7411 dgst_size = DGST_SIZE_4_5;
7412 parse_func = oracles_parse_hash;
7413 sort_by_digest = sort_by_digest_4_5;
7414 opti_type = OPTI_TYPE_ZERO_BYTE
7415 | OPTI_TYPE_PRECOMPUTE_INIT
7416 | OPTI_TYPE_PRECOMPUTE_MERKLE
7417 | OPTI_TYPE_EARLY_SKIP
7418 | OPTI_TYPE_NOT_ITERATED
7419 | OPTI_TYPE_APPENDED_SALT
7420 | OPTI_TYPE_RAW_HASH;
7421 dgst_pos0 = 3;
7422 dgst_pos1 = 4;
7423 dgst_pos2 = 2;
7424 dgst_pos3 = 1;
7425 break;
7426
7427 case 120: hash_type = HASH_TYPE_SHA1;
7428 salt_type = SALT_TYPE_INTERN;
7429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7430 opts_type = OPTS_TYPE_PT_GENERATE_BE
7431 | OPTS_TYPE_PT_ADD80
7432 | OPTS_TYPE_PT_ADDBITS15;
7433 kern_type = KERN_TYPE_SHA1_SLTPW;
7434 dgst_size = DGST_SIZE_4_5;
7435 parse_func = sha1s_parse_hash;
7436 sort_by_digest = sort_by_digest_4_5;
7437 opti_type = OPTI_TYPE_ZERO_BYTE
7438 | OPTI_TYPE_PRECOMPUTE_INIT
7439 | OPTI_TYPE_PRECOMPUTE_MERKLE
7440 | OPTI_TYPE_EARLY_SKIP
7441 | OPTI_TYPE_NOT_ITERATED
7442 | OPTI_TYPE_PREPENDED_SALT
7443 | OPTI_TYPE_RAW_HASH;
7444 dgst_pos0 = 3;
7445 dgst_pos1 = 4;
7446 dgst_pos2 = 2;
7447 dgst_pos3 = 1;
7448 break;
7449
7450 case 121: hash_type = HASH_TYPE_SHA1;
7451 salt_type = SALT_TYPE_INTERN;
7452 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7453 opts_type = OPTS_TYPE_PT_GENERATE_BE
7454 | OPTS_TYPE_PT_ADD80
7455 | OPTS_TYPE_PT_ADDBITS15
7456 | OPTS_TYPE_ST_LOWER;
7457 kern_type = KERN_TYPE_SHA1_SLTPW;
7458 dgst_size = DGST_SIZE_4_5;
7459 parse_func = smf_parse_hash;
7460 sort_by_digest = sort_by_digest_4_5;
7461 opti_type = OPTI_TYPE_ZERO_BYTE
7462 | OPTI_TYPE_PRECOMPUTE_INIT
7463 | OPTI_TYPE_PRECOMPUTE_MERKLE
7464 | OPTI_TYPE_EARLY_SKIP
7465 | OPTI_TYPE_NOT_ITERATED
7466 | OPTI_TYPE_PREPENDED_SALT
7467 | OPTI_TYPE_RAW_HASH;
7468 dgst_pos0 = 3;
7469 dgst_pos1 = 4;
7470 dgst_pos2 = 2;
7471 dgst_pos3 = 1;
7472 break;
7473
7474 case 122: hash_type = HASH_TYPE_SHA1;
7475 salt_type = SALT_TYPE_EMBEDDED;
7476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7477 opts_type = OPTS_TYPE_PT_GENERATE_BE
7478 | OPTS_TYPE_PT_ADD80
7479 | OPTS_TYPE_PT_ADDBITS15
7480 | OPTS_TYPE_ST_HEX;
7481 kern_type = KERN_TYPE_SHA1_SLTPW;
7482 dgst_size = DGST_SIZE_4_5;
7483 parse_func = osx1_parse_hash;
7484 sort_by_digest = sort_by_digest_4_5;
7485 opti_type = OPTI_TYPE_ZERO_BYTE
7486 | OPTI_TYPE_PRECOMPUTE_INIT
7487 | OPTI_TYPE_PRECOMPUTE_MERKLE
7488 | OPTI_TYPE_EARLY_SKIP
7489 | OPTI_TYPE_NOT_ITERATED
7490 | OPTI_TYPE_PREPENDED_SALT
7491 | OPTI_TYPE_RAW_HASH;
7492 dgst_pos0 = 3;
7493 dgst_pos1 = 4;
7494 dgst_pos2 = 2;
7495 dgst_pos3 = 1;
7496 break;
7497
7498 case 124: hash_type = HASH_TYPE_SHA1;
7499 salt_type = SALT_TYPE_EMBEDDED;
7500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7501 opts_type = OPTS_TYPE_PT_GENERATE_BE
7502 | OPTS_TYPE_PT_ADD80
7503 | OPTS_TYPE_PT_ADDBITS15;
7504 kern_type = KERN_TYPE_SHA1_SLTPW;
7505 dgst_size = DGST_SIZE_4_5;
7506 parse_func = djangosha1_parse_hash;
7507 sort_by_digest = sort_by_digest_4_5;
7508 opti_type = OPTI_TYPE_ZERO_BYTE
7509 | OPTI_TYPE_PRECOMPUTE_INIT
7510 | OPTI_TYPE_PRECOMPUTE_MERKLE
7511 | OPTI_TYPE_EARLY_SKIP
7512 | OPTI_TYPE_NOT_ITERATED
7513 | OPTI_TYPE_PREPENDED_SALT
7514 | OPTI_TYPE_RAW_HASH;
7515 dgst_pos0 = 3;
7516 dgst_pos1 = 4;
7517 dgst_pos2 = 2;
7518 dgst_pos3 = 1;
7519 break;
7520
7521 case 125: hash_type = HASH_TYPE_SHA1;
7522 salt_type = SALT_TYPE_EMBEDDED;
7523 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7524 opts_type = OPTS_TYPE_PT_GENERATE_BE
7525 | OPTS_TYPE_PT_ADD80
7526 | OPTS_TYPE_PT_ADDBITS15
7527 | OPTS_TYPE_ST_HEX;
7528 kern_type = KERN_TYPE_SHA1_SLTPW;
7529 dgst_size = DGST_SIZE_4_5;
7530 parse_func = arubaos_parse_hash;
7531 sort_by_digest = sort_by_digest_4_5;
7532 opti_type = OPTI_TYPE_ZERO_BYTE
7533 | OPTI_TYPE_PRECOMPUTE_INIT
7534 | OPTI_TYPE_PRECOMPUTE_MERKLE
7535 | OPTI_TYPE_EARLY_SKIP
7536 | OPTI_TYPE_NOT_ITERATED
7537 | OPTI_TYPE_PREPENDED_SALT
7538 | OPTI_TYPE_RAW_HASH;
7539 dgst_pos0 = 3;
7540 dgst_pos1 = 4;
7541 dgst_pos2 = 2;
7542 dgst_pos3 = 1;
7543 break;
7544
7545 case 130: hash_type = HASH_TYPE_SHA1;
7546 salt_type = SALT_TYPE_INTERN;
7547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7548 opts_type = OPTS_TYPE_PT_GENERATE_BE
7549 | OPTS_TYPE_PT_UNICODE
7550 | OPTS_TYPE_ST_ADD80
7551 | OPTS_TYPE_ST_ADDBITS15;
7552 kern_type = KERN_TYPE_SHA1_PWUSLT;
7553 dgst_size = DGST_SIZE_4_5;
7554 parse_func = sha1s_parse_hash;
7555 sort_by_digest = sort_by_digest_4_5;
7556 opti_type = OPTI_TYPE_ZERO_BYTE
7557 | OPTI_TYPE_PRECOMPUTE_INIT
7558 | OPTI_TYPE_PRECOMPUTE_MERKLE
7559 | OPTI_TYPE_EARLY_SKIP
7560 | OPTI_TYPE_NOT_ITERATED
7561 | OPTI_TYPE_APPENDED_SALT
7562 | OPTI_TYPE_RAW_HASH;
7563 dgst_pos0 = 3;
7564 dgst_pos1 = 4;
7565 dgst_pos2 = 2;
7566 dgst_pos3 = 1;
7567 break;
7568
7569 case 131: hash_type = HASH_TYPE_SHA1;
7570 salt_type = SALT_TYPE_EMBEDDED;
7571 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7572 opts_type = OPTS_TYPE_PT_GENERATE_BE
7573 | OPTS_TYPE_PT_UNICODE
7574 | OPTS_TYPE_PT_UPPER
7575 | OPTS_TYPE_ST_ADD80
7576 | OPTS_TYPE_ST_ADDBITS15
7577 | OPTS_TYPE_ST_HEX;
7578 kern_type = KERN_TYPE_SHA1_PWUSLT;
7579 dgst_size = DGST_SIZE_4_5;
7580 parse_func = mssql2000_parse_hash;
7581 sort_by_digest = sort_by_digest_4_5;
7582 opti_type = OPTI_TYPE_ZERO_BYTE
7583 | OPTI_TYPE_PRECOMPUTE_INIT
7584 | OPTI_TYPE_PRECOMPUTE_MERKLE
7585 | OPTI_TYPE_EARLY_SKIP
7586 | OPTI_TYPE_NOT_ITERATED
7587 | OPTI_TYPE_APPENDED_SALT
7588 | OPTI_TYPE_RAW_HASH;
7589 dgst_pos0 = 3;
7590 dgst_pos1 = 4;
7591 dgst_pos2 = 2;
7592 dgst_pos3 = 1;
7593 break;
7594
7595 case 132: hash_type = HASH_TYPE_SHA1;
7596 salt_type = SALT_TYPE_EMBEDDED;
7597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7598 opts_type = OPTS_TYPE_PT_GENERATE_BE
7599 | OPTS_TYPE_PT_UNICODE
7600 | OPTS_TYPE_ST_ADD80
7601 | OPTS_TYPE_ST_ADDBITS15
7602 | OPTS_TYPE_ST_HEX;
7603 kern_type = KERN_TYPE_SHA1_PWUSLT;
7604 dgst_size = DGST_SIZE_4_5;
7605 parse_func = mssql2005_parse_hash;
7606 sort_by_digest = sort_by_digest_4_5;
7607 opti_type = OPTI_TYPE_ZERO_BYTE
7608 | OPTI_TYPE_PRECOMPUTE_INIT
7609 | OPTI_TYPE_PRECOMPUTE_MERKLE
7610 | OPTI_TYPE_EARLY_SKIP
7611 | OPTI_TYPE_NOT_ITERATED
7612 | OPTI_TYPE_APPENDED_SALT
7613 | OPTI_TYPE_RAW_HASH;
7614 dgst_pos0 = 3;
7615 dgst_pos1 = 4;
7616 dgst_pos2 = 2;
7617 dgst_pos3 = 1;
7618 break;
7619
7620 case 133: hash_type = HASH_TYPE_SHA1;
7621 salt_type = SALT_TYPE_EMBEDDED;
7622 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7623 opts_type = OPTS_TYPE_PT_GENERATE_BE
7624 | OPTS_TYPE_PT_UNICODE
7625 | OPTS_TYPE_ST_ADD80
7626 | OPTS_TYPE_ST_ADDBITS15;
7627 kern_type = KERN_TYPE_SHA1_PWUSLT;
7628 dgst_size = DGST_SIZE_4_5;
7629 parse_func = peoplesoft_parse_hash;
7630 sort_by_digest = sort_by_digest_4_5;
7631 opti_type = OPTI_TYPE_ZERO_BYTE
7632 | OPTI_TYPE_PRECOMPUTE_INIT
7633 | OPTI_TYPE_PRECOMPUTE_MERKLE
7634 | OPTI_TYPE_EARLY_SKIP
7635 | OPTI_TYPE_NOT_ITERATED
7636 | OPTI_TYPE_APPENDED_SALT
7637 | OPTI_TYPE_RAW_HASH;
7638 dgst_pos0 = 3;
7639 dgst_pos1 = 4;
7640 dgst_pos2 = 2;
7641 dgst_pos3 = 1;
7642 break;
7643
7644 case 140: hash_type = HASH_TYPE_SHA1;
7645 salt_type = SALT_TYPE_INTERN;
7646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7647 opts_type = OPTS_TYPE_PT_GENERATE_BE
7648 | OPTS_TYPE_PT_ADD80
7649 | OPTS_TYPE_PT_ADDBITS15
7650 | OPTS_TYPE_PT_UNICODE;
7651 kern_type = KERN_TYPE_SHA1_SLTPWU;
7652 dgst_size = DGST_SIZE_4_5;
7653 parse_func = sha1s_parse_hash;
7654 sort_by_digest = sort_by_digest_4_5;
7655 opti_type = OPTI_TYPE_ZERO_BYTE
7656 | OPTI_TYPE_PRECOMPUTE_INIT
7657 | OPTI_TYPE_PRECOMPUTE_MERKLE
7658 | OPTI_TYPE_EARLY_SKIP
7659 | OPTI_TYPE_NOT_ITERATED
7660 | OPTI_TYPE_PREPENDED_SALT
7661 | OPTI_TYPE_RAW_HASH;
7662 dgst_pos0 = 3;
7663 dgst_pos1 = 4;
7664 dgst_pos2 = 2;
7665 dgst_pos3 = 1;
7666 break;
7667
7668 case 141: hash_type = HASH_TYPE_SHA1;
7669 salt_type = SALT_TYPE_EMBEDDED;
7670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7671 opts_type = OPTS_TYPE_PT_GENERATE_BE
7672 | OPTS_TYPE_PT_ADD80
7673 | OPTS_TYPE_PT_ADDBITS15
7674 | OPTS_TYPE_PT_UNICODE
7675 | OPTS_TYPE_ST_BASE64;
7676 kern_type = KERN_TYPE_SHA1_SLTPWU;
7677 dgst_size = DGST_SIZE_4_5;
7678 parse_func = episerver_parse_hash;
7679 sort_by_digest = sort_by_digest_4_5;
7680 opti_type = OPTI_TYPE_ZERO_BYTE
7681 | OPTI_TYPE_PRECOMPUTE_INIT
7682 | OPTI_TYPE_PRECOMPUTE_MERKLE
7683 | OPTI_TYPE_EARLY_SKIP
7684 | OPTI_TYPE_NOT_ITERATED
7685 | OPTI_TYPE_PREPENDED_SALT
7686 | OPTI_TYPE_RAW_HASH;
7687 dgst_pos0 = 3;
7688 dgst_pos1 = 4;
7689 dgst_pos2 = 2;
7690 dgst_pos3 = 1;
7691 break;
7692
7693 case 150: hash_type = HASH_TYPE_SHA1;
7694 salt_type = SALT_TYPE_INTERN;
7695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7696 opts_type = OPTS_TYPE_PT_GENERATE_BE
7697 | OPTS_TYPE_ST_ADD80
7698 | OPTS_TYPE_ST_ADDBITS15;
7699 kern_type = KERN_TYPE_HMACSHA1_PW;
7700 dgst_size = DGST_SIZE_4_5;
7701 parse_func = hmacsha1_parse_hash;
7702 sort_by_digest = sort_by_digest_4_5;
7703 opti_type = OPTI_TYPE_ZERO_BYTE
7704 | OPTI_TYPE_NOT_ITERATED;
7705 dgst_pos0 = 3;
7706 dgst_pos1 = 4;
7707 dgst_pos2 = 2;
7708 dgst_pos3 = 1;
7709 break;
7710
7711 case 160: hash_type = HASH_TYPE_SHA1;
7712 salt_type = SALT_TYPE_INTERN;
7713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7714 opts_type = OPTS_TYPE_PT_GENERATE_BE
7715 | OPTS_TYPE_PT_ADD80
7716 | OPTS_TYPE_PT_ADDBITS15;
7717 kern_type = KERN_TYPE_HMACSHA1_SLT;
7718 dgst_size = DGST_SIZE_4_5;
7719 parse_func = hmacsha1_parse_hash;
7720 sort_by_digest = sort_by_digest_4_5;
7721 opti_type = OPTI_TYPE_ZERO_BYTE
7722 | OPTI_TYPE_NOT_ITERATED;
7723 dgst_pos0 = 3;
7724 dgst_pos1 = 4;
7725 dgst_pos2 = 2;
7726 dgst_pos3 = 1;
7727 break;
7728
7729 case 190: hash_type = HASH_TYPE_SHA1;
7730 salt_type = SALT_TYPE_NONE;
7731 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7732 opts_type = OPTS_TYPE_PT_GENERATE_BE
7733 | OPTS_TYPE_PT_ADD80
7734 | OPTS_TYPE_PT_ADDBITS15;
7735 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7736 dgst_size = DGST_SIZE_4_5;
7737 parse_func = sha1linkedin_parse_hash;
7738 sort_by_digest = sort_by_digest_4_5;
7739 opti_type = OPTI_TYPE_ZERO_BYTE
7740 | OPTI_TYPE_PRECOMPUTE_INIT
7741 | OPTI_TYPE_EARLY_SKIP
7742 | OPTI_TYPE_NOT_ITERATED
7743 | OPTI_TYPE_NOT_SALTED;
7744 dgst_pos0 = 0;
7745 dgst_pos1 = 4;
7746 dgst_pos2 = 3;
7747 dgst_pos3 = 2;
7748 break;
7749
7750 case 200: hash_type = HASH_TYPE_MYSQL;
7751 salt_type = SALT_TYPE_NONE;
7752 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7753 opts_type = 0;
7754 kern_type = KERN_TYPE_MYSQL;
7755 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7756 parse_func = mysql323_parse_hash;
7757 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7758 opti_type = OPTI_TYPE_ZERO_BYTE;
7759 dgst_pos0 = 0;
7760 dgst_pos1 = 1;
7761 dgst_pos2 = 2;
7762 dgst_pos3 = 3;
7763 break;
7764
7765 case 300: hash_type = HASH_TYPE_SHA1;
7766 salt_type = SALT_TYPE_NONE;
7767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7768 opts_type = OPTS_TYPE_PT_GENERATE_BE
7769 | OPTS_TYPE_PT_ADD80
7770 | OPTS_TYPE_PT_ADDBITS15;
7771 kern_type = KERN_TYPE_MYSQL41;
7772 dgst_size = DGST_SIZE_4_5;
7773 parse_func = sha1_parse_hash;
7774 sort_by_digest = sort_by_digest_4_5;
7775 opti_type = OPTI_TYPE_ZERO_BYTE
7776 | OPTI_TYPE_PRECOMPUTE_INIT
7777 | OPTI_TYPE_PRECOMPUTE_MERKLE
7778 | OPTI_TYPE_EARLY_SKIP
7779 | OPTI_TYPE_NOT_ITERATED
7780 | OPTI_TYPE_NOT_SALTED;
7781 dgst_pos0 = 3;
7782 dgst_pos1 = 4;
7783 dgst_pos2 = 2;
7784 dgst_pos3 = 1;
7785 break;
7786
7787 case 400: hash_type = HASH_TYPE_MD5;
7788 salt_type = SALT_TYPE_EMBEDDED;
7789 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7790 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7791 kern_type = KERN_TYPE_PHPASS;
7792 dgst_size = DGST_SIZE_4_4;
7793 parse_func = phpass_parse_hash;
7794 sort_by_digest = sort_by_digest_4_4;
7795 opti_type = OPTI_TYPE_ZERO_BYTE
7796 | OPTI_TYPE_SLOW_HASH_SIMD;
7797 dgst_pos0 = 0;
7798 dgst_pos1 = 1;
7799 dgst_pos2 = 2;
7800 dgst_pos3 = 3;
7801 break;
7802
7803 case 500: hash_type = HASH_TYPE_MD5;
7804 salt_type = SALT_TYPE_EMBEDDED;
7805 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7806 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7807 kern_type = KERN_TYPE_MD5CRYPT;
7808 dgst_size = DGST_SIZE_4_4;
7809 parse_func = md5crypt_parse_hash;
7810 sort_by_digest = sort_by_digest_4_4;
7811 opti_type = OPTI_TYPE_ZERO_BYTE;
7812 dgst_pos0 = 0;
7813 dgst_pos1 = 1;
7814 dgst_pos2 = 2;
7815 dgst_pos3 = 3;
7816 break;
7817
7818 case 501: hash_type = HASH_TYPE_MD5;
7819 salt_type = SALT_TYPE_EMBEDDED;
7820 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7821 opts_type = OPTS_TYPE_PT_GENERATE_LE
7822 | OPTS_TYPE_HASH_COPY;
7823 kern_type = KERN_TYPE_MD5CRYPT;
7824 dgst_size = DGST_SIZE_4_4;
7825 parse_func = juniper_parse_hash;
7826 sort_by_digest = sort_by_digest_4_4;
7827 opti_type = OPTI_TYPE_ZERO_BYTE;
7828 dgst_pos0 = 0;
7829 dgst_pos1 = 1;
7830 dgst_pos2 = 2;
7831 dgst_pos3 = 3;
7832 break;
7833
7834 case 900: hash_type = HASH_TYPE_MD4;
7835 salt_type = SALT_TYPE_NONE;
7836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7837 opts_type = OPTS_TYPE_PT_GENERATE_LE
7838 | OPTS_TYPE_PT_ADD80
7839 | OPTS_TYPE_PT_ADDBITS14;
7840 kern_type = KERN_TYPE_MD4;
7841 dgst_size = DGST_SIZE_4_4;
7842 parse_func = md4_parse_hash;
7843 sort_by_digest = sort_by_digest_4_4;
7844 opti_type = OPTI_TYPE_ZERO_BYTE
7845 | OPTI_TYPE_PRECOMPUTE_INIT
7846 | OPTI_TYPE_PRECOMPUTE_MERKLE
7847 | OPTI_TYPE_MEET_IN_MIDDLE
7848 | OPTI_TYPE_EARLY_SKIP
7849 | OPTI_TYPE_NOT_ITERATED
7850 | OPTI_TYPE_NOT_SALTED
7851 | OPTI_TYPE_RAW_HASH;
7852 dgst_pos0 = 0;
7853 dgst_pos1 = 3;
7854 dgst_pos2 = 2;
7855 dgst_pos3 = 1;
7856 break;
7857
7858 case 1000: hash_type = HASH_TYPE_MD4;
7859 salt_type = SALT_TYPE_NONE;
7860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7861 opts_type = OPTS_TYPE_PT_GENERATE_LE
7862 | OPTS_TYPE_PT_ADD80
7863 | OPTS_TYPE_PT_ADDBITS14
7864 | OPTS_TYPE_PT_UNICODE;
7865 kern_type = KERN_TYPE_MD4_PWU;
7866 dgst_size = DGST_SIZE_4_4;
7867 parse_func = md4_parse_hash;
7868 sort_by_digest = sort_by_digest_4_4;
7869 opti_type = OPTI_TYPE_ZERO_BYTE
7870 | OPTI_TYPE_PRECOMPUTE_INIT
7871 | OPTI_TYPE_PRECOMPUTE_MERKLE
7872 | OPTI_TYPE_MEET_IN_MIDDLE
7873 | OPTI_TYPE_EARLY_SKIP
7874 | OPTI_TYPE_NOT_ITERATED
7875 | OPTI_TYPE_NOT_SALTED
7876 | OPTI_TYPE_RAW_HASH;
7877 dgst_pos0 = 0;
7878 dgst_pos1 = 3;
7879 dgst_pos2 = 2;
7880 dgst_pos3 = 1;
7881 break;
7882
7883 case 1100: hash_type = HASH_TYPE_MD4;
7884 salt_type = SALT_TYPE_INTERN;
7885 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7886 opts_type = OPTS_TYPE_PT_GENERATE_LE
7887 | OPTS_TYPE_PT_ADD80
7888 | OPTS_TYPE_PT_ADDBITS14
7889 | OPTS_TYPE_PT_UNICODE
7890 | OPTS_TYPE_ST_ADD80
7891 | OPTS_TYPE_ST_UNICODE
7892 | OPTS_TYPE_ST_LOWER;
7893 kern_type = KERN_TYPE_MD44_PWUSLT;
7894 dgst_size = DGST_SIZE_4_4;
7895 parse_func = dcc_parse_hash;
7896 sort_by_digest = sort_by_digest_4_4;
7897 opti_type = OPTI_TYPE_ZERO_BYTE
7898 | OPTI_TYPE_PRECOMPUTE_INIT
7899 | OPTI_TYPE_PRECOMPUTE_MERKLE
7900 | OPTI_TYPE_EARLY_SKIP
7901 | OPTI_TYPE_NOT_ITERATED;
7902 dgst_pos0 = 0;
7903 dgst_pos1 = 3;
7904 dgst_pos2 = 2;
7905 dgst_pos3 = 1;
7906 break;
7907
7908 case 1400: hash_type = HASH_TYPE_SHA256;
7909 salt_type = SALT_TYPE_NONE;
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_SHA256;
7915 dgst_size = DGST_SIZE_4_8;
7916 parse_func = sha256_parse_hash;
7917 sort_by_digest = sort_by_digest_4_8;
7918 opti_type = OPTI_TYPE_ZERO_BYTE
7919 | OPTI_TYPE_PRECOMPUTE_INIT
7920 | OPTI_TYPE_PRECOMPUTE_MERKLE
7921 | OPTI_TYPE_EARLY_SKIP
7922 | OPTI_TYPE_NOT_ITERATED
7923 | OPTI_TYPE_NOT_SALTED
7924 | OPTI_TYPE_RAW_HASH;
7925 dgst_pos0 = 3;
7926 dgst_pos1 = 7;
7927 dgst_pos2 = 2;
7928 dgst_pos3 = 6;
7929 break;
7930
7931 case 1410: hash_type = HASH_TYPE_SHA256;
7932 salt_type = SALT_TYPE_INTERN;
7933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7934 opts_type = OPTS_TYPE_PT_GENERATE_BE
7935 | OPTS_TYPE_ST_ADD80
7936 | OPTS_TYPE_ST_ADDBITS15;
7937 kern_type = KERN_TYPE_SHA256_PWSLT;
7938 dgst_size = DGST_SIZE_4_8;
7939 parse_func = sha256s_parse_hash;
7940 sort_by_digest = sort_by_digest_4_8;
7941 opti_type = OPTI_TYPE_ZERO_BYTE
7942 | OPTI_TYPE_PRECOMPUTE_INIT
7943 | OPTI_TYPE_PRECOMPUTE_MERKLE
7944 | OPTI_TYPE_EARLY_SKIP
7945 | OPTI_TYPE_NOT_ITERATED
7946 | OPTI_TYPE_APPENDED_SALT
7947 | OPTI_TYPE_RAW_HASH;
7948 dgst_pos0 = 3;
7949 dgst_pos1 = 7;
7950 dgst_pos2 = 2;
7951 dgst_pos3 = 6;
7952 break;
7953
7954 case 1420: hash_type = HASH_TYPE_SHA256;
7955 salt_type = SALT_TYPE_INTERN;
7956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7957 opts_type = OPTS_TYPE_PT_GENERATE_BE
7958 | OPTS_TYPE_PT_ADD80
7959 | OPTS_TYPE_PT_ADDBITS15;
7960 kern_type = KERN_TYPE_SHA256_SLTPW;
7961 dgst_size = DGST_SIZE_4_8;
7962 parse_func = sha256s_parse_hash;
7963 sort_by_digest = sort_by_digest_4_8;
7964 opti_type = OPTI_TYPE_ZERO_BYTE
7965 | OPTI_TYPE_PRECOMPUTE_INIT
7966 | OPTI_TYPE_PRECOMPUTE_MERKLE
7967 | OPTI_TYPE_EARLY_SKIP
7968 | OPTI_TYPE_NOT_ITERATED
7969 | OPTI_TYPE_PREPENDED_SALT
7970 | OPTI_TYPE_RAW_HASH;
7971 dgst_pos0 = 3;
7972 dgst_pos1 = 7;
7973 dgst_pos2 = 2;
7974 dgst_pos3 = 6;
7975 break;
7976
7977 case 1421: hash_type = HASH_TYPE_SHA256;
7978 salt_type = SALT_TYPE_EMBEDDED;
7979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7980 opts_type = OPTS_TYPE_PT_GENERATE_BE
7981 | OPTS_TYPE_PT_ADD80
7982 | OPTS_TYPE_PT_ADDBITS15;
7983 kern_type = KERN_TYPE_SHA256_SLTPW;
7984 dgst_size = DGST_SIZE_4_8;
7985 parse_func = hmailserver_parse_hash;
7986 sort_by_digest = sort_by_digest_4_8;
7987 opti_type = OPTI_TYPE_ZERO_BYTE
7988 | OPTI_TYPE_PRECOMPUTE_INIT
7989 | OPTI_TYPE_PRECOMPUTE_MERKLE
7990 | OPTI_TYPE_EARLY_SKIP
7991 | OPTI_TYPE_NOT_ITERATED
7992 | OPTI_TYPE_PREPENDED_SALT
7993 | OPTI_TYPE_RAW_HASH;
7994 dgst_pos0 = 3;
7995 dgst_pos1 = 7;
7996 dgst_pos2 = 2;
7997 dgst_pos3 = 6;
7998 break;
7999
8000 case 1430: hash_type = HASH_TYPE_SHA256;
8001 salt_type = SALT_TYPE_INTERN;
8002 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8003 opts_type = OPTS_TYPE_PT_GENERATE_BE
8004 | OPTS_TYPE_PT_UNICODE
8005 | OPTS_TYPE_ST_ADD80
8006 | OPTS_TYPE_ST_ADDBITS15;
8007 kern_type = KERN_TYPE_SHA256_PWUSLT;
8008 dgst_size = DGST_SIZE_4_8;
8009 parse_func = sha256s_parse_hash;
8010 sort_by_digest = sort_by_digest_4_8;
8011 opti_type = OPTI_TYPE_ZERO_BYTE
8012 | OPTI_TYPE_PRECOMPUTE_INIT
8013 | OPTI_TYPE_PRECOMPUTE_MERKLE
8014 | OPTI_TYPE_EARLY_SKIP
8015 | OPTI_TYPE_NOT_ITERATED
8016 | OPTI_TYPE_APPENDED_SALT
8017 | OPTI_TYPE_RAW_HASH;
8018 dgst_pos0 = 3;
8019 dgst_pos1 = 7;
8020 dgst_pos2 = 2;
8021 dgst_pos3 = 6;
8022 break;
8023
8024 case 1440: hash_type = HASH_TYPE_SHA256;
8025 salt_type = SALT_TYPE_INTERN;
8026 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8027 opts_type = OPTS_TYPE_PT_GENERATE_BE
8028 | OPTS_TYPE_PT_ADD80
8029 | OPTS_TYPE_PT_ADDBITS15
8030 | OPTS_TYPE_PT_UNICODE;
8031 kern_type = KERN_TYPE_SHA256_SLTPWU;
8032 dgst_size = DGST_SIZE_4_8;
8033 parse_func = sha256s_parse_hash;
8034 sort_by_digest = sort_by_digest_4_8;
8035 opti_type = OPTI_TYPE_ZERO_BYTE
8036 | OPTI_TYPE_PRECOMPUTE_INIT
8037 | OPTI_TYPE_PRECOMPUTE_MERKLE
8038 | OPTI_TYPE_EARLY_SKIP
8039 | OPTI_TYPE_NOT_ITERATED
8040 | OPTI_TYPE_PREPENDED_SALT
8041 | OPTI_TYPE_RAW_HASH;
8042 dgst_pos0 = 3;
8043 dgst_pos1 = 7;
8044 dgst_pos2 = 2;
8045 dgst_pos3 = 6;
8046 break;
8047
8048 case 1441: hash_type = HASH_TYPE_SHA256;
8049 salt_type = SALT_TYPE_EMBEDDED;
8050 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8051 opts_type = OPTS_TYPE_PT_GENERATE_BE
8052 | OPTS_TYPE_PT_ADD80
8053 | OPTS_TYPE_PT_ADDBITS15
8054 | OPTS_TYPE_PT_UNICODE
8055 | OPTS_TYPE_ST_BASE64;
8056 kern_type = KERN_TYPE_SHA256_SLTPWU;
8057 dgst_size = DGST_SIZE_4_8;
8058 parse_func = episerver4_parse_hash;
8059 sort_by_digest = sort_by_digest_4_8;
8060 opti_type = OPTI_TYPE_ZERO_BYTE
8061 | OPTI_TYPE_PRECOMPUTE_INIT
8062 | OPTI_TYPE_PRECOMPUTE_MERKLE
8063 | OPTI_TYPE_EARLY_SKIP
8064 | OPTI_TYPE_NOT_ITERATED
8065 | OPTI_TYPE_PREPENDED_SALT
8066 | OPTI_TYPE_RAW_HASH;
8067 dgst_pos0 = 3;
8068 dgst_pos1 = 7;
8069 dgst_pos2 = 2;
8070 dgst_pos3 = 6;
8071 break;
8072
8073 case 1450: hash_type = HASH_TYPE_SHA256;
8074 salt_type = SALT_TYPE_INTERN;
8075 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8076 opts_type = OPTS_TYPE_PT_GENERATE_BE
8077 | OPTS_TYPE_ST_ADD80;
8078 kern_type = KERN_TYPE_HMACSHA256_PW;
8079 dgst_size = DGST_SIZE_4_8;
8080 parse_func = hmacsha256_parse_hash;
8081 sort_by_digest = sort_by_digest_4_8;
8082 opti_type = OPTI_TYPE_ZERO_BYTE
8083 | OPTI_TYPE_NOT_ITERATED;
8084 dgst_pos0 = 3;
8085 dgst_pos1 = 7;
8086 dgst_pos2 = 2;
8087 dgst_pos3 = 6;
8088 break;
8089
8090 case 1460: hash_type = HASH_TYPE_SHA256;
8091 salt_type = SALT_TYPE_INTERN;
8092 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8093 opts_type = OPTS_TYPE_PT_GENERATE_BE
8094 | OPTS_TYPE_PT_ADD80
8095 | OPTS_TYPE_PT_ADDBITS15;
8096 kern_type = KERN_TYPE_HMACSHA256_SLT;
8097 dgst_size = DGST_SIZE_4_8;
8098 parse_func = hmacsha256_parse_hash;
8099 sort_by_digest = sort_by_digest_4_8;
8100 opti_type = OPTI_TYPE_ZERO_BYTE
8101 | OPTI_TYPE_NOT_ITERATED;
8102 dgst_pos0 = 3;
8103 dgst_pos1 = 7;
8104 dgst_pos2 = 2;
8105 dgst_pos3 = 6;
8106 break;
8107
8108 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8109 salt_type = SALT_TYPE_EMBEDDED;
8110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8111 opts_type = OPTS_TYPE_PT_GENERATE_LE
8112 | OPTS_TYPE_PT_BITSLICE;
8113 kern_type = KERN_TYPE_DESCRYPT;
8114 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8115 parse_func = descrypt_parse_hash;
8116 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8117 opti_type = OPTI_TYPE_ZERO_BYTE
8118 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8119 dgst_pos0 = 0;
8120 dgst_pos1 = 1;
8121 dgst_pos2 = 2;
8122 dgst_pos3 = 3;
8123 break;
8124
8125 case 1600: hash_type = HASH_TYPE_MD5;
8126 salt_type = SALT_TYPE_EMBEDDED;
8127 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8128 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8129 kern_type = KERN_TYPE_APR1CRYPT;
8130 dgst_size = DGST_SIZE_4_4;
8131 parse_func = md5apr1_parse_hash;
8132 sort_by_digest = sort_by_digest_4_4;
8133 opti_type = OPTI_TYPE_ZERO_BYTE;
8134 dgst_pos0 = 0;
8135 dgst_pos1 = 1;
8136 dgst_pos2 = 2;
8137 dgst_pos3 = 3;
8138 break;
8139
8140 case 1700: hash_type = HASH_TYPE_SHA512;
8141 salt_type = SALT_TYPE_NONE;
8142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8143 opts_type = OPTS_TYPE_PT_GENERATE_BE
8144 | OPTS_TYPE_PT_ADD80
8145 | OPTS_TYPE_PT_ADDBITS15;
8146 kern_type = KERN_TYPE_SHA512;
8147 dgst_size = DGST_SIZE_8_8;
8148 parse_func = sha512_parse_hash;
8149 sort_by_digest = sort_by_digest_8_8;
8150 opti_type = OPTI_TYPE_ZERO_BYTE
8151 | OPTI_TYPE_PRECOMPUTE_INIT
8152 | OPTI_TYPE_PRECOMPUTE_MERKLE
8153 | OPTI_TYPE_EARLY_SKIP
8154 | OPTI_TYPE_NOT_ITERATED
8155 | OPTI_TYPE_NOT_SALTED
8156 | OPTI_TYPE_USES_BITS_64
8157 | OPTI_TYPE_RAW_HASH;
8158 dgst_pos0 = 14;
8159 dgst_pos1 = 15;
8160 dgst_pos2 = 6;
8161 dgst_pos3 = 7;
8162 break;
8163
8164 case 1710: hash_type = HASH_TYPE_SHA512;
8165 salt_type = SALT_TYPE_INTERN;
8166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8167 opts_type = OPTS_TYPE_PT_GENERATE_BE
8168 | OPTS_TYPE_ST_ADD80
8169 | OPTS_TYPE_ST_ADDBITS15;
8170 kern_type = KERN_TYPE_SHA512_PWSLT;
8171 dgst_size = DGST_SIZE_8_8;
8172 parse_func = sha512s_parse_hash;
8173 sort_by_digest = sort_by_digest_8_8;
8174 opti_type = OPTI_TYPE_ZERO_BYTE
8175 | OPTI_TYPE_PRECOMPUTE_INIT
8176 | OPTI_TYPE_PRECOMPUTE_MERKLE
8177 | OPTI_TYPE_EARLY_SKIP
8178 | OPTI_TYPE_NOT_ITERATED
8179 | OPTI_TYPE_APPENDED_SALT
8180 | OPTI_TYPE_USES_BITS_64
8181 | OPTI_TYPE_RAW_HASH;
8182 dgst_pos0 = 14;
8183 dgst_pos1 = 15;
8184 dgst_pos2 = 6;
8185 dgst_pos3 = 7;
8186 break;
8187
8188 case 1711: hash_type = HASH_TYPE_SHA512;
8189 salt_type = SALT_TYPE_EMBEDDED;
8190 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8191 opts_type = OPTS_TYPE_PT_GENERATE_BE
8192 | OPTS_TYPE_ST_ADD80
8193 | OPTS_TYPE_ST_ADDBITS15;
8194 kern_type = KERN_TYPE_SHA512_PWSLT;
8195 dgst_size = DGST_SIZE_8_8;
8196 parse_func = sha512b64s_parse_hash;
8197 sort_by_digest = sort_by_digest_8_8;
8198 opti_type = OPTI_TYPE_ZERO_BYTE
8199 | OPTI_TYPE_PRECOMPUTE_INIT
8200 | OPTI_TYPE_PRECOMPUTE_MERKLE
8201 | OPTI_TYPE_EARLY_SKIP
8202 | OPTI_TYPE_NOT_ITERATED
8203 | OPTI_TYPE_APPENDED_SALT
8204 | OPTI_TYPE_USES_BITS_64
8205 | OPTI_TYPE_RAW_HASH;
8206 dgst_pos0 = 14;
8207 dgst_pos1 = 15;
8208 dgst_pos2 = 6;
8209 dgst_pos3 = 7;
8210 break;
8211
8212 case 1720: hash_type = HASH_TYPE_SHA512;
8213 salt_type = SALT_TYPE_INTERN;
8214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8215 opts_type = OPTS_TYPE_PT_GENERATE_BE
8216 | OPTS_TYPE_PT_ADD80
8217 | OPTS_TYPE_PT_ADDBITS15;
8218 kern_type = KERN_TYPE_SHA512_SLTPW;
8219 dgst_size = DGST_SIZE_8_8;
8220 parse_func = sha512s_parse_hash;
8221 sort_by_digest = sort_by_digest_8_8;
8222 opti_type = OPTI_TYPE_ZERO_BYTE
8223 | OPTI_TYPE_PRECOMPUTE_INIT
8224 | OPTI_TYPE_PRECOMPUTE_MERKLE
8225 | OPTI_TYPE_EARLY_SKIP
8226 | OPTI_TYPE_NOT_ITERATED
8227 | OPTI_TYPE_PREPENDED_SALT
8228 | OPTI_TYPE_USES_BITS_64
8229 | OPTI_TYPE_RAW_HASH;
8230 dgst_pos0 = 14;
8231 dgst_pos1 = 15;
8232 dgst_pos2 = 6;
8233 dgst_pos3 = 7;
8234 break;
8235
8236 case 1722: hash_type = HASH_TYPE_SHA512;
8237 salt_type = SALT_TYPE_EMBEDDED;
8238 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8239 opts_type = OPTS_TYPE_PT_GENERATE_BE
8240 | OPTS_TYPE_PT_ADD80
8241 | OPTS_TYPE_PT_ADDBITS15
8242 | OPTS_TYPE_ST_HEX;
8243 kern_type = KERN_TYPE_SHA512_SLTPW;
8244 dgst_size = DGST_SIZE_8_8;
8245 parse_func = osx512_parse_hash;
8246 sort_by_digest = sort_by_digest_8_8;
8247 opti_type = OPTI_TYPE_ZERO_BYTE
8248 | OPTI_TYPE_PRECOMPUTE_INIT
8249 | OPTI_TYPE_PRECOMPUTE_MERKLE
8250 | OPTI_TYPE_EARLY_SKIP
8251 | OPTI_TYPE_NOT_ITERATED
8252 | OPTI_TYPE_PREPENDED_SALT
8253 | OPTI_TYPE_USES_BITS_64
8254 | OPTI_TYPE_RAW_HASH;
8255 dgst_pos0 = 14;
8256 dgst_pos1 = 15;
8257 dgst_pos2 = 6;
8258 dgst_pos3 = 7;
8259 break;
8260
8261 case 1730: hash_type = HASH_TYPE_SHA512;
8262 salt_type = SALT_TYPE_INTERN;
8263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8264 opts_type = OPTS_TYPE_PT_GENERATE_BE
8265 | OPTS_TYPE_PT_UNICODE
8266 | OPTS_TYPE_ST_ADD80
8267 | OPTS_TYPE_ST_ADDBITS15;
8268 kern_type = KERN_TYPE_SHA512_PWSLTU;
8269 dgst_size = DGST_SIZE_8_8;
8270 parse_func = sha512s_parse_hash;
8271 sort_by_digest = sort_by_digest_8_8;
8272 opti_type = OPTI_TYPE_ZERO_BYTE
8273 | OPTI_TYPE_PRECOMPUTE_INIT
8274 | OPTI_TYPE_PRECOMPUTE_MERKLE
8275 | OPTI_TYPE_EARLY_SKIP
8276 | OPTI_TYPE_NOT_ITERATED
8277 | OPTI_TYPE_APPENDED_SALT
8278 | OPTI_TYPE_USES_BITS_64
8279 | OPTI_TYPE_RAW_HASH;
8280 dgst_pos0 = 14;
8281 dgst_pos1 = 15;
8282 dgst_pos2 = 6;
8283 dgst_pos3 = 7;
8284 break;
8285
8286 case 1731: hash_type = HASH_TYPE_SHA512;
8287 salt_type = SALT_TYPE_EMBEDDED;
8288 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8289 opts_type = OPTS_TYPE_PT_GENERATE_BE
8290 | OPTS_TYPE_PT_UNICODE
8291 | OPTS_TYPE_ST_ADD80
8292 | OPTS_TYPE_ST_ADDBITS15
8293 | OPTS_TYPE_ST_HEX;
8294 kern_type = KERN_TYPE_SHA512_PWSLTU;
8295 dgst_size = DGST_SIZE_8_8;
8296 parse_func = mssql2012_parse_hash;
8297 sort_by_digest = sort_by_digest_8_8;
8298 opti_type = OPTI_TYPE_ZERO_BYTE
8299 | OPTI_TYPE_PRECOMPUTE_INIT
8300 | OPTI_TYPE_PRECOMPUTE_MERKLE
8301 | OPTI_TYPE_EARLY_SKIP
8302 | OPTI_TYPE_NOT_ITERATED
8303 | OPTI_TYPE_APPENDED_SALT
8304 | OPTI_TYPE_USES_BITS_64
8305 | OPTI_TYPE_RAW_HASH;
8306 dgst_pos0 = 14;
8307 dgst_pos1 = 15;
8308 dgst_pos2 = 6;
8309 dgst_pos3 = 7;
8310 break;
8311
8312 case 1740: hash_type = HASH_TYPE_SHA512;
8313 salt_type = SALT_TYPE_INTERN;
8314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8315 opts_type = OPTS_TYPE_PT_GENERATE_BE
8316 | OPTS_TYPE_PT_ADD80
8317 | OPTS_TYPE_PT_ADDBITS15
8318 | OPTS_TYPE_PT_UNICODE;
8319 kern_type = KERN_TYPE_SHA512_SLTPWU;
8320 dgst_size = DGST_SIZE_8_8;
8321 parse_func = sha512s_parse_hash;
8322 sort_by_digest = sort_by_digest_8_8;
8323 opti_type = OPTI_TYPE_ZERO_BYTE
8324 | OPTI_TYPE_PRECOMPUTE_INIT
8325 | OPTI_TYPE_PRECOMPUTE_MERKLE
8326 | OPTI_TYPE_EARLY_SKIP
8327 | OPTI_TYPE_NOT_ITERATED
8328 | OPTI_TYPE_PREPENDED_SALT
8329 | OPTI_TYPE_USES_BITS_64
8330 | OPTI_TYPE_RAW_HASH;
8331 dgst_pos0 = 14;
8332 dgst_pos1 = 15;
8333 dgst_pos2 = 6;
8334 dgst_pos3 = 7;
8335 break;
8336
8337 case 1750: hash_type = HASH_TYPE_SHA512;
8338 salt_type = SALT_TYPE_INTERN;
8339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8340 opts_type = OPTS_TYPE_PT_GENERATE_BE
8341 | OPTS_TYPE_ST_ADD80;
8342 kern_type = KERN_TYPE_HMACSHA512_PW;
8343 dgst_size = DGST_SIZE_8_8;
8344 parse_func = hmacsha512_parse_hash;
8345 sort_by_digest = sort_by_digest_8_8;
8346 opti_type = OPTI_TYPE_ZERO_BYTE
8347 | OPTI_TYPE_USES_BITS_64
8348 | OPTI_TYPE_NOT_ITERATED;
8349 dgst_pos0 = 14;
8350 dgst_pos1 = 15;
8351 dgst_pos2 = 6;
8352 dgst_pos3 = 7;
8353 break;
8354
8355 case 1760: hash_type = HASH_TYPE_SHA512;
8356 salt_type = SALT_TYPE_INTERN;
8357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8358 opts_type = OPTS_TYPE_PT_GENERATE_BE
8359 | OPTS_TYPE_PT_ADD80
8360 | OPTS_TYPE_PT_ADDBITS15;
8361 kern_type = KERN_TYPE_HMACSHA512_SLT;
8362 dgst_size = DGST_SIZE_8_8;
8363 parse_func = hmacsha512_parse_hash;
8364 sort_by_digest = sort_by_digest_8_8;
8365 opti_type = OPTI_TYPE_ZERO_BYTE
8366 | OPTI_TYPE_USES_BITS_64
8367 | OPTI_TYPE_NOT_ITERATED;
8368 dgst_pos0 = 14;
8369 dgst_pos1 = 15;
8370 dgst_pos2 = 6;
8371 dgst_pos3 = 7;
8372 break;
8373
8374 case 1800: hash_type = HASH_TYPE_SHA512;
8375 salt_type = SALT_TYPE_EMBEDDED;
8376 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8377 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8378 kern_type = KERN_TYPE_SHA512CRYPT;
8379 dgst_size = DGST_SIZE_8_8;
8380 parse_func = sha512crypt_parse_hash;
8381 sort_by_digest = sort_by_digest_8_8;
8382 opti_type = OPTI_TYPE_ZERO_BYTE
8383 | OPTI_TYPE_USES_BITS_64;
8384 dgst_pos0 = 0;
8385 dgst_pos1 = 1;
8386 dgst_pos2 = 2;
8387 dgst_pos3 = 3;
8388 break;
8389
8390 case 2100: hash_type = HASH_TYPE_DCC2;
8391 salt_type = SALT_TYPE_EMBEDDED;
8392 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8393 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8394 | OPTS_TYPE_ST_LOWER
8395 | OPTS_TYPE_ST_UNICODE;
8396 kern_type = KERN_TYPE_DCC2;
8397 dgst_size = DGST_SIZE_4_4;
8398 parse_func = dcc2_parse_hash;
8399 sort_by_digest = sort_by_digest_4_4;
8400 opti_type = OPTI_TYPE_ZERO_BYTE
8401 | OPTI_TYPE_SLOW_HASH_SIMD;
8402 dgst_pos0 = 0;
8403 dgst_pos1 = 1;
8404 dgst_pos2 = 2;
8405 dgst_pos3 = 3;
8406 break;
8407
8408 case 2400: hash_type = HASH_TYPE_MD5;
8409 salt_type = SALT_TYPE_NONE;
8410 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8411 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8412 kern_type = KERN_TYPE_MD5PIX;
8413 dgst_size = DGST_SIZE_4_4;
8414 parse_func = md5pix_parse_hash;
8415 sort_by_digest = sort_by_digest_4_4;
8416 opti_type = OPTI_TYPE_ZERO_BYTE
8417 | OPTI_TYPE_PRECOMPUTE_INIT
8418 | OPTI_TYPE_PRECOMPUTE_MERKLE
8419 | OPTI_TYPE_EARLY_SKIP
8420 | OPTI_TYPE_NOT_ITERATED
8421 | OPTI_TYPE_NOT_SALTED;
8422 dgst_pos0 = 0;
8423 dgst_pos1 = 3;
8424 dgst_pos2 = 2;
8425 dgst_pos3 = 1;
8426 break;
8427
8428 case 2410: hash_type = HASH_TYPE_MD5;
8429 salt_type = SALT_TYPE_INTERN;
8430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8431 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8432 kern_type = KERN_TYPE_MD5ASA;
8433 dgst_size = DGST_SIZE_4_4;
8434 parse_func = md5asa_parse_hash;
8435 sort_by_digest = sort_by_digest_4_4;
8436 opti_type = OPTI_TYPE_ZERO_BYTE
8437 | OPTI_TYPE_PRECOMPUTE_INIT
8438 | OPTI_TYPE_PRECOMPUTE_MERKLE
8439 | OPTI_TYPE_EARLY_SKIP
8440 | OPTI_TYPE_NOT_ITERATED;
8441 dgst_pos0 = 0;
8442 dgst_pos1 = 3;
8443 dgst_pos2 = 2;
8444 dgst_pos3 = 1;
8445 break;
8446
8447 case 2500: hash_type = HASH_TYPE_WPA;
8448 salt_type = SALT_TYPE_EMBEDDED;
8449 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8450 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8451 kern_type = KERN_TYPE_WPA;
8452 dgst_size = DGST_SIZE_4_4;
8453 parse_func = wpa_parse_hash;
8454 sort_by_digest = sort_by_digest_4_4;
8455 opti_type = OPTI_TYPE_ZERO_BYTE
8456 | OPTI_TYPE_SLOW_HASH_SIMD;
8457 dgst_pos0 = 0;
8458 dgst_pos1 = 1;
8459 dgst_pos2 = 2;
8460 dgst_pos3 = 3;
8461 break;
8462
8463 case 2600: hash_type = HASH_TYPE_MD5;
8464 salt_type = SALT_TYPE_VIRTUAL;
8465 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8466 opts_type = OPTS_TYPE_PT_GENERATE_LE
8467 | OPTS_TYPE_PT_ADD80
8468 | OPTS_TYPE_PT_ADDBITS14
8469 | OPTS_TYPE_ST_ADD80;
8470 kern_type = KERN_TYPE_MD55_PWSLT1;
8471 dgst_size = DGST_SIZE_4_4;
8472 parse_func = md5md5_parse_hash;
8473 sort_by_digest = sort_by_digest_4_4;
8474 opti_type = OPTI_TYPE_ZERO_BYTE
8475 | OPTI_TYPE_PRECOMPUTE_INIT
8476 | OPTI_TYPE_PRECOMPUTE_MERKLE
8477 | OPTI_TYPE_EARLY_SKIP;
8478 dgst_pos0 = 0;
8479 dgst_pos1 = 3;
8480 dgst_pos2 = 2;
8481 dgst_pos3 = 1;
8482 break;
8483
8484 case 2611: hash_type = HASH_TYPE_MD5;
8485 salt_type = SALT_TYPE_INTERN;
8486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8487 opts_type = OPTS_TYPE_PT_GENERATE_LE
8488 | OPTS_TYPE_PT_ADD80
8489 | OPTS_TYPE_PT_ADDBITS14
8490 | OPTS_TYPE_ST_ADD80;
8491 kern_type = KERN_TYPE_MD55_PWSLT1;
8492 dgst_size = DGST_SIZE_4_4;
8493 parse_func = vb3_parse_hash;
8494 sort_by_digest = sort_by_digest_4_4;
8495 opti_type = OPTI_TYPE_ZERO_BYTE
8496 | OPTI_TYPE_PRECOMPUTE_INIT
8497 | OPTI_TYPE_PRECOMPUTE_MERKLE
8498 | OPTI_TYPE_EARLY_SKIP;
8499 dgst_pos0 = 0;
8500 dgst_pos1 = 3;
8501 dgst_pos2 = 2;
8502 dgst_pos3 = 1;
8503 break;
8504
8505 case 2612: hash_type = HASH_TYPE_MD5;
8506 salt_type = SALT_TYPE_EMBEDDED;
8507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8508 opts_type = OPTS_TYPE_PT_GENERATE_LE
8509 | OPTS_TYPE_PT_ADD80
8510 | OPTS_TYPE_PT_ADDBITS14
8511 | OPTS_TYPE_ST_ADD80
8512 | OPTS_TYPE_ST_HEX;
8513 kern_type = KERN_TYPE_MD55_PWSLT1;
8514 dgst_size = DGST_SIZE_4_4;
8515 parse_func = phps_parse_hash;
8516 sort_by_digest = sort_by_digest_4_4;
8517 opti_type = OPTI_TYPE_ZERO_BYTE
8518 | OPTI_TYPE_PRECOMPUTE_INIT
8519 | OPTI_TYPE_PRECOMPUTE_MERKLE
8520 | OPTI_TYPE_EARLY_SKIP;
8521 dgst_pos0 = 0;
8522 dgst_pos1 = 3;
8523 dgst_pos2 = 2;
8524 dgst_pos3 = 1;
8525 break;
8526
8527 case 2711: hash_type = HASH_TYPE_MD5;
8528 salt_type = SALT_TYPE_INTERN;
8529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8530 opts_type = OPTS_TYPE_PT_GENERATE_LE
8531 | OPTS_TYPE_PT_ADD80
8532 | OPTS_TYPE_PT_ADDBITS14
8533 | OPTS_TYPE_ST_ADD80;
8534 kern_type = KERN_TYPE_MD55_PWSLT2;
8535 dgst_size = DGST_SIZE_4_4;
8536 parse_func = vb30_parse_hash;
8537 sort_by_digest = sort_by_digest_4_4;
8538 opti_type = OPTI_TYPE_ZERO_BYTE
8539 | OPTI_TYPE_PRECOMPUTE_INIT
8540 | OPTI_TYPE_EARLY_SKIP;
8541 dgst_pos0 = 0;
8542 dgst_pos1 = 3;
8543 dgst_pos2 = 2;
8544 dgst_pos3 = 1;
8545 break;
8546
8547 case 2811: hash_type = HASH_TYPE_MD5;
8548 salt_type = SALT_TYPE_INTERN;
8549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8550 opts_type = OPTS_TYPE_PT_GENERATE_LE
8551 | OPTS_TYPE_PT_ADD80
8552 | OPTS_TYPE_PT_ADDBITS14;
8553 kern_type = KERN_TYPE_MD55_SLTPW;
8554 dgst_size = DGST_SIZE_4_4;
8555 parse_func = ipb2_parse_hash;
8556 sort_by_digest = sort_by_digest_4_4;
8557 opti_type = OPTI_TYPE_ZERO_BYTE
8558 | OPTI_TYPE_PRECOMPUTE_INIT
8559 | OPTI_TYPE_EARLY_SKIP;
8560 dgst_pos0 = 0;
8561 dgst_pos1 = 3;
8562 dgst_pos2 = 2;
8563 dgst_pos3 = 1;
8564 break;
8565
8566 case 3000: hash_type = HASH_TYPE_LM;
8567 salt_type = SALT_TYPE_NONE;
8568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8569 opts_type = OPTS_TYPE_PT_GENERATE_LE
8570 | OPTS_TYPE_PT_UPPER
8571 | OPTS_TYPE_PT_BITSLICE;
8572 kern_type = KERN_TYPE_LM;
8573 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8574 parse_func = lm_parse_hash;
8575 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8576 opti_type = OPTI_TYPE_ZERO_BYTE
8577 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8578 dgst_pos0 = 0;
8579 dgst_pos1 = 1;
8580 dgst_pos2 = 2;
8581 dgst_pos3 = 3;
8582 break;
8583
8584 case 3100: hash_type = HASH_TYPE_ORACLEH;
8585 salt_type = SALT_TYPE_INTERN;
8586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8587 opts_type = OPTS_TYPE_PT_GENERATE_LE
8588 | OPTS_TYPE_PT_UPPER
8589 | OPTS_TYPE_ST_UPPER;
8590 kern_type = KERN_TYPE_ORACLEH;
8591 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8592 parse_func = oracleh_parse_hash;
8593 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8594 opti_type = OPTI_TYPE_ZERO_BYTE;
8595 dgst_pos0 = 0;
8596 dgst_pos1 = 1;
8597 dgst_pos2 = 2;
8598 dgst_pos3 = 3;
8599 break;
8600
8601 case 3200: hash_type = HASH_TYPE_BCRYPT;
8602 salt_type = SALT_TYPE_EMBEDDED;
8603 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8604 opts_type = OPTS_TYPE_PT_GENERATE_LE
8605 | OPTS_TYPE_ST_GENERATE_LE;
8606 kern_type = KERN_TYPE_BCRYPT;
8607 dgst_size = DGST_SIZE_4_6;
8608 parse_func = bcrypt_parse_hash;
8609 sort_by_digest = sort_by_digest_4_6;
8610 opti_type = OPTI_TYPE_ZERO_BYTE;
8611 dgst_pos0 = 0;
8612 dgst_pos1 = 1;
8613 dgst_pos2 = 2;
8614 dgst_pos3 = 3;
8615 break;
8616
8617 case 3710: hash_type = HASH_TYPE_MD5;
8618 salt_type = SALT_TYPE_INTERN;
8619 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8620 opts_type = OPTS_TYPE_PT_GENERATE_LE
8621 | OPTS_TYPE_PT_ADD80
8622 | OPTS_TYPE_PT_ADDBITS14;
8623 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8624 dgst_size = DGST_SIZE_4_4;
8625 parse_func = md5s_parse_hash;
8626 sort_by_digest = sort_by_digest_4_4;
8627 opti_type = OPTI_TYPE_ZERO_BYTE
8628 | OPTI_TYPE_PRECOMPUTE_INIT
8629 | OPTI_TYPE_PRECOMPUTE_MERKLE
8630 | OPTI_TYPE_EARLY_SKIP;
8631 dgst_pos0 = 0;
8632 dgst_pos1 = 3;
8633 dgst_pos2 = 2;
8634 dgst_pos3 = 1;
8635 break;
8636
8637 case 3711: hash_type = HASH_TYPE_MD5;
8638 salt_type = SALT_TYPE_EMBEDDED;
8639 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8640 opts_type = OPTS_TYPE_PT_GENERATE_LE
8641 | OPTS_TYPE_PT_ADD80
8642 | OPTS_TYPE_PT_ADDBITS14;
8643 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8644 dgst_size = DGST_SIZE_4_4;
8645 parse_func = mediawiki_b_parse_hash;
8646 sort_by_digest = sort_by_digest_4_4;
8647 opti_type = OPTI_TYPE_ZERO_BYTE
8648 | OPTI_TYPE_PRECOMPUTE_INIT
8649 | OPTI_TYPE_PRECOMPUTE_MERKLE
8650 | OPTI_TYPE_EARLY_SKIP;
8651 dgst_pos0 = 0;
8652 dgst_pos1 = 3;
8653 dgst_pos2 = 2;
8654 dgst_pos3 = 1;
8655 break;
8656
8657 case 3800: hash_type = HASH_TYPE_MD5;
8658 salt_type = SALT_TYPE_INTERN;
8659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8660 opts_type = OPTS_TYPE_PT_GENERATE_LE
8661 | OPTS_TYPE_ST_ADDBITS14;
8662 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8663 dgst_size = DGST_SIZE_4_4;
8664 parse_func = md5s_parse_hash;
8665 sort_by_digest = sort_by_digest_4_4;
8666 opti_type = OPTI_TYPE_ZERO_BYTE
8667 | OPTI_TYPE_PRECOMPUTE_INIT
8668 | OPTI_TYPE_PRECOMPUTE_MERKLE
8669 | OPTI_TYPE_EARLY_SKIP
8670 | OPTI_TYPE_NOT_ITERATED
8671 | OPTI_TYPE_RAW_HASH;
8672 dgst_pos0 = 0;
8673 dgst_pos1 = 3;
8674 dgst_pos2 = 2;
8675 dgst_pos3 = 1;
8676 break;
8677
8678 case 4300: hash_type = HASH_TYPE_MD5;
8679 salt_type = SALT_TYPE_VIRTUAL;
8680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8681 opts_type = OPTS_TYPE_PT_GENERATE_LE
8682 | OPTS_TYPE_PT_ADD80
8683 | OPTS_TYPE_PT_ADDBITS14
8684 | OPTS_TYPE_ST_ADD80;
8685 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8686 dgst_size = DGST_SIZE_4_4;
8687 parse_func = md5md5_parse_hash;
8688 sort_by_digest = sort_by_digest_4_4;
8689 opti_type = OPTI_TYPE_ZERO_BYTE
8690 | OPTI_TYPE_PRECOMPUTE_INIT
8691 | OPTI_TYPE_PRECOMPUTE_MERKLE
8692 | OPTI_TYPE_EARLY_SKIP;
8693 dgst_pos0 = 0;
8694 dgst_pos1 = 3;
8695 dgst_pos2 = 2;
8696 dgst_pos3 = 1;
8697 break;
8698
8699
8700 case 4400: hash_type = HASH_TYPE_MD5;
8701 salt_type = SALT_TYPE_NONE;
8702 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8703 opts_type = OPTS_TYPE_PT_GENERATE_BE
8704 | OPTS_TYPE_PT_ADD80
8705 | OPTS_TYPE_PT_ADDBITS15;
8706 kern_type = KERN_TYPE_MD5_SHA1;
8707 dgst_size = DGST_SIZE_4_4;
8708 parse_func = md5_parse_hash;
8709 sort_by_digest = sort_by_digest_4_4;
8710 opti_type = OPTI_TYPE_ZERO_BYTE
8711 | OPTI_TYPE_PRECOMPUTE_INIT
8712 | OPTI_TYPE_PRECOMPUTE_MERKLE
8713 | OPTI_TYPE_EARLY_SKIP
8714 | OPTI_TYPE_NOT_ITERATED
8715 | OPTI_TYPE_NOT_SALTED
8716 | OPTI_TYPE_RAW_HASH;
8717 dgst_pos0 = 0;
8718 dgst_pos1 = 3;
8719 dgst_pos2 = 2;
8720 dgst_pos3 = 1;
8721 break;
8722
8723 case 4500: hash_type = HASH_TYPE_SHA1;
8724 salt_type = SALT_TYPE_NONE;
8725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8726 opts_type = OPTS_TYPE_PT_GENERATE_BE
8727 | OPTS_TYPE_PT_ADD80
8728 | OPTS_TYPE_PT_ADDBITS15;
8729 kern_type = KERN_TYPE_SHA11;
8730 dgst_size = DGST_SIZE_4_5;
8731 parse_func = sha1_parse_hash;
8732 sort_by_digest = sort_by_digest_4_5;
8733 opti_type = OPTI_TYPE_ZERO_BYTE
8734 | OPTI_TYPE_PRECOMPUTE_INIT
8735 | OPTI_TYPE_PRECOMPUTE_MERKLE
8736 | OPTI_TYPE_EARLY_SKIP
8737 | OPTI_TYPE_NOT_SALTED;
8738 dgst_pos0 = 3;
8739 dgst_pos1 = 4;
8740 dgst_pos2 = 2;
8741 dgst_pos3 = 1;
8742 break;
8743
8744 case 4700: hash_type = HASH_TYPE_SHA1;
8745 salt_type = SALT_TYPE_NONE;
8746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8747 opts_type = OPTS_TYPE_PT_GENERATE_LE
8748 | OPTS_TYPE_PT_ADD80
8749 | OPTS_TYPE_PT_ADDBITS14;
8750 kern_type = KERN_TYPE_SHA1_MD5;
8751 dgst_size = DGST_SIZE_4_5;
8752 parse_func = sha1_parse_hash;
8753 sort_by_digest = sort_by_digest_4_5;
8754 opti_type = OPTI_TYPE_ZERO_BYTE
8755 | OPTI_TYPE_PRECOMPUTE_INIT
8756 | OPTI_TYPE_PRECOMPUTE_MERKLE
8757 | OPTI_TYPE_EARLY_SKIP
8758 | OPTI_TYPE_NOT_ITERATED
8759 | OPTI_TYPE_NOT_SALTED
8760 | OPTI_TYPE_RAW_HASH;
8761 dgst_pos0 = 3;
8762 dgst_pos1 = 4;
8763 dgst_pos2 = 2;
8764 dgst_pos3 = 1;
8765 break;
8766
8767 case 4800: hash_type = HASH_TYPE_MD5;
8768 salt_type = SALT_TYPE_EMBEDDED;
8769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8770 opts_type = OPTS_TYPE_PT_GENERATE_LE
8771 | OPTS_TYPE_PT_ADDBITS14;
8772 kern_type = KERN_TYPE_MD5_CHAP;
8773 dgst_size = DGST_SIZE_4_4;
8774 parse_func = chap_parse_hash;
8775 sort_by_digest = sort_by_digest_4_4;
8776 opti_type = OPTI_TYPE_ZERO_BYTE
8777 | OPTI_TYPE_PRECOMPUTE_INIT
8778 | OPTI_TYPE_PRECOMPUTE_MERKLE
8779 | OPTI_TYPE_MEET_IN_MIDDLE
8780 | OPTI_TYPE_EARLY_SKIP
8781 | OPTI_TYPE_NOT_ITERATED
8782 | OPTI_TYPE_RAW_HASH;
8783 dgst_pos0 = 0;
8784 dgst_pos1 = 3;
8785 dgst_pos2 = 2;
8786 dgst_pos3 = 1;
8787 break;
8788
8789 case 4900: hash_type = HASH_TYPE_SHA1;
8790 salt_type = SALT_TYPE_INTERN;
8791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8792 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8793 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8794 dgst_size = DGST_SIZE_4_5;
8795 parse_func = sha1s_parse_hash;
8796 sort_by_digest = sort_by_digest_4_5;
8797 opti_type = OPTI_TYPE_ZERO_BYTE
8798 | OPTI_TYPE_PRECOMPUTE_INIT
8799 | OPTI_TYPE_PRECOMPUTE_MERKLE
8800 | OPTI_TYPE_EARLY_SKIP;
8801 dgst_pos0 = 3;
8802 dgst_pos1 = 4;
8803 dgst_pos2 = 2;
8804 dgst_pos3 = 1;
8805 break;
8806
8807 case 5000: hash_type = HASH_TYPE_KECCAK;
8808 salt_type = SALT_TYPE_EMBEDDED;
8809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8810 opts_type = OPTS_TYPE_PT_GENERATE_LE
8811 | OPTS_TYPE_PT_ADD01;
8812 kern_type = KERN_TYPE_KECCAK;
8813 dgst_size = DGST_SIZE_8_25;
8814 parse_func = keccak_parse_hash;
8815 sort_by_digest = sort_by_digest_8_25;
8816 opti_type = OPTI_TYPE_ZERO_BYTE
8817 | OPTI_TYPE_USES_BITS_64
8818 | OPTI_TYPE_RAW_HASH;
8819 dgst_pos0 = 2;
8820 dgst_pos1 = 3;
8821 dgst_pos2 = 4;
8822 dgst_pos3 = 5;
8823 break;
8824
8825 case 5100: hash_type = HASH_TYPE_MD5H;
8826 salt_type = SALT_TYPE_NONE;
8827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8828 opts_type = OPTS_TYPE_PT_GENERATE_LE
8829 | OPTS_TYPE_PT_ADD80
8830 | OPTS_TYPE_PT_ADDBITS14;
8831 kern_type = KERN_TYPE_MD5H;
8832 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8833 parse_func = md5half_parse_hash;
8834 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8835 opti_type = OPTI_TYPE_ZERO_BYTE
8836 | OPTI_TYPE_RAW_HASH;
8837 dgst_pos0 = 0;
8838 dgst_pos1 = 1;
8839 dgst_pos2 = 2;
8840 dgst_pos3 = 3;
8841 break;
8842
8843 case 5200: hash_type = HASH_TYPE_SHA256;
8844 salt_type = SALT_TYPE_EMBEDDED;
8845 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8846 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8847 kern_type = KERN_TYPE_PSAFE3;
8848 dgst_size = DGST_SIZE_4_8;
8849 parse_func = psafe3_parse_hash;
8850 sort_by_digest = sort_by_digest_4_8;
8851 opti_type = OPTI_TYPE_ZERO_BYTE;
8852 dgst_pos0 = 0;
8853 dgst_pos1 = 1;
8854 dgst_pos2 = 2;
8855 dgst_pos3 = 3;
8856 break;
8857
8858 case 5300: hash_type = HASH_TYPE_MD5;
8859 salt_type = SALT_TYPE_EMBEDDED;
8860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8861 opts_type = OPTS_TYPE_PT_GENERATE_LE
8862 | OPTS_TYPE_ST_ADD80;
8863 kern_type = KERN_TYPE_IKEPSK_MD5;
8864 dgst_size = DGST_SIZE_4_4;
8865 parse_func = ikepsk_md5_parse_hash;
8866 sort_by_digest = sort_by_digest_4_4;
8867 opti_type = OPTI_TYPE_ZERO_BYTE;
8868 dgst_pos0 = 0;
8869 dgst_pos1 = 3;
8870 dgst_pos2 = 2;
8871 dgst_pos3 = 1;
8872 break;
8873
8874 case 5400: hash_type = HASH_TYPE_SHA1;
8875 salt_type = SALT_TYPE_EMBEDDED;
8876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8877 opts_type = OPTS_TYPE_PT_GENERATE_BE
8878 | OPTS_TYPE_ST_ADD80;
8879 kern_type = KERN_TYPE_IKEPSK_SHA1;
8880 dgst_size = DGST_SIZE_4_5;
8881 parse_func = ikepsk_sha1_parse_hash;
8882 sort_by_digest = sort_by_digest_4_5;
8883 opti_type = OPTI_TYPE_ZERO_BYTE;
8884 dgst_pos0 = 3;
8885 dgst_pos1 = 4;
8886 dgst_pos2 = 2;
8887 dgst_pos3 = 1;
8888 break;
8889
8890 case 5500: hash_type = HASH_TYPE_NETNTLM;
8891 salt_type = SALT_TYPE_EMBEDDED;
8892 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8893 opts_type = OPTS_TYPE_PT_GENERATE_LE
8894 | OPTS_TYPE_PT_ADD80
8895 | OPTS_TYPE_PT_ADDBITS14
8896 | OPTS_TYPE_PT_UNICODE
8897 | OPTS_TYPE_ST_HEX;
8898 kern_type = KERN_TYPE_NETNTLMv1;
8899 dgst_size = DGST_SIZE_4_4;
8900 parse_func = netntlmv1_parse_hash;
8901 sort_by_digest = sort_by_digest_4_4;
8902 opti_type = OPTI_TYPE_ZERO_BYTE
8903 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8904 dgst_pos0 = 0;
8905 dgst_pos1 = 1;
8906 dgst_pos2 = 2;
8907 dgst_pos3 = 3;
8908 break;
8909
8910 case 5600: hash_type = HASH_TYPE_MD5;
8911 salt_type = SALT_TYPE_EMBEDDED;
8912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8913 opts_type = OPTS_TYPE_PT_GENERATE_LE
8914 | OPTS_TYPE_PT_ADD80
8915 | OPTS_TYPE_PT_ADDBITS14
8916 | OPTS_TYPE_PT_UNICODE;
8917 kern_type = KERN_TYPE_NETNTLMv2;
8918 dgst_size = DGST_SIZE_4_4;
8919 parse_func = netntlmv2_parse_hash;
8920 sort_by_digest = sort_by_digest_4_4;
8921 opti_type = OPTI_TYPE_ZERO_BYTE;
8922 dgst_pos0 = 0;
8923 dgst_pos1 = 3;
8924 dgst_pos2 = 2;
8925 dgst_pos3 = 1;
8926 break;
8927
8928 case 5700: hash_type = HASH_TYPE_SHA256;
8929 salt_type = SALT_TYPE_NONE;
8930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8931 opts_type = OPTS_TYPE_PT_GENERATE_BE
8932 | OPTS_TYPE_PT_ADD80
8933 | OPTS_TYPE_PT_ADDBITS15;
8934 kern_type = KERN_TYPE_SHA256;
8935 dgst_size = DGST_SIZE_4_8;
8936 parse_func = cisco4_parse_hash;
8937 sort_by_digest = sort_by_digest_4_8;
8938 opti_type = OPTI_TYPE_ZERO_BYTE
8939 | OPTI_TYPE_PRECOMPUTE_INIT
8940 | OPTI_TYPE_PRECOMPUTE_MERKLE
8941 | OPTI_TYPE_EARLY_SKIP
8942 | OPTI_TYPE_NOT_ITERATED
8943 | OPTI_TYPE_NOT_SALTED
8944 | OPTI_TYPE_RAW_HASH;
8945 dgst_pos0 = 3;
8946 dgst_pos1 = 7;
8947 dgst_pos2 = 2;
8948 dgst_pos3 = 6;
8949 break;
8950
8951 case 5800: hash_type = HASH_TYPE_SHA1;
8952 salt_type = SALT_TYPE_INTERN;
8953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8954 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8955 | OPTS_TYPE_ST_ADD80;
8956 kern_type = KERN_TYPE_ANDROIDPIN;
8957 dgst_size = DGST_SIZE_4_5;
8958 parse_func = androidpin_parse_hash;
8959 sort_by_digest = sort_by_digest_4_5;
8960 opti_type = OPTI_TYPE_ZERO_BYTE;
8961 dgst_pos0 = 0;
8962 dgst_pos1 = 1;
8963 dgst_pos2 = 2;
8964 dgst_pos3 = 3;
8965 break;
8966
8967 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8968 salt_type = SALT_TYPE_NONE;
8969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8970 opts_type = OPTS_TYPE_PT_GENERATE_LE
8971 | OPTS_TYPE_PT_ADD80;
8972 kern_type = KERN_TYPE_RIPEMD160;
8973 dgst_size = DGST_SIZE_4_5;
8974 parse_func = ripemd160_parse_hash;
8975 sort_by_digest = sort_by_digest_4_5;
8976 opti_type = OPTI_TYPE_ZERO_BYTE;
8977 dgst_pos0 = 0;
8978 dgst_pos1 = 1;
8979 dgst_pos2 = 2;
8980 dgst_pos3 = 3;
8981 break;
8982
8983 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8984 salt_type = SALT_TYPE_NONE;
8985 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8986 opts_type = OPTS_TYPE_PT_GENERATE_BE
8987 | OPTS_TYPE_PT_ADD80;
8988 kern_type = KERN_TYPE_WHIRLPOOL;
8989 dgst_size = DGST_SIZE_4_16;
8990 parse_func = whirlpool_parse_hash;
8991 sort_by_digest = sort_by_digest_4_16;
8992 opti_type = OPTI_TYPE_ZERO_BYTE;
8993 dgst_pos0 = 0;
8994 dgst_pos1 = 1;
8995 dgst_pos2 = 2;
8996 dgst_pos3 = 3;
8997 break;
8998
8999 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9000 salt_type = SALT_TYPE_EMBEDDED;
9001 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9002 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9003 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9004 dgst_size = DGST_SIZE_4_5;
9005 parse_func = truecrypt_parse_hash_2k;
9006 sort_by_digest = sort_by_digest_4_5;
9007 opti_type = OPTI_TYPE_ZERO_BYTE;
9008 dgst_pos0 = 0;
9009 dgst_pos1 = 1;
9010 dgst_pos2 = 2;
9011 dgst_pos3 = 3;
9012 break;
9013
9014 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9015 salt_type = SALT_TYPE_EMBEDDED;
9016 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9017 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9018 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9019 dgst_size = DGST_SIZE_4_5;
9020 parse_func = truecrypt_parse_hash_2k;
9021 sort_by_digest = sort_by_digest_4_5;
9022 opti_type = OPTI_TYPE_ZERO_BYTE;
9023 dgst_pos0 = 0;
9024 dgst_pos1 = 1;
9025 dgst_pos2 = 2;
9026 dgst_pos3 = 3;
9027 break;
9028
9029 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9030 salt_type = SALT_TYPE_EMBEDDED;
9031 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9032 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9033 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9034 dgst_size = DGST_SIZE_4_5;
9035 parse_func = truecrypt_parse_hash_2k;
9036 sort_by_digest = sort_by_digest_4_5;
9037 opti_type = OPTI_TYPE_ZERO_BYTE;
9038 dgst_pos0 = 0;
9039 dgst_pos1 = 1;
9040 dgst_pos2 = 2;
9041 dgst_pos3 = 3;
9042 break;
9043
9044 case 6221: hash_type = HASH_TYPE_SHA512;
9045 salt_type = SALT_TYPE_EMBEDDED;
9046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9047 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9048 kern_type = KERN_TYPE_TCSHA512_XTS512;
9049 dgst_size = DGST_SIZE_8_8;
9050 parse_func = truecrypt_parse_hash_1k;
9051 sort_by_digest = sort_by_digest_8_8;
9052 opti_type = OPTI_TYPE_ZERO_BYTE
9053 | OPTI_TYPE_USES_BITS_64;
9054 dgst_pos0 = 0;
9055 dgst_pos1 = 1;
9056 dgst_pos2 = 2;
9057 dgst_pos3 = 3;
9058 break;
9059
9060 case 6222: hash_type = HASH_TYPE_SHA512;
9061 salt_type = SALT_TYPE_EMBEDDED;
9062 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9063 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9064 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9065 dgst_size = DGST_SIZE_8_8;
9066 parse_func = truecrypt_parse_hash_1k;
9067 sort_by_digest = sort_by_digest_8_8;
9068 opti_type = OPTI_TYPE_ZERO_BYTE
9069 | OPTI_TYPE_USES_BITS_64;
9070 dgst_pos0 = 0;
9071 dgst_pos1 = 1;
9072 dgst_pos2 = 2;
9073 dgst_pos3 = 3;
9074 break;
9075
9076 case 6223: hash_type = HASH_TYPE_SHA512;
9077 salt_type = SALT_TYPE_EMBEDDED;
9078 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9079 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9080 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9081 dgst_size = DGST_SIZE_8_8;
9082 parse_func = truecrypt_parse_hash_1k;
9083 sort_by_digest = sort_by_digest_8_8;
9084 opti_type = OPTI_TYPE_ZERO_BYTE
9085 | OPTI_TYPE_USES_BITS_64;
9086 dgst_pos0 = 0;
9087 dgst_pos1 = 1;
9088 dgst_pos2 = 2;
9089 dgst_pos3 = 3;
9090 break;
9091
9092 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9093 salt_type = SALT_TYPE_EMBEDDED;
9094 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9095 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9096 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9097 dgst_size = DGST_SIZE_4_8;
9098 parse_func = truecrypt_parse_hash_1k;
9099 sort_by_digest = sort_by_digest_4_8;
9100 opti_type = OPTI_TYPE_ZERO_BYTE;
9101 dgst_pos0 = 0;
9102 dgst_pos1 = 1;
9103 dgst_pos2 = 2;
9104 dgst_pos3 = 3;
9105 break;
9106
9107 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9108 salt_type = SALT_TYPE_EMBEDDED;
9109 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9110 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9111 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9112 dgst_size = DGST_SIZE_4_8;
9113 parse_func = truecrypt_parse_hash_1k;
9114 sort_by_digest = sort_by_digest_4_8;
9115 opti_type = OPTI_TYPE_ZERO_BYTE;
9116 dgst_pos0 = 0;
9117 dgst_pos1 = 1;
9118 dgst_pos2 = 2;
9119 dgst_pos3 = 3;
9120 break;
9121
9122 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9123 salt_type = SALT_TYPE_EMBEDDED;
9124 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9125 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9126 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9127 dgst_size = DGST_SIZE_4_8;
9128 parse_func = truecrypt_parse_hash_1k;
9129 sort_by_digest = sort_by_digest_4_8;
9130 opti_type = OPTI_TYPE_ZERO_BYTE;
9131 dgst_pos0 = 0;
9132 dgst_pos1 = 1;
9133 dgst_pos2 = 2;
9134 dgst_pos3 = 3;
9135 break;
9136
9137 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9138 salt_type = SALT_TYPE_EMBEDDED;
9139 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9140 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9141 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9142 dgst_size = DGST_SIZE_4_5;
9143 parse_func = truecrypt_parse_hash_1k;
9144 sort_by_digest = sort_by_digest_4_5;
9145 opti_type = OPTI_TYPE_ZERO_BYTE;
9146 dgst_pos0 = 0;
9147 dgst_pos1 = 1;
9148 dgst_pos2 = 2;
9149 dgst_pos3 = 3;
9150 break;
9151
9152 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9153 salt_type = SALT_TYPE_EMBEDDED;
9154 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9155 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9156 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9157 dgst_size = DGST_SIZE_4_5;
9158 parse_func = truecrypt_parse_hash_1k;
9159 sort_by_digest = sort_by_digest_4_5;
9160 opti_type = OPTI_TYPE_ZERO_BYTE;
9161 dgst_pos0 = 0;
9162 dgst_pos1 = 1;
9163 dgst_pos2 = 2;
9164 dgst_pos3 = 3;
9165 break;
9166
9167 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9168 salt_type = SALT_TYPE_EMBEDDED;
9169 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9170 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9171 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9172 dgst_size = DGST_SIZE_4_5;
9173 parse_func = truecrypt_parse_hash_1k;
9174 sort_by_digest = sort_by_digest_4_5;
9175 opti_type = OPTI_TYPE_ZERO_BYTE;
9176 dgst_pos0 = 0;
9177 dgst_pos1 = 1;
9178 dgst_pos2 = 2;
9179 dgst_pos3 = 3;
9180 break;
9181
9182 case 6300: hash_type = HASH_TYPE_MD5;
9183 salt_type = SALT_TYPE_EMBEDDED;
9184 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9185 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9186 kern_type = KERN_TYPE_MD5AIX;
9187 dgst_size = DGST_SIZE_4_4;
9188 parse_func = md5aix_parse_hash;
9189 sort_by_digest = sort_by_digest_4_4;
9190 opti_type = OPTI_TYPE_ZERO_BYTE;
9191 dgst_pos0 = 0;
9192 dgst_pos1 = 1;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 3;
9195 break;
9196
9197 case 6400: hash_type = HASH_TYPE_SHA256;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9201 kern_type = KERN_TYPE_SHA256AIX;
9202 dgst_size = DGST_SIZE_4_8;
9203 parse_func = sha256aix_parse_hash;
9204 sort_by_digest = sort_by_digest_4_8;
9205 opti_type = OPTI_TYPE_ZERO_BYTE;
9206 dgst_pos0 = 0;
9207 dgst_pos1 = 1;
9208 dgst_pos2 = 2;
9209 dgst_pos3 = 3;
9210 break;
9211
9212 case 6500: hash_type = HASH_TYPE_SHA512;
9213 salt_type = SALT_TYPE_EMBEDDED;
9214 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9215 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9216 kern_type = KERN_TYPE_SHA512AIX;
9217 dgst_size = DGST_SIZE_8_8;
9218 parse_func = sha512aix_parse_hash;
9219 sort_by_digest = sort_by_digest_8_8;
9220 opti_type = OPTI_TYPE_ZERO_BYTE
9221 | OPTI_TYPE_USES_BITS_64;
9222 dgst_pos0 = 0;
9223 dgst_pos1 = 1;
9224 dgst_pos2 = 2;
9225 dgst_pos3 = 3;
9226 break;
9227
9228 case 6600: hash_type = HASH_TYPE_AES;
9229 salt_type = SALT_TYPE_EMBEDDED;
9230 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9231 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9232 kern_type = KERN_TYPE_AGILEKEY;
9233 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9234 parse_func = agilekey_parse_hash;
9235 sort_by_digest = sort_by_digest_4_5;
9236 opti_type = OPTI_TYPE_ZERO_BYTE;
9237 dgst_pos0 = 0;
9238 dgst_pos1 = 1;
9239 dgst_pos2 = 2;
9240 dgst_pos3 = 3;
9241 break;
9242
9243 case 6700: hash_type = HASH_TYPE_SHA1;
9244 salt_type = SALT_TYPE_EMBEDDED;
9245 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9246 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9247 kern_type = KERN_TYPE_SHA1AIX;
9248 dgst_size = DGST_SIZE_4_5;
9249 parse_func = sha1aix_parse_hash;
9250 sort_by_digest = sort_by_digest_4_5;
9251 opti_type = OPTI_TYPE_ZERO_BYTE;
9252 dgst_pos0 = 0;
9253 dgst_pos1 = 1;
9254 dgst_pos2 = 2;
9255 dgst_pos3 = 3;
9256 break;
9257
9258 case 6800: hash_type = HASH_TYPE_AES;
9259 salt_type = SALT_TYPE_EMBEDDED;
9260 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9261 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9262 kern_type = KERN_TYPE_LASTPASS;
9263 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9264 parse_func = lastpass_parse_hash;
9265 sort_by_digest = sort_by_digest_4_8;
9266 opti_type = OPTI_TYPE_ZERO_BYTE;
9267 dgst_pos0 = 0;
9268 dgst_pos1 = 1;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 3;
9271 break;
9272
9273 case 6900: hash_type = HASH_TYPE_GOST;
9274 salt_type = SALT_TYPE_NONE;
9275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9276 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9277 kern_type = KERN_TYPE_GOST;
9278 dgst_size = DGST_SIZE_4_8;
9279 parse_func = gost_parse_hash;
9280 sort_by_digest = sort_by_digest_4_8;
9281 opti_type = OPTI_TYPE_ZERO_BYTE;
9282 dgst_pos0 = 0;
9283 dgst_pos1 = 1;
9284 dgst_pos2 = 2;
9285 dgst_pos3 = 3;
9286 break;
9287
9288 case 7100: hash_type = HASH_TYPE_SHA512;
9289 salt_type = SALT_TYPE_EMBEDDED;
9290 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9291 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9292 kern_type = KERN_TYPE_PBKDF2_SHA512;
9293 dgst_size = DGST_SIZE_8_16;
9294 parse_func = sha512osx_parse_hash;
9295 sort_by_digest = sort_by_digest_8_16;
9296 opti_type = OPTI_TYPE_ZERO_BYTE
9297 | OPTI_TYPE_USES_BITS_64
9298 | OPTI_TYPE_SLOW_HASH_SIMD;
9299 dgst_pos0 = 0;
9300 dgst_pos1 = 1;
9301 dgst_pos2 = 2;
9302 dgst_pos3 = 3;
9303 break;
9304
9305 case 7200: hash_type = HASH_TYPE_SHA512;
9306 salt_type = SALT_TYPE_EMBEDDED;
9307 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9308 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9309 kern_type = KERN_TYPE_PBKDF2_SHA512;
9310 dgst_size = DGST_SIZE_8_16;
9311 parse_func = sha512grub_parse_hash;
9312 sort_by_digest = sort_by_digest_8_16;
9313 opti_type = OPTI_TYPE_ZERO_BYTE
9314 | OPTI_TYPE_USES_BITS_64
9315 | OPTI_TYPE_SLOW_HASH_SIMD;
9316 dgst_pos0 = 0;
9317 dgst_pos1 = 1;
9318 dgst_pos2 = 2;
9319 dgst_pos3 = 3;
9320 break;
9321
9322 case 7300: 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_ADD80
9327 | OPTS_TYPE_ST_ADDBITS15;
9328 kern_type = KERN_TYPE_RAKP;
9329 dgst_size = DGST_SIZE_4_5;
9330 parse_func = rakp_parse_hash;
9331 sort_by_digest = sort_by_digest_4_5;
9332 opti_type = OPTI_TYPE_ZERO_BYTE
9333 | OPTI_TYPE_NOT_ITERATED;
9334 dgst_pos0 = 3;
9335 dgst_pos1 = 4;
9336 dgst_pos2 = 2;
9337 dgst_pos3 = 1;
9338 break;
9339
9340 case 7400: hash_type = HASH_TYPE_SHA256;
9341 salt_type = SALT_TYPE_EMBEDDED;
9342 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9343 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9344 kern_type = KERN_TYPE_SHA256CRYPT;
9345 dgst_size = DGST_SIZE_4_8;
9346 parse_func = sha256crypt_parse_hash;
9347 sort_by_digest = sort_by_digest_4_8;
9348 opti_type = OPTI_TYPE_ZERO_BYTE;
9349 dgst_pos0 = 0;
9350 dgst_pos1 = 1;
9351 dgst_pos2 = 2;
9352 dgst_pos3 = 3;
9353 break;
9354
9355 case 7500: hash_type = HASH_TYPE_KRB5PA;
9356 salt_type = SALT_TYPE_EMBEDDED;
9357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9358 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9359 kern_type = KERN_TYPE_KRB5PA;
9360 dgst_size = DGST_SIZE_4_4;
9361 parse_func = krb5pa_parse_hash;
9362 sort_by_digest = sort_by_digest_4_4;
9363 opti_type = OPTI_TYPE_ZERO_BYTE
9364 | OPTI_TYPE_NOT_ITERATED;
9365 dgst_pos0 = 0;
9366 dgst_pos1 = 1;
9367 dgst_pos2 = 2;
9368 dgst_pos3 = 3;
9369 break;
9370
9371 case 7600: hash_type = HASH_TYPE_SHA1;
9372 salt_type = SALT_TYPE_INTERN;
9373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9374 opts_type = OPTS_TYPE_PT_GENERATE_BE
9375 | OPTS_TYPE_PT_ADD80
9376 | OPTS_TYPE_PT_ADDBITS15;
9377 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9378 dgst_size = DGST_SIZE_4_5;
9379 parse_func = redmine_parse_hash;
9380 sort_by_digest = sort_by_digest_4_5;
9381 opti_type = OPTI_TYPE_ZERO_BYTE
9382 | OPTI_TYPE_PRECOMPUTE_INIT
9383 | OPTI_TYPE_EARLY_SKIP
9384 | OPTI_TYPE_NOT_ITERATED
9385 | OPTI_TYPE_PREPENDED_SALT;
9386 dgst_pos0 = 3;
9387 dgst_pos1 = 4;
9388 dgst_pos2 = 2;
9389 dgst_pos3 = 1;
9390 break;
9391
9392 case 7700: hash_type = HASH_TYPE_SAPB;
9393 salt_type = SALT_TYPE_EMBEDDED;
9394 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9395 opts_type = OPTS_TYPE_PT_GENERATE_LE
9396 | OPTS_TYPE_PT_UPPER
9397 | OPTS_TYPE_ST_UPPER;
9398 kern_type = KERN_TYPE_SAPB;
9399 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9400 parse_func = sapb_parse_hash;
9401 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9402 opti_type = OPTI_TYPE_ZERO_BYTE
9403 | OPTI_TYPE_PRECOMPUTE_INIT
9404 | OPTI_TYPE_NOT_ITERATED;
9405 dgst_pos0 = 0;
9406 dgst_pos1 = 1;
9407 dgst_pos2 = 2;
9408 dgst_pos3 = 3;
9409 break;
9410
9411 case 7800: hash_type = HASH_TYPE_SAPG;
9412 salt_type = SALT_TYPE_EMBEDDED;
9413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9414 opts_type = OPTS_TYPE_PT_GENERATE_BE
9415 | OPTS_TYPE_ST_ADD80
9416 | OPTS_TYPE_ST_UPPER;
9417 kern_type = KERN_TYPE_SAPG;
9418 dgst_size = DGST_SIZE_4_5;
9419 parse_func = sapg_parse_hash;
9420 sort_by_digest = sort_by_digest_4_5;
9421 opti_type = OPTI_TYPE_ZERO_BYTE
9422 | OPTI_TYPE_PRECOMPUTE_INIT
9423 | OPTI_TYPE_NOT_ITERATED;
9424 dgst_pos0 = 3;
9425 dgst_pos1 = 4;
9426 dgst_pos2 = 2;
9427 dgst_pos3 = 1;
9428 break;
9429
9430 case 7900: hash_type = HASH_TYPE_SHA512;
9431 salt_type = SALT_TYPE_EMBEDDED;
9432 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9433 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9434 kern_type = KERN_TYPE_DRUPAL7;
9435 dgst_size = DGST_SIZE_8_8;
9436 parse_func = drupal7_parse_hash;
9437 sort_by_digest = sort_by_digest_8_8;
9438 opti_type = OPTI_TYPE_ZERO_BYTE
9439 | OPTI_TYPE_USES_BITS_64;
9440 dgst_pos0 = 0;
9441 dgst_pos1 = 1;
9442 dgst_pos2 = 2;
9443 dgst_pos3 = 3;
9444 break;
9445
9446 case 8000: hash_type = HASH_TYPE_SHA256;
9447 salt_type = SALT_TYPE_EMBEDDED;
9448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9449 opts_type = OPTS_TYPE_PT_GENERATE_BE
9450 | OPTS_TYPE_PT_UNICODE
9451 | OPTS_TYPE_ST_ADD80
9452 | OPTS_TYPE_ST_HEX;
9453 kern_type = KERN_TYPE_SYBASEASE;
9454 dgst_size = DGST_SIZE_4_8;
9455 parse_func = sybasease_parse_hash;
9456 sort_by_digest = sort_by_digest_4_8;
9457 opti_type = OPTI_TYPE_ZERO_BYTE
9458 | OPTI_TYPE_PRECOMPUTE_INIT
9459 | OPTI_TYPE_EARLY_SKIP
9460 | OPTI_TYPE_NOT_ITERATED
9461 | OPTI_TYPE_RAW_HASH;
9462 dgst_pos0 = 3;
9463 dgst_pos1 = 7;
9464 dgst_pos2 = 2;
9465 dgst_pos3 = 6;
9466 break;
9467
9468 case 8100: hash_type = HASH_TYPE_SHA1;
9469 salt_type = SALT_TYPE_EMBEDDED;
9470 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9471 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9472 kern_type = KERN_TYPE_NETSCALER;
9473 dgst_size = DGST_SIZE_4_5;
9474 parse_func = netscaler_parse_hash;
9475 sort_by_digest = sort_by_digest_4_5;
9476 opti_type = OPTI_TYPE_ZERO_BYTE
9477 | OPTI_TYPE_PRECOMPUTE_INIT
9478 | OPTI_TYPE_PRECOMPUTE_MERKLE
9479 | OPTI_TYPE_EARLY_SKIP
9480 | OPTI_TYPE_NOT_ITERATED
9481 | OPTI_TYPE_PREPENDED_SALT
9482 | OPTI_TYPE_RAW_HASH;
9483 dgst_pos0 = 3;
9484 dgst_pos1 = 4;
9485 dgst_pos2 = 2;
9486 dgst_pos3 = 1;
9487 break;
9488
9489 case 8200: hash_type = HASH_TYPE_SHA256;
9490 salt_type = SALT_TYPE_EMBEDDED;
9491 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9492 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9493 kern_type = KERN_TYPE_CLOUDKEY;
9494 dgst_size = DGST_SIZE_4_8;
9495 parse_func = cloudkey_parse_hash;
9496 sort_by_digest = sort_by_digest_4_8;
9497 opti_type = OPTI_TYPE_ZERO_BYTE;
9498 dgst_pos0 = 0;
9499 dgst_pos1 = 1;
9500 dgst_pos2 = 2;
9501 dgst_pos3 = 3;
9502 break;
9503
9504 case 8300: hash_type = HASH_TYPE_SHA1;
9505 salt_type = SALT_TYPE_EMBEDDED;
9506 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9507 opts_type = OPTS_TYPE_PT_GENERATE_BE
9508 | OPTS_TYPE_ST_HEX
9509 | OPTS_TYPE_ST_ADD80;
9510 kern_type = KERN_TYPE_NSEC3;
9511 dgst_size = DGST_SIZE_4_5;
9512 parse_func = nsec3_parse_hash;
9513 sort_by_digest = sort_by_digest_4_5;
9514 opti_type = OPTI_TYPE_ZERO_BYTE;
9515 dgst_pos0 = 3;
9516 dgst_pos1 = 4;
9517 dgst_pos2 = 2;
9518 dgst_pos3 = 1;
9519 break;
9520
9521 case 8400: hash_type = HASH_TYPE_SHA1;
9522 salt_type = SALT_TYPE_INTERN;
9523 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9524 opts_type = OPTS_TYPE_PT_GENERATE_BE
9525 | OPTS_TYPE_PT_ADD80
9526 | OPTS_TYPE_PT_ADDBITS15;
9527 kern_type = KERN_TYPE_WBB3;
9528 dgst_size = DGST_SIZE_4_5;
9529 parse_func = wbb3_parse_hash;
9530 sort_by_digest = sort_by_digest_4_5;
9531 opti_type = OPTI_TYPE_ZERO_BYTE
9532 | OPTI_TYPE_PRECOMPUTE_INIT
9533 | OPTI_TYPE_NOT_ITERATED;
9534 dgst_pos0 = 3;
9535 dgst_pos1 = 4;
9536 dgst_pos2 = 2;
9537 dgst_pos3 = 1;
9538 break;
9539
9540 case 8500: hash_type = HASH_TYPE_DESRACF;
9541 salt_type = SALT_TYPE_EMBEDDED;
9542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9543 opts_type = OPTS_TYPE_PT_GENERATE_LE
9544 | OPTS_TYPE_ST_UPPER;
9545 kern_type = KERN_TYPE_RACF;
9546 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9547 parse_func = racf_parse_hash;
9548 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9549 opti_type = OPTI_TYPE_ZERO_BYTE
9550 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9551 dgst_pos0 = 0;
9552 dgst_pos1 = 1;
9553 dgst_pos2 = 2;
9554 dgst_pos3 = 3;
9555 break;
9556
9557 case 8600: hash_type = HASH_TYPE_LOTUS5;
9558 salt_type = SALT_TYPE_NONE;
9559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9560 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9561 kern_type = KERN_TYPE_LOTUS5;
9562 dgst_size = DGST_SIZE_4_4;
9563 parse_func = lotus5_parse_hash;
9564 sort_by_digest = sort_by_digest_4_4;
9565 opti_type = OPTI_TYPE_EARLY_SKIP
9566 | OPTI_TYPE_NOT_ITERATED
9567 | OPTI_TYPE_NOT_SALTED
9568 | OPTI_TYPE_RAW_HASH;
9569 dgst_pos0 = 0;
9570 dgst_pos1 = 1;
9571 dgst_pos2 = 2;
9572 dgst_pos3 = 3;
9573 break;
9574
9575 case 8700: hash_type = HASH_TYPE_LOTUS6;
9576 salt_type = SALT_TYPE_EMBEDDED;
9577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9578 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9579 kern_type = KERN_TYPE_LOTUS6;
9580 dgst_size = DGST_SIZE_4_4;
9581 parse_func = lotus6_parse_hash;
9582 sort_by_digest = sort_by_digest_4_4;
9583 opti_type = OPTI_TYPE_EARLY_SKIP
9584 | OPTI_TYPE_NOT_ITERATED
9585 | OPTI_TYPE_RAW_HASH;
9586 dgst_pos0 = 0;
9587 dgst_pos1 = 1;
9588 dgst_pos2 = 2;
9589 dgst_pos3 = 3;
9590 break;
9591
9592 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9593 salt_type = SALT_TYPE_EMBEDDED;
9594 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9595 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9596 kern_type = KERN_TYPE_ANDROIDFDE;
9597 dgst_size = DGST_SIZE_4_4;
9598 parse_func = androidfde_parse_hash;
9599 sort_by_digest = sort_by_digest_4_4;
9600 opti_type = OPTI_TYPE_ZERO_BYTE;
9601 dgst_pos0 = 0;
9602 dgst_pos1 = 1;
9603 dgst_pos2 = 2;
9604 dgst_pos3 = 3;
9605 break;
9606
9607 case 8900: hash_type = HASH_TYPE_SCRYPT;
9608 salt_type = SALT_TYPE_EMBEDDED;
9609 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9610 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9611 kern_type = KERN_TYPE_SCRYPT;
9612 dgst_size = DGST_SIZE_4_8;
9613 parse_func = scrypt_parse_hash;
9614 sort_by_digest = sort_by_digest_4_8;
9615 opti_type = OPTI_TYPE_ZERO_BYTE;
9616 dgst_pos0 = 0;
9617 dgst_pos1 = 1;
9618 dgst_pos2 = 2;
9619 dgst_pos3 = 3;
9620 break;
9621
9622 case 9000: hash_type = HASH_TYPE_SHA1;
9623 salt_type = SALT_TYPE_EMBEDDED;
9624 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9625 opts_type = OPTS_TYPE_PT_GENERATE_LE
9626 | OPTS_TYPE_ST_GENERATE_LE;
9627 kern_type = KERN_TYPE_PSAFE2;
9628 dgst_size = DGST_SIZE_4_5;
9629 parse_func = psafe2_parse_hash;
9630 sort_by_digest = sort_by_digest_4_5;
9631 opti_type = OPTI_TYPE_ZERO_BYTE;
9632 dgst_pos0 = 0;
9633 dgst_pos1 = 1;
9634 dgst_pos2 = 2;
9635 dgst_pos3 = 3;
9636 break;
9637
9638 case 9100: hash_type = HASH_TYPE_LOTUS8;
9639 salt_type = SALT_TYPE_EMBEDDED;
9640 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9641 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9642 kern_type = KERN_TYPE_LOTUS8;
9643 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9644 parse_func = lotus8_parse_hash;
9645 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9646 opti_type = OPTI_TYPE_ZERO_BYTE;
9647 dgst_pos0 = 0;
9648 dgst_pos1 = 1;
9649 dgst_pos2 = 2;
9650 dgst_pos3 = 3;
9651 break;
9652
9653 case 9200: hash_type = HASH_TYPE_SHA256;
9654 salt_type = SALT_TYPE_EMBEDDED;
9655 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9656 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9657 kern_type = KERN_TYPE_PBKDF2_SHA256;
9658 dgst_size = DGST_SIZE_4_32;
9659 parse_func = cisco8_parse_hash;
9660 sort_by_digest = sort_by_digest_4_32;
9661 opti_type = OPTI_TYPE_ZERO_BYTE
9662 | OPTI_TYPE_SLOW_HASH_SIMD;
9663 dgst_pos0 = 0;
9664 dgst_pos1 = 1;
9665 dgst_pos2 = 2;
9666 dgst_pos3 = 3;
9667 break;
9668
9669 case 9300: hash_type = HASH_TYPE_SCRYPT;
9670 salt_type = SALT_TYPE_EMBEDDED;
9671 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9672 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9673 kern_type = KERN_TYPE_SCRYPT;
9674 dgst_size = DGST_SIZE_4_8;
9675 parse_func = cisco9_parse_hash;
9676 sort_by_digest = sort_by_digest_4_8;
9677 opti_type = OPTI_TYPE_ZERO_BYTE;
9678 dgst_pos0 = 0;
9679 dgst_pos1 = 1;
9680 dgst_pos2 = 2;
9681 dgst_pos3 = 3;
9682 break;
9683
9684 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9685 salt_type = SALT_TYPE_EMBEDDED;
9686 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9687 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9688 kern_type = KERN_TYPE_OFFICE2007;
9689 dgst_size = DGST_SIZE_4_4;
9690 parse_func = office2007_parse_hash;
9691 sort_by_digest = sort_by_digest_4_4;
9692 opti_type = OPTI_TYPE_ZERO_BYTE;
9693 dgst_pos0 = 0;
9694 dgst_pos1 = 1;
9695 dgst_pos2 = 2;
9696 dgst_pos3 = 3;
9697 break;
9698
9699 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9700 salt_type = SALT_TYPE_EMBEDDED;
9701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9702 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9703 kern_type = KERN_TYPE_OFFICE2010;
9704 dgst_size = DGST_SIZE_4_4;
9705 parse_func = office2010_parse_hash;
9706 sort_by_digest = sort_by_digest_4_4;
9707 opti_type = OPTI_TYPE_ZERO_BYTE;
9708 dgst_pos0 = 0;
9709 dgst_pos1 = 1;
9710 dgst_pos2 = 2;
9711 dgst_pos3 = 3;
9712 break;
9713
9714 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9715 salt_type = SALT_TYPE_EMBEDDED;
9716 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9717 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9718 kern_type = KERN_TYPE_OFFICE2013;
9719 dgst_size = DGST_SIZE_4_4;
9720 parse_func = office2013_parse_hash;
9721 sort_by_digest = sort_by_digest_4_4;
9722 opti_type = OPTI_TYPE_ZERO_BYTE;
9723 dgst_pos0 = 0;
9724 dgst_pos1 = 1;
9725 dgst_pos2 = 2;
9726 dgst_pos3 = 3;
9727 break;
9728
9729 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9730 salt_type = SALT_TYPE_EMBEDDED;
9731 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9732 opts_type = OPTS_TYPE_PT_GENERATE_LE
9733 | OPTS_TYPE_PT_ADD80
9734 | OPTS_TYPE_PT_UNICODE;
9735 kern_type = KERN_TYPE_OLDOFFICE01;
9736 dgst_size = DGST_SIZE_4_4;
9737 parse_func = oldoffice01_parse_hash;
9738 sort_by_digest = sort_by_digest_4_4;
9739 opti_type = OPTI_TYPE_ZERO_BYTE
9740 | OPTI_TYPE_PRECOMPUTE_INIT
9741 | OPTI_TYPE_NOT_ITERATED;
9742 dgst_pos0 = 0;
9743 dgst_pos1 = 1;
9744 dgst_pos2 = 2;
9745 dgst_pos3 = 3;
9746 break;
9747
9748 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9749 salt_type = SALT_TYPE_EMBEDDED;
9750 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9751 opts_type = OPTS_TYPE_PT_GENERATE_LE
9752 | OPTS_TYPE_PT_ADD80;
9753 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9754 dgst_size = DGST_SIZE_4_4;
9755 parse_func = oldoffice01cm1_parse_hash;
9756 sort_by_digest = sort_by_digest_4_4;
9757 opti_type = OPTI_TYPE_ZERO_BYTE
9758 | OPTI_TYPE_PRECOMPUTE_INIT
9759 | OPTI_TYPE_NOT_ITERATED;
9760 dgst_pos0 = 0;
9761 dgst_pos1 = 1;
9762 dgst_pos2 = 2;
9763 dgst_pos3 = 3;
9764 break;
9765
9766 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9767 salt_type = SALT_TYPE_EMBEDDED;
9768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9769 opts_type = OPTS_TYPE_PT_GENERATE_LE
9770 | OPTS_TYPE_PT_ADD80
9771 | OPTS_TYPE_PT_UNICODE
9772 | OPTS_TYPE_PT_NEVERCRACK;
9773 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9774 dgst_size = DGST_SIZE_4_4;
9775 parse_func = oldoffice01cm2_parse_hash;
9776 sort_by_digest = sort_by_digest_4_4;
9777 opti_type = OPTI_TYPE_ZERO_BYTE
9778 | OPTI_TYPE_PRECOMPUTE_INIT
9779 | OPTI_TYPE_NOT_ITERATED;
9780 dgst_pos0 = 0;
9781 dgst_pos1 = 1;
9782 dgst_pos2 = 2;
9783 dgst_pos3 = 3;
9784 break;
9785
9786 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9787 salt_type = SALT_TYPE_EMBEDDED;
9788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9789 opts_type = OPTS_TYPE_PT_GENERATE_BE
9790 | OPTS_TYPE_PT_ADD80
9791 | OPTS_TYPE_PT_UNICODE;
9792 kern_type = KERN_TYPE_OLDOFFICE34;
9793 dgst_size = DGST_SIZE_4_4;
9794 parse_func = oldoffice34_parse_hash;
9795 sort_by_digest = sort_by_digest_4_4;
9796 opti_type = OPTI_TYPE_ZERO_BYTE
9797 | OPTI_TYPE_PRECOMPUTE_INIT
9798 | OPTI_TYPE_NOT_ITERATED;
9799 dgst_pos0 = 0;
9800 dgst_pos1 = 1;
9801 dgst_pos2 = 2;
9802 dgst_pos3 = 3;
9803 break;
9804
9805 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9806 salt_type = SALT_TYPE_EMBEDDED;
9807 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9808 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9809 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9810 dgst_size = DGST_SIZE_4_4;
9811 parse_func = oldoffice34cm1_parse_hash;
9812 sort_by_digest = sort_by_digest_4_4;
9813 opti_type = OPTI_TYPE_ZERO_BYTE
9814 | OPTI_TYPE_PRECOMPUTE_INIT
9815 | OPTI_TYPE_NOT_ITERATED;
9816 dgst_pos0 = 0;
9817 dgst_pos1 = 1;
9818 dgst_pos2 = 2;
9819 dgst_pos3 = 3;
9820 break;
9821
9822 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9823 salt_type = SALT_TYPE_EMBEDDED;
9824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9825 opts_type = OPTS_TYPE_PT_GENERATE_BE
9826 | OPTS_TYPE_PT_ADD80
9827 | OPTS_TYPE_PT_UNICODE
9828 | OPTS_TYPE_PT_NEVERCRACK;
9829 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9830 dgst_size = DGST_SIZE_4_4;
9831 parse_func = oldoffice34cm2_parse_hash;
9832 sort_by_digest = sort_by_digest_4_4;
9833 opti_type = OPTI_TYPE_ZERO_BYTE
9834 | OPTI_TYPE_PRECOMPUTE_INIT
9835 | OPTI_TYPE_NOT_ITERATED;
9836 dgst_pos0 = 0;
9837 dgst_pos1 = 1;
9838 dgst_pos2 = 2;
9839 dgst_pos3 = 3;
9840 break;
9841
9842 case 9900: hash_type = HASH_TYPE_MD5;
9843 salt_type = SALT_TYPE_NONE;
9844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9845 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9846 kern_type = KERN_TYPE_RADMIN2;
9847 dgst_size = DGST_SIZE_4_4;
9848 parse_func = radmin2_parse_hash;
9849 sort_by_digest = sort_by_digest_4_4;
9850 opti_type = OPTI_TYPE_ZERO_BYTE
9851 | OPTI_TYPE_PRECOMPUTE_INIT
9852 | OPTI_TYPE_EARLY_SKIP
9853 | OPTI_TYPE_NOT_ITERATED
9854 | OPTI_TYPE_NOT_SALTED;
9855 dgst_pos0 = 0;
9856 dgst_pos1 = 3;
9857 dgst_pos2 = 2;
9858 dgst_pos3 = 1;
9859 break;
9860
9861 case 10000: hash_type = HASH_TYPE_SHA256;
9862 salt_type = SALT_TYPE_EMBEDDED;
9863 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9864 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9865 kern_type = KERN_TYPE_PBKDF2_SHA256;
9866 dgst_size = DGST_SIZE_4_32;
9867 parse_func = djangopbkdf2_parse_hash;
9868 sort_by_digest = sort_by_digest_4_32;
9869 opti_type = OPTI_TYPE_ZERO_BYTE
9870 | OPTI_TYPE_SLOW_HASH_SIMD;
9871 dgst_pos0 = 0;
9872 dgst_pos1 = 1;
9873 dgst_pos2 = 2;
9874 dgst_pos3 = 3;
9875 break;
9876
9877 case 10100: hash_type = HASH_TYPE_SIPHASH;
9878 salt_type = SALT_TYPE_EMBEDDED;
9879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9880 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9881 kern_type = KERN_TYPE_SIPHASH;
9882 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9883 parse_func = siphash_parse_hash;
9884 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9885 opti_type = OPTI_TYPE_ZERO_BYTE
9886 | OPTI_TYPE_NOT_ITERATED
9887 | OPTI_TYPE_RAW_HASH;
9888 dgst_pos0 = 0;
9889 dgst_pos1 = 1;
9890 dgst_pos2 = 2;
9891 dgst_pos3 = 3;
9892 break;
9893
9894 case 10200: hash_type = HASH_TYPE_MD5;
9895 salt_type = SALT_TYPE_EMBEDDED;
9896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9897 opts_type = OPTS_TYPE_PT_GENERATE_LE
9898 | OPTS_TYPE_ST_ADD80
9899 | OPTS_TYPE_ST_ADDBITS14;
9900 kern_type = KERN_TYPE_HMACMD5_PW;
9901 dgst_size = DGST_SIZE_4_4;
9902 parse_func = crammd5_parse_hash;
9903 sort_by_digest = sort_by_digest_4_4;
9904 opti_type = OPTI_TYPE_ZERO_BYTE
9905 | OPTI_TYPE_NOT_ITERATED;
9906 dgst_pos0 = 0;
9907 dgst_pos1 = 3;
9908 dgst_pos2 = 2;
9909 dgst_pos3 = 1;
9910 break;
9911
9912 case 10300: hash_type = HASH_TYPE_SHA1;
9913 salt_type = SALT_TYPE_EMBEDDED;
9914 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9915 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9916 kern_type = KERN_TYPE_SAPH_SHA1;
9917 dgst_size = DGST_SIZE_4_5;
9918 parse_func = saph_sha1_parse_hash;
9919 sort_by_digest = sort_by_digest_4_5;
9920 opti_type = OPTI_TYPE_ZERO_BYTE;
9921 dgst_pos0 = 0;
9922 dgst_pos1 = 1;
9923 dgst_pos2 = 2;
9924 dgst_pos3 = 3;
9925 break;
9926
9927 case 10400: hash_type = HASH_TYPE_PDFU16;
9928 salt_type = SALT_TYPE_EMBEDDED;
9929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9930 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9931 kern_type = KERN_TYPE_PDF11;
9932 dgst_size = DGST_SIZE_4_4;
9933 parse_func = pdf11_parse_hash;
9934 sort_by_digest = sort_by_digest_4_4;
9935 opti_type = OPTI_TYPE_ZERO_BYTE
9936 | OPTI_TYPE_NOT_ITERATED;
9937 dgst_pos0 = 0;
9938 dgst_pos1 = 1;
9939 dgst_pos2 = 2;
9940 dgst_pos3 = 3;
9941 break;
9942
9943 case 10410: hash_type = HASH_TYPE_PDFU16;
9944 salt_type = SALT_TYPE_EMBEDDED;
9945 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9946 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9947 kern_type = KERN_TYPE_PDF11CM1;
9948 dgst_size = DGST_SIZE_4_4;
9949 parse_func = pdf11cm1_parse_hash;
9950 sort_by_digest = sort_by_digest_4_4;
9951 opti_type = OPTI_TYPE_ZERO_BYTE
9952 | OPTI_TYPE_NOT_ITERATED;
9953 dgst_pos0 = 0;
9954 dgst_pos1 = 1;
9955 dgst_pos2 = 2;
9956 dgst_pos3 = 3;
9957 break;
9958
9959 case 10420: hash_type = HASH_TYPE_PDFU16;
9960 salt_type = SALT_TYPE_EMBEDDED;
9961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9962 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9963 kern_type = KERN_TYPE_PDF11CM2;
9964 dgst_size = DGST_SIZE_4_4;
9965 parse_func = pdf11cm2_parse_hash;
9966 sort_by_digest = sort_by_digest_4_4;
9967 opti_type = OPTI_TYPE_ZERO_BYTE
9968 | OPTI_TYPE_NOT_ITERATED;
9969 dgst_pos0 = 0;
9970 dgst_pos1 = 1;
9971 dgst_pos2 = 2;
9972 dgst_pos3 = 3;
9973 break;
9974
9975 case 10500: hash_type = HASH_TYPE_PDFU16;
9976 salt_type = SALT_TYPE_EMBEDDED;
9977 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9978 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9979 kern_type = KERN_TYPE_PDF14;
9980 dgst_size = DGST_SIZE_4_4;
9981 parse_func = pdf14_parse_hash;
9982 sort_by_digest = sort_by_digest_4_4;
9983 opti_type = OPTI_TYPE_ZERO_BYTE
9984 | OPTI_TYPE_NOT_ITERATED;
9985 dgst_pos0 = 0;
9986 dgst_pos1 = 1;
9987 dgst_pos2 = 2;
9988 dgst_pos3 = 3;
9989 break;
9990
9991 case 10600: hash_type = HASH_TYPE_SHA256;
9992 salt_type = SALT_TYPE_EMBEDDED;
9993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9994 opts_type = OPTS_TYPE_PT_GENERATE_BE
9995 | OPTS_TYPE_ST_ADD80
9996 | OPTS_TYPE_ST_ADDBITS15
9997 | OPTS_TYPE_HASH_COPY;
9998 kern_type = KERN_TYPE_SHA256_PWSLT;
9999 dgst_size = DGST_SIZE_4_8;
10000 parse_func = pdf17l3_parse_hash;
10001 sort_by_digest = sort_by_digest_4_8;
10002 opti_type = OPTI_TYPE_ZERO_BYTE
10003 | OPTI_TYPE_PRECOMPUTE_INIT
10004 | OPTI_TYPE_PRECOMPUTE_MERKLE
10005 | OPTI_TYPE_EARLY_SKIP
10006 | OPTI_TYPE_NOT_ITERATED
10007 | OPTI_TYPE_APPENDED_SALT
10008 | OPTI_TYPE_RAW_HASH;
10009 dgst_pos0 = 3;
10010 dgst_pos1 = 7;
10011 dgst_pos2 = 2;
10012 dgst_pos3 = 6;
10013 break;
10014
10015 case 10700: hash_type = HASH_TYPE_PDFU32;
10016 salt_type = SALT_TYPE_EMBEDDED;
10017 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10018 opts_type = OPTS_TYPE_PT_GENERATE_LE
10019 | OPTS_TYPE_HASH_COPY;
10020 kern_type = KERN_TYPE_PDF17L8;
10021 dgst_size = DGST_SIZE_4_8;
10022 parse_func = pdf17l8_parse_hash;
10023 sort_by_digest = sort_by_digest_4_8;
10024 opti_type = OPTI_TYPE_ZERO_BYTE
10025 | OPTI_TYPE_NOT_ITERATED;
10026 dgst_pos0 = 0;
10027 dgst_pos1 = 1;
10028 dgst_pos2 = 2;
10029 dgst_pos3 = 3;
10030 break;
10031
10032 case 10800: hash_type = HASH_TYPE_SHA384;
10033 salt_type = SALT_TYPE_NONE;
10034 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10035 opts_type = OPTS_TYPE_PT_GENERATE_BE
10036 | OPTS_TYPE_PT_ADD80
10037 | OPTS_TYPE_PT_ADDBITS15;
10038 kern_type = KERN_TYPE_SHA384;
10039 dgst_size = DGST_SIZE_8_8;
10040 parse_func = sha384_parse_hash;
10041 sort_by_digest = sort_by_digest_8_8;
10042 opti_type = OPTI_TYPE_ZERO_BYTE
10043 | OPTI_TYPE_PRECOMPUTE_INIT
10044 | OPTI_TYPE_PRECOMPUTE_MERKLE
10045 | OPTI_TYPE_EARLY_SKIP
10046 | OPTI_TYPE_NOT_ITERATED
10047 | OPTI_TYPE_NOT_SALTED
10048 | OPTI_TYPE_USES_BITS_64
10049 | OPTI_TYPE_RAW_HASH;
10050 dgst_pos0 = 6;
10051 dgst_pos1 = 7;
10052 dgst_pos2 = 4;
10053 dgst_pos3 = 5;
10054 break;
10055
10056 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10057 salt_type = SALT_TYPE_EMBEDDED;
10058 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10059 opts_type = OPTS_TYPE_PT_GENERATE_LE
10060 | OPTS_TYPE_ST_BASE64
10061 | OPTS_TYPE_HASH_COPY;
10062 kern_type = KERN_TYPE_PBKDF2_SHA256;
10063 dgst_size = DGST_SIZE_4_32;
10064 parse_func = pbkdf2_sha256_parse_hash;
10065 sort_by_digest = sort_by_digest_4_32;
10066 opti_type = OPTI_TYPE_ZERO_BYTE
10067 | OPTI_TYPE_SLOW_HASH_SIMD;
10068 dgst_pos0 = 0;
10069 dgst_pos1 = 1;
10070 dgst_pos2 = 2;
10071 dgst_pos3 = 3;
10072 break;
10073
10074 case 11000: hash_type = HASH_TYPE_MD5;
10075 salt_type = SALT_TYPE_INTERN;
10076 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10077 opts_type = OPTS_TYPE_PT_GENERATE_LE
10078 | OPTS_TYPE_PT_ADD80;
10079 kern_type = KERN_TYPE_PRESTASHOP;
10080 dgst_size = DGST_SIZE_4_4;
10081 parse_func = prestashop_parse_hash;
10082 sort_by_digest = sort_by_digest_4_4;
10083 opti_type = OPTI_TYPE_ZERO_BYTE
10084 | OPTI_TYPE_PRECOMPUTE_INIT
10085 | OPTI_TYPE_NOT_ITERATED
10086 | OPTI_TYPE_PREPENDED_SALT;
10087 dgst_pos0 = 0;
10088 dgst_pos1 = 3;
10089 dgst_pos2 = 2;
10090 dgst_pos3 = 1;
10091 break;
10092
10093 case 11100: hash_type = HASH_TYPE_MD5;
10094 salt_type = SALT_TYPE_EMBEDDED;
10095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10096 opts_type = OPTS_TYPE_PT_GENERATE_LE
10097 | OPTS_TYPE_ST_ADD80;
10098 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10099 dgst_size = DGST_SIZE_4_4;
10100 parse_func = postgresql_auth_parse_hash;
10101 sort_by_digest = sort_by_digest_4_4;
10102 opti_type = OPTI_TYPE_ZERO_BYTE
10103 | OPTI_TYPE_PRECOMPUTE_INIT
10104 | OPTI_TYPE_PRECOMPUTE_MERKLE
10105 | OPTI_TYPE_EARLY_SKIP;
10106 dgst_pos0 = 0;
10107 dgst_pos1 = 3;
10108 dgst_pos2 = 2;
10109 dgst_pos3 = 1;
10110 break;
10111
10112 case 11200: hash_type = HASH_TYPE_SHA1;
10113 salt_type = SALT_TYPE_EMBEDDED;
10114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10115 opts_type = OPTS_TYPE_PT_GENERATE_BE
10116 | OPTS_TYPE_PT_ADD80
10117 | OPTS_TYPE_ST_HEX;
10118 kern_type = KERN_TYPE_MYSQL_AUTH;
10119 dgst_size = DGST_SIZE_4_5;
10120 parse_func = mysql_auth_parse_hash;
10121 sort_by_digest = sort_by_digest_4_5;
10122 opti_type = OPTI_TYPE_ZERO_BYTE
10123 | OPTI_TYPE_EARLY_SKIP;
10124 dgst_pos0 = 3;
10125 dgst_pos1 = 4;
10126 dgst_pos2 = 2;
10127 dgst_pos3 = 1;
10128 break;
10129
10130 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10131 salt_type = SALT_TYPE_EMBEDDED;
10132 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10133 opts_type = OPTS_TYPE_PT_GENERATE_LE
10134 | OPTS_TYPE_ST_HEX
10135 | OPTS_TYPE_ST_ADD80;
10136 kern_type = KERN_TYPE_BITCOIN_WALLET;
10137 dgst_size = DGST_SIZE_4_4;
10138 parse_func = bitcoin_wallet_parse_hash;
10139 sort_by_digest = sort_by_digest_4_4;
10140 opti_type = OPTI_TYPE_ZERO_BYTE;
10141 dgst_pos0 = 0;
10142 dgst_pos1 = 1;
10143 dgst_pos2 = 2;
10144 dgst_pos3 = 3;
10145 break;
10146
10147 case 11400: hash_type = HASH_TYPE_MD5;
10148 salt_type = SALT_TYPE_EMBEDDED;
10149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10150 opts_type = OPTS_TYPE_PT_GENERATE_LE
10151 | OPTS_TYPE_PT_ADD80
10152 | OPTS_TYPE_HASH_COPY;
10153 kern_type = KERN_TYPE_SIP_AUTH;
10154 dgst_size = DGST_SIZE_4_4;
10155 parse_func = sip_auth_parse_hash;
10156 sort_by_digest = sort_by_digest_4_4;
10157 opti_type = OPTI_TYPE_ZERO_BYTE;
10158 dgst_pos0 = 0;
10159 dgst_pos1 = 3;
10160 dgst_pos2 = 2;
10161 dgst_pos3 = 1;
10162 break;
10163
10164 case 11500: hash_type = HASH_TYPE_CRC32;
10165 salt_type = SALT_TYPE_INTERN;
10166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10167 opts_type = OPTS_TYPE_PT_GENERATE_LE
10168 | OPTS_TYPE_ST_GENERATE_LE
10169 | OPTS_TYPE_ST_HEX;
10170 kern_type = KERN_TYPE_CRC32;
10171 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10172 parse_func = crc32_parse_hash;
10173 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10174 opti_type = OPTI_TYPE_ZERO_BYTE;
10175 dgst_pos0 = 0;
10176 dgst_pos1 = 1;
10177 dgst_pos2 = 2;
10178 dgst_pos3 = 3;
10179 break;
10180
10181 case 11600: hash_type = HASH_TYPE_AES;
10182 salt_type = SALT_TYPE_EMBEDDED;
10183 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10184 opts_type = OPTS_TYPE_PT_GENERATE_LE
10185 | OPTS_TYPE_PT_NEVERCRACK;
10186 kern_type = KERN_TYPE_SEVEN_ZIP;
10187 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10188 parse_func = seven_zip_parse_hash;
10189 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10190 opti_type = OPTI_TYPE_ZERO_BYTE;
10191 dgst_pos0 = 0;
10192 dgst_pos1 = 1;
10193 dgst_pos2 = 2;
10194 dgst_pos3 = 3;
10195 break;
10196
10197 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10198 salt_type = SALT_TYPE_NONE;
10199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10200 opts_type = OPTS_TYPE_PT_GENERATE_LE
10201 | OPTS_TYPE_PT_ADD01;
10202 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10203 dgst_size = DGST_SIZE_4_8;
10204 parse_func = gost2012sbog_256_parse_hash;
10205 sort_by_digest = sort_by_digest_4_8;
10206 opti_type = OPTI_TYPE_ZERO_BYTE;
10207 dgst_pos0 = 0;
10208 dgst_pos1 = 1;
10209 dgst_pos2 = 2;
10210 dgst_pos3 = 3;
10211 break;
10212
10213 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10214 salt_type = SALT_TYPE_NONE;
10215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10216 opts_type = OPTS_TYPE_PT_GENERATE_LE
10217 | OPTS_TYPE_PT_ADD01;
10218 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10219 dgst_size = DGST_SIZE_4_16;
10220 parse_func = gost2012sbog_512_parse_hash;
10221 sort_by_digest = sort_by_digest_4_16;
10222 opti_type = OPTI_TYPE_ZERO_BYTE;
10223 dgst_pos0 = 0;
10224 dgst_pos1 = 1;
10225 dgst_pos2 = 2;
10226 dgst_pos3 = 3;
10227 break;
10228
10229 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10230 salt_type = SALT_TYPE_EMBEDDED;
10231 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10232 opts_type = OPTS_TYPE_PT_GENERATE_LE
10233 | OPTS_TYPE_ST_BASE64
10234 | OPTS_TYPE_HASH_COPY;
10235 kern_type = KERN_TYPE_PBKDF2_MD5;
10236 dgst_size = DGST_SIZE_4_32;
10237 parse_func = pbkdf2_md5_parse_hash;
10238 sort_by_digest = sort_by_digest_4_32;
10239 opti_type = OPTI_TYPE_ZERO_BYTE
10240 | OPTI_TYPE_SLOW_HASH_SIMD;
10241 dgst_pos0 = 0;
10242 dgst_pos1 = 1;
10243 dgst_pos2 = 2;
10244 dgst_pos3 = 3;
10245 break;
10246
10247 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10248 salt_type = SALT_TYPE_EMBEDDED;
10249 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10250 opts_type = OPTS_TYPE_PT_GENERATE_LE
10251 | OPTS_TYPE_ST_BASE64
10252 | OPTS_TYPE_HASH_COPY;
10253 kern_type = KERN_TYPE_PBKDF2_SHA1;
10254 dgst_size = DGST_SIZE_4_32;
10255 parse_func = pbkdf2_sha1_parse_hash;
10256 sort_by_digest = sort_by_digest_4_32;
10257 opti_type = OPTI_TYPE_ZERO_BYTE
10258 | OPTI_TYPE_SLOW_HASH_SIMD;
10259 dgst_pos0 = 0;
10260 dgst_pos1 = 1;
10261 dgst_pos2 = 2;
10262 dgst_pos3 = 3;
10263 break;
10264
10265 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10266 salt_type = SALT_TYPE_EMBEDDED;
10267 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10268 opts_type = OPTS_TYPE_PT_GENERATE_LE
10269 | OPTS_TYPE_ST_BASE64
10270 | OPTS_TYPE_HASH_COPY;
10271 kern_type = KERN_TYPE_PBKDF2_SHA512;
10272 dgst_size = DGST_SIZE_8_16;
10273 parse_func = pbkdf2_sha512_parse_hash;
10274 sort_by_digest = sort_by_digest_8_16;
10275 opti_type = OPTI_TYPE_ZERO_BYTE
10276 | OPTI_TYPE_USES_BITS_64
10277 | OPTI_TYPE_SLOW_HASH_SIMD;
10278 dgst_pos0 = 0;
10279 dgst_pos1 = 1;
10280 dgst_pos2 = 2;
10281 dgst_pos3 = 3;
10282 break;
10283
10284 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10285 salt_type = SALT_TYPE_EMBEDDED;
10286 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10287 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10288 kern_type = KERN_TYPE_ECRYPTFS;
10289 dgst_size = DGST_SIZE_8_8;
10290 parse_func = ecryptfs_parse_hash;
10291 sort_by_digest = sort_by_digest_8_8;
10292 opti_type = OPTI_TYPE_ZERO_BYTE
10293 | OPTI_TYPE_USES_BITS_64;
10294 dgst_pos0 = 0;
10295 dgst_pos1 = 1;
10296 dgst_pos2 = 2;
10297 dgst_pos3 = 3;
10298 break;
10299
10300 case 12300: hash_type = HASH_TYPE_ORACLET;
10301 salt_type = SALT_TYPE_EMBEDDED;
10302 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10303 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10304 kern_type = KERN_TYPE_ORACLET;
10305 dgst_size = DGST_SIZE_8_16;
10306 parse_func = oraclet_parse_hash;
10307 sort_by_digest = sort_by_digest_8_16;
10308 opti_type = OPTI_TYPE_ZERO_BYTE
10309 | OPTI_TYPE_USES_BITS_64;
10310 dgst_pos0 = 0;
10311 dgst_pos1 = 1;
10312 dgst_pos2 = 2;
10313 dgst_pos3 = 3;
10314 break;
10315
10316 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10317 salt_type = SALT_TYPE_EMBEDDED;
10318 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10319 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10320 kern_type = KERN_TYPE_BSDICRYPT;
10321 dgst_size = DGST_SIZE_4_4;
10322 parse_func = bsdicrypt_parse_hash;
10323 sort_by_digest = sort_by_digest_4_4;
10324 opti_type = OPTI_TYPE_ZERO_BYTE
10325 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10326 dgst_pos0 = 0;
10327 dgst_pos1 = 1;
10328 dgst_pos2 = 2;
10329 dgst_pos3 = 3;
10330 break;
10331
10332 case 12500: hash_type = HASH_TYPE_RAR3HP;
10333 salt_type = SALT_TYPE_EMBEDDED;
10334 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10335 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10336 kern_type = KERN_TYPE_RAR3;
10337 dgst_size = DGST_SIZE_4_4;
10338 parse_func = rar3hp_parse_hash;
10339 sort_by_digest = sort_by_digest_4_4;
10340 opti_type = OPTI_TYPE_ZERO_BYTE;
10341 dgst_pos0 = 0;
10342 dgst_pos1 = 1;
10343 dgst_pos2 = 2;
10344 dgst_pos3 = 3;
10345 break;
10346
10347 case 12600: hash_type = HASH_TYPE_SHA256;
10348 salt_type = SALT_TYPE_INTERN;
10349 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10350 opts_type = OPTS_TYPE_PT_GENERATE_BE
10351 | OPTS_TYPE_PT_ADD80;
10352 kern_type = KERN_TYPE_CF10;
10353 dgst_size = DGST_SIZE_4_8;
10354 parse_func = cf10_parse_hash;
10355 sort_by_digest = sort_by_digest_4_8;
10356 opti_type = OPTI_TYPE_ZERO_BYTE
10357 | OPTI_TYPE_PRECOMPUTE_INIT
10358 | OPTI_TYPE_EARLY_SKIP
10359 | OPTI_TYPE_NOT_ITERATED;
10360 dgst_pos0 = 3;
10361 dgst_pos1 = 7;
10362 dgst_pos2 = 2;
10363 dgst_pos3 = 6;
10364 break;
10365
10366 case 12700: hash_type = HASH_TYPE_AES;
10367 salt_type = SALT_TYPE_EMBEDDED;
10368 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10369 opts_type = OPTS_TYPE_PT_GENERATE_LE
10370 | OPTS_TYPE_HASH_COPY;
10371 kern_type = KERN_TYPE_MYWALLET;
10372 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10373 parse_func = mywallet_parse_hash;
10374 sort_by_digest = sort_by_digest_4_5;
10375 opti_type = OPTI_TYPE_ZERO_BYTE;
10376 dgst_pos0 = 0;
10377 dgst_pos1 = 1;
10378 dgst_pos2 = 2;
10379 dgst_pos3 = 3;
10380 break;
10381
10382 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10383 salt_type = SALT_TYPE_EMBEDDED;
10384 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10385 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10386 kern_type = KERN_TYPE_MS_DRSR;
10387 dgst_size = DGST_SIZE_4_8;
10388 parse_func = ms_drsr_parse_hash;
10389 sort_by_digest = sort_by_digest_4_8;
10390 opti_type = OPTI_TYPE_ZERO_BYTE;
10391 dgst_pos0 = 0;
10392 dgst_pos1 = 1;
10393 dgst_pos2 = 2;
10394 dgst_pos3 = 3;
10395 break;
10396
10397 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10398 salt_type = SALT_TYPE_EMBEDDED;
10399 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10400 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10401 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10402 dgst_size = DGST_SIZE_4_8;
10403 parse_func = androidfde_samsung_parse_hash;
10404 sort_by_digest = sort_by_digest_4_8;
10405 opti_type = OPTI_TYPE_ZERO_BYTE;
10406 dgst_pos0 = 0;
10407 dgst_pos1 = 1;
10408 dgst_pos2 = 2;
10409 dgst_pos3 = 3;
10410 break;
10411
10412 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10413 salt_type = SALT_TYPE_EMBEDDED;
10414 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10415 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10416 kern_type = KERN_TYPE_RAR5;
10417 dgst_size = DGST_SIZE_4_4;
10418 parse_func = rar5_parse_hash;
10419 sort_by_digest = sort_by_digest_4_4;
10420 opti_type = OPTI_TYPE_ZERO_BYTE;
10421 dgst_pos0 = 0;
10422 dgst_pos1 = 1;
10423 dgst_pos2 = 2;
10424 dgst_pos3 = 3;
10425 break;
10426
10427 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10428 salt_type = SALT_TYPE_EMBEDDED;
10429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10430 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10431 kern_type = KERN_TYPE_KRB5TGS;
10432 dgst_size = DGST_SIZE_4_4;
10433 parse_func = krb5tgs_parse_hash;
10434 sort_by_digest = sort_by_digest_4_4;
10435 opti_type = OPTI_TYPE_ZERO_BYTE
10436 | OPTI_TYPE_NOT_ITERATED;
10437 dgst_pos0 = 0;
10438 dgst_pos1 = 1;
10439 dgst_pos2 = 2;
10440 dgst_pos3 = 3;
10441 break;
10442
10443 case 13200: hash_type = HASH_TYPE_AES;
10444 salt_type = SALT_TYPE_EMBEDDED;
10445 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10446 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10447 kern_type = KERN_TYPE_AXCRYPT;
10448 dgst_size = DGST_SIZE_4_4;
10449 parse_func = axcrypt_parse_hash;
10450 sort_by_digest = sort_by_digest_4_4;
10451 opti_type = OPTI_TYPE_ZERO_BYTE;
10452 dgst_pos0 = 0;
10453 dgst_pos1 = 1;
10454 dgst_pos2 = 2;
10455 dgst_pos3 = 3;
10456 break;
10457
10458 case 13300: hash_type = HASH_TYPE_SHA1;
10459 salt_type = SALT_TYPE_NONE;
10460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10461 opts_type = OPTS_TYPE_PT_GENERATE_BE
10462 | OPTS_TYPE_PT_ADD80
10463 | OPTS_TYPE_PT_ADDBITS15;
10464 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10465 dgst_size = DGST_SIZE_4_5;
10466 parse_func = sha1axcrypt_parse_hash;
10467 sort_by_digest = sort_by_digest_4_5;
10468 opti_type = OPTI_TYPE_ZERO_BYTE
10469 | OPTI_TYPE_PRECOMPUTE_INIT
10470 | OPTI_TYPE_EARLY_SKIP
10471 | OPTI_TYPE_NOT_ITERATED
10472 | OPTI_TYPE_NOT_SALTED;
10473 dgst_pos0 = 0;
10474 dgst_pos1 = 4;
10475 dgst_pos2 = 3;
10476 dgst_pos3 = 2;
10477 break;
10478
10479 case 13400: hash_type = HASH_TYPE_AES;
10480 salt_type = SALT_TYPE_EMBEDDED;
10481 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10482 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10483 kern_type = KERN_TYPE_KEEPASS;
10484 dgst_size = DGST_SIZE_4_4;
10485 parse_func = keepass_parse_hash;
10486 sort_by_digest = sort_by_digest_4_4;
10487 opti_type = OPTI_TYPE_ZERO_BYTE;
10488 dgst_pos0 = 0;
10489 dgst_pos1 = 1;
10490 dgst_pos2 = 2;
10491 dgst_pos3 = 3;
10492 break;
10493
10494 case 13500: hash_type = HASH_TYPE_SHA1;
10495 salt_type = SALT_TYPE_EMBEDDED;
10496 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10497 opts_type = OPTS_TYPE_PT_GENERATE_BE
10498 | OPTS_TYPE_PT_UNICODE
10499 | OPTS_TYPE_PT_ADD80;
10500 kern_type = KERN_TYPE_PSTOKEN;
10501 dgst_size = DGST_SIZE_4_5;
10502 parse_func = pstoken_parse_hash;
10503 sort_by_digest = sort_by_digest_4_5;
10504 opti_type = OPTI_TYPE_ZERO_BYTE
10505 | OPTI_TYPE_PRECOMPUTE_INIT
10506 | OPTI_TYPE_EARLY_SKIP
10507 | OPTI_TYPE_NOT_ITERATED
10508 | OPTI_TYPE_PREPENDED_SALT
10509 | OPTI_TYPE_RAW_HASH;
10510 dgst_pos0 = 3;
10511 dgst_pos1 = 4;
10512 dgst_pos2 = 2;
10513 dgst_pos3 = 1;
10514 break;
10515
10516 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10517 salt_type = SALT_TYPE_EMBEDDED;
10518 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10519 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10520 kern_type = KERN_TYPE_ZIP2;
10521 dgst_size = DGST_SIZE_4_4;
10522 parse_func = zip2_parse_hash;
10523 sort_by_digest = sort_by_digest_4_4;
10524 opti_type = OPTI_TYPE_ZERO_BYTE;
10525 dgst_pos0 = 0;
10526 dgst_pos1 = 1;
10527 dgst_pos2 = 2;
10528 dgst_pos3 = 3;
10529 break;
10530
10531 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10532 salt_type = SALT_TYPE_EMBEDDED;
10533 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10534 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10535 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10536 dgst_size = DGST_SIZE_4_5;
10537 parse_func = veracrypt_parse_hash_655331;
10538 sort_by_digest = sort_by_digest_4_5;
10539 opti_type = OPTI_TYPE_ZERO_BYTE;
10540 dgst_pos0 = 0;
10541 dgst_pos1 = 1;
10542 dgst_pos2 = 2;
10543 dgst_pos3 = 3;
10544 break;
10545
10546 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10547 salt_type = SALT_TYPE_EMBEDDED;
10548 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10549 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10550 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10551 dgst_size = DGST_SIZE_4_5;
10552 parse_func = veracrypt_parse_hash_655331;
10553 sort_by_digest = sort_by_digest_4_5;
10554 opti_type = OPTI_TYPE_ZERO_BYTE;
10555 dgst_pos0 = 0;
10556 dgst_pos1 = 1;
10557 dgst_pos2 = 2;
10558 dgst_pos3 = 3;
10559 break;
10560
10561 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10562 salt_type = SALT_TYPE_EMBEDDED;
10563 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10564 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10565 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10566 dgst_size = DGST_SIZE_4_5;
10567 parse_func = veracrypt_parse_hash_655331;
10568 sort_by_digest = sort_by_digest_4_5;
10569 opti_type = OPTI_TYPE_ZERO_BYTE;
10570 dgst_pos0 = 0;
10571 dgst_pos1 = 1;
10572 dgst_pos2 = 2;
10573 dgst_pos3 = 3;
10574 break;
10575
10576 case 13721: hash_type = HASH_TYPE_SHA512;
10577 salt_type = SALT_TYPE_EMBEDDED;
10578 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10579 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10580 kern_type = KERN_TYPE_TCSHA512_XTS512;
10581 dgst_size = DGST_SIZE_8_8;
10582 parse_func = veracrypt_parse_hash_500000;
10583 sort_by_digest = sort_by_digest_8_8;
10584 opti_type = OPTI_TYPE_ZERO_BYTE
10585 | OPTI_TYPE_USES_BITS_64;
10586 dgst_pos0 = 0;
10587 dgst_pos1 = 1;
10588 dgst_pos2 = 2;
10589 dgst_pos3 = 3;
10590 break;
10591
10592 case 13722: hash_type = HASH_TYPE_SHA512;
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_TCSHA512_XTS1024;
10597 dgst_size = DGST_SIZE_8_8;
10598 parse_func = veracrypt_parse_hash_500000;
10599 sort_by_digest = sort_by_digest_8_8;
10600 opti_type = OPTI_TYPE_ZERO_BYTE
10601 | OPTI_TYPE_USES_BITS_64;
10602 dgst_pos0 = 0;
10603 dgst_pos1 = 1;
10604 dgst_pos2 = 2;
10605 dgst_pos3 = 3;
10606 break;
10607
10608 case 13723: hash_type = HASH_TYPE_SHA512;
10609 salt_type = SALT_TYPE_EMBEDDED;
10610 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10611 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10612 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10613 dgst_size = DGST_SIZE_8_8;
10614 parse_func = veracrypt_parse_hash_500000;
10615 sort_by_digest = sort_by_digest_8_8;
10616 opti_type = OPTI_TYPE_ZERO_BYTE
10617 | OPTI_TYPE_USES_BITS_64;
10618 dgst_pos0 = 0;
10619 dgst_pos1 = 1;
10620 dgst_pos2 = 2;
10621 dgst_pos3 = 3;
10622 break;
10623
10624 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10625 salt_type = SALT_TYPE_EMBEDDED;
10626 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10627 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10628 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10629 dgst_size = DGST_SIZE_4_8;
10630 parse_func = veracrypt_parse_hash_500000;
10631 sort_by_digest = sort_by_digest_4_8;
10632 opti_type = OPTI_TYPE_ZERO_BYTE;
10633 dgst_pos0 = 0;
10634 dgst_pos1 = 1;
10635 dgst_pos2 = 2;
10636 dgst_pos3 = 3;
10637 break;
10638
10639 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10640 salt_type = SALT_TYPE_EMBEDDED;
10641 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10642 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10643 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10644 dgst_size = DGST_SIZE_4_8;
10645 parse_func = veracrypt_parse_hash_500000;
10646 sort_by_digest = sort_by_digest_4_8;
10647 opti_type = OPTI_TYPE_ZERO_BYTE;
10648 dgst_pos0 = 0;
10649 dgst_pos1 = 1;
10650 dgst_pos2 = 2;
10651 dgst_pos3 = 3;
10652 break;
10653
10654 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10655 salt_type = SALT_TYPE_EMBEDDED;
10656 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10657 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10658 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10659 dgst_size = DGST_SIZE_4_8;
10660 parse_func = veracrypt_parse_hash_500000;
10661 sort_by_digest = sort_by_digest_4_8;
10662 opti_type = OPTI_TYPE_ZERO_BYTE;
10663 dgst_pos0 = 0;
10664 dgst_pos1 = 1;
10665 dgst_pos2 = 2;
10666 dgst_pos3 = 3;
10667 break;
10668
10669 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10670 salt_type = SALT_TYPE_EMBEDDED;
10671 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10672 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10673 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10674 dgst_size = DGST_SIZE_4_5;
10675 parse_func = veracrypt_parse_hash_327661;
10676 sort_by_digest = sort_by_digest_4_5;
10677 opti_type = OPTI_TYPE_ZERO_BYTE;
10678 dgst_pos0 = 0;
10679 dgst_pos1 = 1;
10680 dgst_pos2 = 2;
10681 dgst_pos3 = 3;
10682 break;
10683
10684 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10685 salt_type = SALT_TYPE_EMBEDDED;
10686 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10687 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10688 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10689 dgst_size = DGST_SIZE_4_5;
10690 parse_func = veracrypt_parse_hash_327661;
10691 sort_by_digest = sort_by_digest_4_5;
10692 opti_type = OPTI_TYPE_ZERO_BYTE;
10693 dgst_pos0 = 0;
10694 dgst_pos1 = 1;
10695 dgst_pos2 = 2;
10696 dgst_pos3 = 3;
10697 break;
10698
10699 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10700 salt_type = SALT_TYPE_EMBEDDED;
10701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10702 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10703 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10704 dgst_size = DGST_SIZE_4_5;
10705 parse_func = veracrypt_parse_hash_327661;
10706 sort_by_digest = sort_by_digest_4_5;
10707 opti_type = OPTI_TYPE_ZERO_BYTE;
10708 dgst_pos0 = 0;
10709 dgst_pos1 = 1;
10710 dgst_pos2 = 2;
10711 dgst_pos3 = 3;
10712 break;
10713
10714 case 13751: hash_type = HASH_TYPE_SHA256;
10715 salt_type = SALT_TYPE_EMBEDDED;
10716 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10717 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10718 kern_type = KERN_TYPE_VCSHA256_XTS512;
10719 dgst_size = DGST_SIZE_4_8;
10720 parse_func = veracrypt_parse_hash_500000;
10721 sort_by_digest = sort_by_digest_4_8;
10722 opti_type = OPTI_TYPE_ZERO_BYTE;
10723 dgst_pos0 = 0;
10724 dgst_pos1 = 1;
10725 dgst_pos2 = 2;
10726 dgst_pos3 = 3;
10727 break;
10728
10729 case 13752: hash_type = HASH_TYPE_SHA256;
10730 salt_type = SALT_TYPE_EMBEDDED;
10731 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10732 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10733 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10734 dgst_size = DGST_SIZE_4_8;
10735 parse_func = veracrypt_parse_hash_500000;
10736 sort_by_digest = sort_by_digest_4_8;
10737 opti_type = OPTI_TYPE_ZERO_BYTE;
10738 dgst_pos0 = 0;
10739 dgst_pos1 = 1;
10740 dgst_pos2 = 2;
10741 dgst_pos3 = 3;
10742 break;
10743
10744 case 13753: hash_type = HASH_TYPE_SHA256;
10745 salt_type = SALT_TYPE_EMBEDDED;
10746 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10747 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10748 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10749 dgst_size = DGST_SIZE_4_8;
10750 parse_func = veracrypt_parse_hash_500000;
10751 sort_by_digest = sort_by_digest_4_8;
10752 opti_type = OPTI_TYPE_ZERO_BYTE;
10753 dgst_pos0 = 0;
10754 dgst_pos1 = 1;
10755 dgst_pos2 = 2;
10756 dgst_pos3 = 3;
10757 break;
10758
10759 case 13761: hash_type = HASH_TYPE_SHA256;
10760 salt_type = SALT_TYPE_EMBEDDED;
10761 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10762 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10763 kern_type = KERN_TYPE_VCSHA256_XTS512;
10764 dgst_size = DGST_SIZE_4_8;
10765 parse_func = veracrypt_parse_hash_200000;
10766 sort_by_digest = sort_by_digest_4_8;
10767 opti_type = OPTI_TYPE_ZERO_BYTE;
10768 dgst_pos0 = 0;
10769 dgst_pos1 = 1;
10770 dgst_pos2 = 2;
10771 dgst_pos3 = 3;
10772 break;
10773
10774 case 13762: hash_type = HASH_TYPE_SHA256;
10775 salt_type = SALT_TYPE_EMBEDDED;
10776 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10777 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10778 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10779 dgst_size = DGST_SIZE_4_8;
10780 parse_func = veracrypt_parse_hash_200000;
10781 sort_by_digest = sort_by_digest_4_8;
10782 opti_type = OPTI_TYPE_ZERO_BYTE;
10783 dgst_pos0 = 0;
10784 dgst_pos1 = 1;
10785 dgst_pos2 = 2;
10786 dgst_pos3 = 3;
10787 break;
10788
10789 case 13763: hash_type = HASH_TYPE_SHA256;
10790 salt_type = SALT_TYPE_EMBEDDED;
10791 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10792 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10793 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10794 dgst_size = DGST_SIZE_4_8;
10795 parse_func = veracrypt_parse_hash_200000;
10796 sort_by_digest = sort_by_digest_4_8;
10797 opti_type = OPTI_TYPE_ZERO_BYTE;
10798 dgst_pos0 = 0;
10799 dgst_pos1 = 1;
10800 dgst_pos2 = 2;
10801 dgst_pos3 = 3;
10802 break;
10803
10804
10805 default: usage_mini_print (PROGNAME); return (-1);
10806 }
10807
10808 /**
10809 * parser
10810 */
10811
10812 data.parse_func = parse_func;
10813
10814 /**
10815 * misc stuff
10816 */
10817
10818 if (hex_salt)
10819 {
10820 if (salt_type == SALT_TYPE_INTERN)
10821 {
10822 opts_type |= OPTS_TYPE_ST_HEX;
10823 }
10824 else
10825 {
10826 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10827
10828 return (-1);
10829 }
10830 }
10831
10832 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10833 | (salt_type == SALT_TYPE_EXTERN)
10834 | (salt_type == SALT_TYPE_EMBEDDED)
10835 | (salt_type == SALT_TYPE_VIRTUAL));
10836
10837 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10838
10839 data.hash_type = hash_type;
10840 data.attack_mode = attack_mode;
10841 data.attack_kern = attack_kern;
10842 data.attack_exec = attack_exec;
10843 data.kern_type = kern_type;
10844 data.opts_type = opts_type;
10845 data.dgst_size = dgst_size;
10846 data.salt_type = salt_type;
10847 data.isSalted = isSalted;
10848 data.sort_by_digest = sort_by_digest;
10849 data.dgst_pos0 = dgst_pos0;
10850 data.dgst_pos1 = dgst_pos1;
10851 data.dgst_pos2 = dgst_pos2;
10852 data.dgst_pos3 = dgst_pos3;
10853
10854 esalt_size = 0;
10855
10856 switch (hash_mode)
10857 {
10858 case 2500: esalt_size = sizeof (wpa_t); break;
10859 case 5300: esalt_size = sizeof (ikepsk_t); break;
10860 case 5400: esalt_size = sizeof (ikepsk_t); break;
10861 case 5500: esalt_size = sizeof (netntlm_t); break;
10862 case 5600: esalt_size = sizeof (netntlm_t); break;
10863 case 6211: esalt_size = sizeof (tc_t); break;
10864 case 6212: esalt_size = sizeof (tc_t); break;
10865 case 6213: esalt_size = sizeof (tc_t); break;
10866 case 6221: esalt_size = sizeof (tc_t); break;
10867 case 6222: esalt_size = sizeof (tc_t); break;
10868 case 6223: esalt_size = sizeof (tc_t); break;
10869 case 6231: esalt_size = sizeof (tc_t); break;
10870 case 6232: esalt_size = sizeof (tc_t); break;
10871 case 6233: esalt_size = sizeof (tc_t); break;
10872 case 6241: esalt_size = sizeof (tc_t); break;
10873 case 6242: esalt_size = sizeof (tc_t); break;
10874 case 6243: esalt_size = sizeof (tc_t); break;
10875 case 6600: esalt_size = sizeof (agilekey_t); break;
10876 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10877 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10878 case 7300: esalt_size = sizeof (rakp_t); break;
10879 case 7500: esalt_size = sizeof (krb5pa_t); break;
10880 case 8200: esalt_size = sizeof (cloudkey_t); break;
10881 case 8800: esalt_size = sizeof (androidfde_t); break;
10882 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10883 case 9400: esalt_size = sizeof (office2007_t); break;
10884 case 9500: esalt_size = sizeof (office2010_t); break;
10885 case 9600: esalt_size = sizeof (office2013_t); break;
10886 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10887 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10888 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10889 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10890 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10891 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10892 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10893 case 10200: esalt_size = sizeof (cram_md5_t); break;
10894 case 10400: esalt_size = sizeof (pdf_t); break;
10895 case 10410: esalt_size = sizeof (pdf_t); break;
10896 case 10420: esalt_size = sizeof (pdf_t); break;
10897 case 10500: esalt_size = sizeof (pdf_t); break;
10898 case 10600: esalt_size = sizeof (pdf_t); break;
10899 case 10700: esalt_size = sizeof (pdf_t); break;
10900 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10901 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10902 case 11400: esalt_size = sizeof (sip_t); break;
10903 case 11600: esalt_size = sizeof (seven_zip_t); break;
10904 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10905 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10906 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10907 case 13000: esalt_size = sizeof (rar5_t); break;
10908 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10909 case 13400: esalt_size = sizeof (keepass_t); break;
10910 case 13500: esalt_size = sizeof (pstoken_t); break;
10911 case 13600: esalt_size = sizeof (zip2_t); break;
10912 case 13711: esalt_size = sizeof (tc_t); break;
10913 case 13712: esalt_size = sizeof (tc_t); break;
10914 case 13713: esalt_size = sizeof (tc_t); break;
10915 case 13721: esalt_size = sizeof (tc_t); break;
10916 case 13722: esalt_size = sizeof (tc_t); break;
10917 case 13723: esalt_size = sizeof (tc_t); break;
10918 case 13731: esalt_size = sizeof (tc_t); break;
10919 case 13732: esalt_size = sizeof (tc_t); break;
10920 case 13733: esalt_size = sizeof (tc_t); break;
10921 case 13741: esalt_size = sizeof (tc_t); break;
10922 case 13742: esalt_size = sizeof (tc_t); break;
10923 case 13743: esalt_size = sizeof (tc_t); break;
10924 case 13751: esalt_size = sizeof (tc_t); break;
10925 case 13752: esalt_size = sizeof (tc_t); break;
10926 case 13753: esalt_size = sizeof (tc_t); break;
10927 case 13761: esalt_size = sizeof (tc_t); break;
10928 case 13762: esalt_size = sizeof (tc_t); break;
10929 case 13763: esalt_size = sizeof (tc_t); break;
10930 }
10931
10932 data.esalt_size = esalt_size;
10933
10934 /**
10935 * choose dictionary parser
10936 */
10937
10938 if (hash_type == HASH_TYPE_LM)
10939 {
10940 get_next_word_func = get_next_word_lm;
10941 }
10942 else if (opts_type & OPTS_TYPE_PT_UPPER)
10943 {
10944 get_next_word_func = get_next_word_uc;
10945 }
10946 else
10947 {
10948 get_next_word_func = get_next_word_std;
10949 }
10950
10951 /**
10952 * dictstat
10953 */
10954
10955 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10956
10957 #ifdef _POSIX
10958 size_t dictstat_nmemb = 0;
10959 #endif
10960
10961 #ifdef _WIN
10962 uint dictstat_nmemb = 0;
10963 #endif
10964
10965 char dictstat[256] = { 0 };
10966
10967 FILE *dictstat_fp = NULL;
10968
10969 if (keyspace == 0)
10970 {
10971 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10972
10973 dictstat_fp = fopen (dictstat, "rb");
10974
10975 if (dictstat_fp)
10976 {
10977 #ifdef _POSIX
10978 struct stat tmpstat;
10979
10980 fstat (fileno (dictstat_fp), &tmpstat);
10981 #endif
10982
10983 #ifdef _WIN
10984 struct stat64 tmpstat;
10985
10986 _fstat64 (fileno (dictstat_fp), &tmpstat);
10987 #endif
10988
10989 if (tmpstat.st_mtime < COMPTIME)
10990 {
10991 /* with v0.15 the format changed so we have to ensure user is using a good version
10992 since there is no version-header in the dictstat file */
10993
10994 fclose (dictstat_fp);
10995
10996 unlink (dictstat);
10997 }
10998 else
10999 {
11000 while (!feof (dictstat_fp))
11001 {
11002 dictstat_t d;
11003
11004 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11005
11006 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11007
11008 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11009 {
11010 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11011
11012 return -1;
11013 }
11014 }
11015
11016 fclose (dictstat_fp);
11017 }
11018 }
11019 }
11020
11021 /**
11022 * potfile
11023 */
11024
11025 char potfile[256] = { 0 };
11026
11027 if (potfile_path == NULL)
11028 {
11029 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11030 }
11031 else
11032 {
11033 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11034 }
11035
11036 data.pot_fp = NULL;
11037
11038 FILE *out_fp = NULL;
11039 FILE *pot_fp = NULL;
11040
11041 if (show == 1 || left == 1)
11042 {
11043 pot_fp = fopen (potfile, "rb");
11044
11045 if (pot_fp == NULL)
11046 {
11047 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11048
11049 return (-1);
11050 }
11051
11052 if (outfile != NULL)
11053 {
11054 if ((out_fp = fopen (outfile, "ab")) == NULL)
11055 {
11056 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11057
11058 fclose (pot_fp);
11059
11060 return (-1);
11061 }
11062 }
11063 else
11064 {
11065 out_fp = stdout;
11066 }
11067 }
11068 else
11069 {
11070 if (potfile_disable == 0)
11071 {
11072 pot_fp = fopen (potfile, "ab");
11073
11074 if (pot_fp == NULL)
11075 {
11076 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11077
11078 return (-1);
11079 }
11080
11081 data.pot_fp = pot_fp;
11082 }
11083 }
11084
11085 pot_t *pot = NULL;
11086
11087 uint pot_cnt = 0;
11088 uint pot_avail = 0;
11089
11090 if (show == 1 || left == 1)
11091 {
11092 SUPPRESS_OUTPUT = 1;
11093
11094 pot_avail = count_lines (pot_fp);
11095
11096 rewind (pot_fp);
11097
11098 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11099
11100 uint pot_hashes_avail = 0;
11101
11102 uint line_num = 0;
11103
11104 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11105
11106 while (!feof (pot_fp))
11107 {
11108 line_num++;
11109
11110 int line_len = fgetl (pot_fp, line_buf);
11111
11112 if (line_len == 0) continue;
11113
11114 char *plain_buf = line_buf + line_len;
11115
11116 pot_t *pot_ptr = &pot[pot_cnt];
11117
11118 hash_t *hashes_buf = &pot_ptr->hash;
11119
11120 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11121 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11122
11123 if (pot_cnt == pot_hashes_avail)
11124 {
11125 uint pos = 0;
11126
11127 for (pos = 0; pos < INCR_POT; pos++)
11128 {
11129 if ((pot_cnt + pos) >= pot_avail) break;
11130
11131 pot_t *tmp_pot = &pot[pot_cnt + pos];
11132
11133 hash_t *tmp_hash = &tmp_pot->hash;
11134
11135 tmp_hash->digest = mymalloc (dgst_size);
11136
11137 if (isSalted)
11138 {
11139 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11140 }
11141
11142 if (esalt_size)
11143 {
11144 tmp_hash->esalt = mymalloc (esalt_size);
11145 }
11146
11147 pot_hashes_avail++;
11148 }
11149 }
11150
11151 int plain_len = 0;
11152
11153 int parser_status;
11154
11155 int iter = MAX_CUT_TRIES;
11156
11157 do
11158 {
11159 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11160 {
11161 if (line_buf[i] == ':')
11162 {
11163 line_len--;
11164
11165 break;
11166 }
11167 }
11168
11169 if (data.hash_mode != 2500)
11170 {
11171 parser_status = parse_func (line_buf, line_len, hashes_buf);
11172 }
11173 else
11174 {
11175 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11176
11177 if (line_len > max_salt_size)
11178 {
11179 parser_status = PARSER_GLOBAL_LENGTH;
11180 }
11181 else
11182 {
11183 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11184
11185 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11186
11187 hashes_buf->salt->salt_len = line_len;
11188
11189 parser_status = PARSER_OK;
11190 }
11191 }
11192
11193 // if NOT parsed without error, we add the ":" to the plain
11194
11195 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11196 {
11197 plain_len++;
11198 plain_buf--;
11199 }
11200
11201 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11202
11203 if (parser_status < PARSER_GLOBAL_ZERO)
11204 {
11205 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11206
11207 continue;
11208 }
11209
11210 if (plain_len >= 255) continue;
11211
11212 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11213
11214 pot_ptr->plain_len = plain_len;
11215
11216 pot_cnt++;
11217 }
11218
11219 myfree (line_buf);
11220
11221 fclose (pot_fp);
11222
11223 SUPPRESS_OUTPUT = 0;
11224
11225 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11226 }
11227
11228 /**
11229 * word len
11230 */
11231
11232 uint pw_min = PW_MIN;
11233 uint pw_max = PW_MAX;
11234
11235 switch (hash_mode)
11236 {
11237 case 125: if (pw_max > 32) pw_max = 32;
11238 break;
11239 case 400: if (pw_max > 40) pw_max = 40;
11240 break;
11241 case 500: if (pw_max > 16) pw_max = 16;
11242 break;
11243 case 1500: if (pw_max > 8) pw_max = 8;
11244 break;
11245 case 1600: if (pw_max > 16) pw_max = 16;
11246 break;
11247 case 1800: if (pw_max > 16) pw_max = 16;
11248 break;
11249 case 2100: if (pw_max > 16) pw_max = 16;
11250 break;
11251 case 2500: if (pw_min < 8) pw_min = 8;
11252 break;
11253 case 3000: if (pw_max > 7) pw_max = 7;
11254 break;
11255 case 5200: if (pw_max > 24) pw_max = 24;
11256 break;
11257 case 5800: if (pw_max > 16) pw_max = 16;
11258 break;
11259 case 6300: if (pw_max > 16) pw_max = 16;
11260 break;
11261 case 7400: if (pw_max > 16) pw_max = 16;
11262 break;
11263 case 7500: if (pw_max > 8) pw_max = 8;
11264 break;
11265 case 7900: if (pw_max > 48) pw_max = 48;
11266 break;
11267 case 8500: if (pw_max > 8) pw_max = 8;
11268 break;
11269 case 8600: if (pw_max > 16) pw_max = 16;
11270 break;
11271 case 9710: pw_min = 5;
11272 pw_max = 5;
11273 break;
11274 case 9810: pw_min = 5;
11275 pw_max = 5;
11276 break;
11277 case 10410: pw_min = 5;
11278 pw_max = 5;
11279 break;
11280 case 10300: if (pw_max < 3) pw_min = 3;
11281 if (pw_max > 40) pw_max = 40;
11282 break;
11283 case 10500: if (pw_max < 3) pw_min = 3;
11284 if (pw_max > 40) pw_max = 40;
11285 break;
11286 case 10700: if (pw_max > 16) pw_max = 16;
11287 break;
11288 case 11300: if (pw_max > 40) pw_max = 40;
11289 break;
11290 case 11600: if (pw_max > 32) pw_max = 32;
11291 break;
11292 case 12500: if (pw_max > 20) pw_max = 20;
11293 break;
11294 case 12800: if (pw_max > 24) pw_max = 24;
11295 break;
11296 }
11297
11298 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11299 {
11300 switch (attack_kern)
11301 {
11302 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11303 break;
11304 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11305 break;
11306 }
11307 }
11308
11309 /**
11310 * charsets : keep them together for more easy maintainnce
11311 */
11312
11313 cs_t mp_sys[6] = { { { 0 }, 0 } };
11314 cs_t mp_usr[4] = { { { 0 }, 0 } };
11315
11316 mp_setup_sys (mp_sys);
11317
11318 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11319 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11320 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11321 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11322
11323 /**
11324 * load hashes, part I: find input mode, count hashes
11325 */
11326
11327 uint hashlist_mode = 0;
11328 uint hashlist_format = HLFMT_HASHCAT;
11329
11330 uint hashes_avail = 0;
11331
11332 if (benchmark == 0)
11333 {
11334 struct stat f;
11335
11336 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11337
11338 if ((hash_mode == 2500) ||
11339 (hash_mode == 5200) ||
11340 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11341 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11342 (hash_mode == 9000))
11343 {
11344 hashlist_mode = HL_MODE_ARG;
11345
11346 char *hashfile = myargv[optind];
11347
11348 data.hashfile = hashfile;
11349
11350 logfile_top_var_string ("target", hashfile);
11351 }
11352
11353 if (hashlist_mode == HL_MODE_ARG)
11354 {
11355 if (hash_mode == 2500)
11356 {
11357 struct stat st;
11358
11359 if (stat (data.hashfile, &st) == -1)
11360 {
11361 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11362
11363 return (-1);
11364 }
11365
11366 hashes_avail = st.st_size / sizeof (hccap_t);
11367 }
11368 else
11369 {
11370 hashes_avail = 1;
11371 }
11372 }
11373 else if (hashlist_mode == HL_MODE_FILE)
11374 {
11375 char *hashfile = myargv[optind];
11376
11377 data.hashfile = hashfile;
11378
11379 logfile_top_var_string ("target", hashfile);
11380
11381 FILE *fp = NULL;
11382
11383 if ((fp = fopen (hashfile, "rb")) == NULL)
11384 {
11385 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11386
11387 return (-1);
11388 }
11389
11390 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11391
11392 hashes_avail = count_lines (fp);
11393
11394 rewind (fp);
11395
11396 if (hashes_avail == 0)
11397 {
11398 log_error ("ERROR: hashfile is empty or corrupt");
11399
11400 fclose (fp);
11401
11402 return (-1);
11403 }
11404
11405 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11406
11407 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11408 {
11409 log_error ("ERROR: remove not supported in native hashfile-format mode");
11410
11411 fclose (fp);
11412
11413 return (-1);
11414 }
11415
11416 fclose (fp);
11417 }
11418 }
11419 else
11420 {
11421 hashlist_mode = HL_MODE_ARG;
11422
11423 hashes_avail = 1;
11424 }
11425
11426 if (hash_mode == 3000) hashes_avail *= 2;
11427
11428 data.hashlist_mode = hashlist_mode;
11429 data.hashlist_format = hashlist_format;
11430
11431 logfile_top_uint (hashlist_mode);
11432 logfile_top_uint (hashlist_format);
11433
11434 /**
11435 * load hashes, part II: allocate required memory, set pointers
11436 */
11437
11438 hash_t *hashes_buf = NULL;
11439 void *digests_buf = NULL;
11440 salt_t *salts_buf = NULL;
11441 void *esalts_buf = NULL;
11442
11443 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11444
11445 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11446
11447 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11448 {
11449 u32 hash_pos;
11450
11451 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11452 {
11453 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11454
11455 hashes_buf[hash_pos].hash_info = hash_info;
11456
11457 if (username && (remove || show || left))
11458 {
11459 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11460 }
11461
11462 if (benchmark)
11463 {
11464 hash_info->orighash = (char *) mymalloc (256);
11465 }
11466 }
11467 }
11468
11469 if (isSalted)
11470 {
11471 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11472
11473 if (esalt_size)
11474 {
11475 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11476 }
11477 }
11478 else
11479 {
11480 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11481 }
11482
11483 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11484 {
11485 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11486
11487 if (isSalted)
11488 {
11489 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11490
11491 if (esalt_size)
11492 {
11493 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11494 }
11495 }
11496 else
11497 {
11498 hashes_buf[hash_pos].salt = &salts_buf[0];
11499 }
11500 }
11501
11502 /**
11503 * load hashes, part III: parse hashes or generate them if benchmark
11504 */
11505
11506 uint hashes_cnt = 0;
11507
11508 if (benchmark == 0)
11509 {
11510 if (keyspace == 1)
11511 {
11512 // useless to read hash file for keyspace, cheat a little bit w/ optind
11513 }
11514 else if (hashes_avail == 0)
11515 {
11516 }
11517 else if (hashlist_mode == HL_MODE_ARG)
11518 {
11519 char *input_buf = myargv[optind];
11520
11521 uint input_len = strlen (input_buf);
11522
11523 logfile_top_var_string ("target", input_buf);
11524
11525 char *hash_buf = NULL;
11526 int hash_len = 0;
11527
11528 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11529
11530 bool hash_fmt_error = 0;
11531
11532 if (hash_len < 1) hash_fmt_error = 1;
11533 if (hash_buf == NULL) hash_fmt_error = 1;
11534
11535 if (hash_fmt_error)
11536 {
11537 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11538 }
11539 else
11540 {
11541 if (opts_type & OPTS_TYPE_HASH_COPY)
11542 {
11543 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11544
11545 hash_info_tmp->orighash = mystrdup (hash_buf);
11546 }
11547
11548 if (isSalted)
11549 {
11550 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11551 }
11552
11553 int parser_status = PARSER_OK;
11554
11555 if (hash_mode == 2500)
11556 {
11557 if (hash_len == 0)
11558 {
11559 log_error ("ERROR: hccap file not specified");
11560
11561 return (-1);
11562 }
11563
11564 hashlist_mode = HL_MODE_FILE;
11565
11566 data.hashlist_mode = hashlist_mode;
11567
11568 FILE *fp = fopen (hash_buf, "rb");
11569
11570 if (fp == NULL)
11571 {
11572 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11573
11574 return (-1);
11575 }
11576
11577 if (hashes_avail < 1)
11578 {
11579 log_error ("ERROR: hccap file is empty or corrupt");
11580
11581 fclose (fp);
11582
11583 return (-1);
11584 }
11585
11586 uint hccap_size = sizeof (hccap_t);
11587
11588 char *in = (char *) mymalloc (hccap_size);
11589
11590 while (!feof (fp))
11591 {
11592 int n = fread (in, hccap_size, 1, fp);
11593
11594 if (n != 1)
11595 {
11596 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11597
11598 break;
11599 }
11600
11601 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11602
11603 if (parser_status != PARSER_OK)
11604 {
11605 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11606
11607 continue;
11608 }
11609
11610 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11611
11612 if ((show == 1) || (left == 1))
11613 {
11614 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11615
11616 char *salt_ptr = (char *) tmp_salt->salt_buf;
11617
11618 int cur_pos = tmp_salt->salt_len;
11619 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11620
11621 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11622
11623 // do the appending task
11624
11625 snprintf (salt_ptr + cur_pos,
11626 rem_len,
11627 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11628 wpa->orig_mac1[0],
11629 wpa->orig_mac1[1],
11630 wpa->orig_mac1[2],
11631 wpa->orig_mac1[3],
11632 wpa->orig_mac1[4],
11633 wpa->orig_mac1[5],
11634 wpa->orig_mac2[0],
11635 wpa->orig_mac2[1],
11636 wpa->orig_mac2[2],
11637 wpa->orig_mac2[3],
11638 wpa->orig_mac2[4],
11639 wpa->orig_mac2[5]);
11640
11641 // memset () the remaining part of the salt
11642
11643 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11644 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11645
11646 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11647
11648 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11649 }
11650
11651 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);
11652 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);
11653
11654 hashes_cnt++;
11655 }
11656
11657 fclose (fp);
11658
11659 myfree (in);
11660 }
11661 else if (hash_mode == 3000)
11662 {
11663 if (hash_len == 32)
11664 {
11665 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11666
11667 hash_t *lm_hash_left = NULL;
11668
11669 if (parser_status == PARSER_OK)
11670 {
11671 lm_hash_left = &hashes_buf[hashes_cnt];
11672
11673 hashes_cnt++;
11674 }
11675 else
11676 {
11677 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11678 }
11679
11680 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11681
11682 hash_t *lm_hash_right = NULL;
11683
11684 if (parser_status == PARSER_OK)
11685 {
11686 lm_hash_right = &hashes_buf[hashes_cnt];
11687
11688 hashes_cnt++;
11689 }
11690 else
11691 {
11692 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11693 }
11694
11695 // show / left
11696
11697 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11698 {
11699 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);
11700 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);
11701 }
11702 }
11703 else
11704 {
11705 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11706
11707 if (parser_status == PARSER_OK)
11708 {
11709 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11710 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11711 }
11712
11713 if (parser_status == PARSER_OK)
11714 {
11715 hashes_cnt++;
11716 }
11717 else
11718 {
11719 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11720 }
11721 }
11722 }
11723 else
11724 {
11725 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11726
11727 if (parser_status == PARSER_OK)
11728 {
11729 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11730 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11731 }
11732
11733 if (parser_status == PARSER_OK)
11734 {
11735 hashes_cnt++;
11736 }
11737 else
11738 {
11739 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11740 }
11741 }
11742 }
11743 }
11744 else if (hashlist_mode == HL_MODE_FILE)
11745 {
11746 char *hashfile = data.hashfile;
11747
11748 FILE *fp;
11749
11750 if ((fp = fopen (hashfile, "rb")) == NULL)
11751 {
11752 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11753
11754 return (-1);
11755 }
11756
11757 uint line_num = 0;
11758
11759 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11760
11761 while (!feof (fp))
11762 {
11763 line_num++;
11764
11765 int line_len = fgetl (fp, line_buf);
11766
11767 if (line_len == 0) continue;
11768
11769 char *hash_buf = NULL;
11770 int hash_len = 0;
11771
11772 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11773
11774 bool hash_fmt_error = 0;
11775
11776 if (hash_len < 1) hash_fmt_error = 1;
11777 if (hash_buf == NULL) hash_fmt_error = 1;
11778
11779 if (hash_fmt_error)
11780 {
11781 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11782
11783 continue;
11784 }
11785
11786 if (username)
11787 {
11788 char *user_buf = NULL;
11789 int user_len = 0;
11790
11791 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11792
11793 if (remove || show)
11794 {
11795 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11796
11797 *user = (user_t *) mymalloc (sizeof (user_t));
11798
11799 user_t *user_ptr = *user;
11800
11801 if (user_buf != NULL)
11802 {
11803 user_ptr->user_name = mystrdup (user_buf);
11804 }
11805 else
11806 {
11807 user_ptr->user_name = mystrdup ("");
11808 }
11809
11810 user_ptr->user_len = user_len;
11811 }
11812 }
11813
11814 if (opts_type & OPTS_TYPE_HASH_COPY)
11815 {
11816 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11817
11818 hash_info_tmp->orighash = mystrdup (hash_buf);
11819 }
11820
11821 if (isSalted)
11822 {
11823 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11824 }
11825
11826 if (hash_mode == 3000)
11827 {
11828 if (hash_len == 32)
11829 {
11830 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11831
11832 if (parser_status < PARSER_GLOBAL_ZERO)
11833 {
11834 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11835
11836 continue;
11837 }
11838
11839 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11840
11841 hashes_cnt++;
11842
11843 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11844
11845 if (parser_status < PARSER_GLOBAL_ZERO)
11846 {
11847 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11848
11849 continue;
11850 }
11851
11852 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11853
11854 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);
11855
11856 hashes_cnt++;
11857
11858 // show / left
11859
11860 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);
11861 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);
11862 }
11863 else
11864 {
11865 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11866
11867 if (parser_status < PARSER_GLOBAL_ZERO)
11868 {
11869 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11870
11871 continue;
11872 }
11873
11874 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);
11875
11876 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11877 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11878
11879 hashes_cnt++;
11880 }
11881 }
11882 else
11883 {
11884 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11885
11886 if (parser_status < PARSER_GLOBAL_ZERO)
11887 {
11888 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11889
11890 continue;
11891 }
11892
11893 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);
11894
11895 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11896 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11897
11898 hashes_cnt++;
11899 }
11900 }
11901
11902 myfree (line_buf);
11903
11904 fclose (fp);
11905
11906 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11907
11908 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11909 }
11910 }
11911 else
11912 {
11913 if (isSalted)
11914 {
11915 hashes_buf[0].salt->salt_len = 8;
11916
11917 // special salt handling
11918
11919 switch (hash_mode)
11920 {
11921 case 1500: hashes_buf[0].salt->salt_len = 2;
11922 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11923 break;
11924 case 1731: hashes_buf[0].salt->salt_len = 4;
11925 break;
11926 case 2410: hashes_buf[0].salt->salt_len = 4;
11927 break;
11928 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11929 break;
11930 case 3100: hashes_buf[0].salt->salt_len = 1;
11931 break;
11932 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11933 break;
11934 case 5800: hashes_buf[0].salt->salt_len = 16;
11935 break;
11936 case 6800: hashes_buf[0].salt->salt_len = 32;
11937 break;
11938 case 8400: hashes_buf[0].salt->salt_len = 40;
11939 break;
11940 case 8800: hashes_buf[0].salt->salt_len = 16;
11941 break;
11942 case 8900: hashes_buf[0].salt->salt_len = 16;
11943 hashes_buf[0].salt->scrypt_N = 1024;
11944 hashes_buf[0].salt->scrypt_r = 1;
11945 hashes_buf[0].salt->scrypt_p = 1;
11946 break;
11947 case 9100: hashes_buf[0].salt->salt_len = 16;
11948 break;
11949 case 9300: hashes_buf[0].salt->salt_len = 14;
11950 hashes_buf[0].salt->scrypt_N = 16384;
11951 hashes_buf[0].salt->scrypt_r = 1;
11952 hashes_buf[0].salt->scrypt_p = 1;
11953 break;
11954 case 9400: hashes_buf[0].salt->salt_len = 16;
11955 break;
11956 case 9500: hashes_buf[0].salt->salt_len = 16;
11957 break;
11958 case 9600: hashes_buf[0].salt->salt_len = 16;
11959 break;
11960 case 9700: hashes_buf[0].salt->salt_len = 16;
11961 break;
11962 case 9710: hashes_buf[0].salt->salt_len = 16;
11963 break;
11964 case 9720: hashes_buf[0].salt->salt_len = 16;
11965 break;
11966 case 9800: hashes_buf[0].salt->salt_len = 16;
11967 break;
11968 case 9810: hashes_buf[0].salt->salt_len = 16;
11969 break;
11970 case 9820: hashes_buf[0].salt->salt_len = 16;
11971 break;
11972 case 10300: hashes_buf[0].salt->salt_len = 12;
11973 break;
11974 case 11500: hashes_buf[0].salt->salt_len = 4;
11975 break;
11976 case 11600: hashes_buf[0].salt->salt_len = 4;
11977 break;
11978 case 12400: hashes_buf[0].salt->salt_len = 4;
11979 break;
11980 case 12500: hashes_buf[0].salt->salt_len = 8;
11981 break;
11982 case 12600: hashes_buf[0].salt->salt_len = 64;
11983 break;
11984 }
11985
11986 // special esalt handling
11987
11988 switch (hash_mode)
11989 {
11990 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11991 break;
11992 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11993 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11994 break;
11995 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11996 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11997 break;
11998 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11999 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12000 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12001 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12002 break;
12003 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12004 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12005 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12006 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12007 break;
12008 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12009 break;
12010 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12011 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12012 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12013 break;
12014 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12015 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12016 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12017 break;
12018 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12019 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12020 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12021 break;
12022 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12023 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12024 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12025 break;
12026 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12027 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12028 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12029 break;
12030 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12031 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12032 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12033 break;
12034 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12035 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12036 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12037 break;
12038 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12039 break;
12040 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12041 break;
12042 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12043 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12044 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12045 break;
12046 }
12047 }
12048
12049 // set hashfile
12050
12051 switch (hash_mode)
12052 {
12053 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12054 break;
12055 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12056 break;
12057 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12058 break;
12059 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12060 break;
12061 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12062 break;
12063 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12064 break;
12065 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12066 break;
12067 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12068 break;
12069 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12070 break;
12071 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12072 break;
12073 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12074 break;
12075 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12076 break;
12077 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12078 break;
12079 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12080 break;
12081 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12082 break;
12083 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12084 break;
12085 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12086 break;
12087 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12088 break;
12089 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12090 break;
12091 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12092 break;
12093 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12094 break;
12095 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12096 break;
12097 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12098 break;
12099 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12100 break;
12101 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12102 break;
12103 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12104 break;
12105 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12106 break;
12107 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12108 break;
12109 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12110 break;
12111 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12112 break;
12113 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12114 break;
12115 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12116 break;
12117 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12118 break;
12119 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12120 break;
12121 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12122 break;
12123 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12124 break;
12125 }
12126
12127 // set default iterations
12128
12129 switch (hash_mode)
12130 {
12131 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12132 break;
12133 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12134 break;
12135 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12136 break;
12137 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12138 break;
12139 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12140 break;
12141 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12142 break;
12143 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12144 break;
12145 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12146 break;
12147 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12148 break;
12149 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12150 break;
12151 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12152 break;
12153 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12154 break;
12155 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12156 break;
12157 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12158 break;
12159 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12160 break;
12161 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12162 break;
12163 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12164 break;
12165 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12166 break;
12167 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12168 break;
12169 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12170 break;
12171 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12172 break;
12173 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12174 break;
12175 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12176 break;
12177 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12178 break;
12179 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12180 break;
12181 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12182 break;
12183 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12184 break;
12185 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12186 break;
12187 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12188 break;
12189 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12190 break;
12191 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12192 break;
12193 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12194 break;
12195 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12196 break;
12197 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12198 break;
12199 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12200 break;
12201 case 8900: hashes_buf[0].salt->salt_iter = 1;
12202 break;
12203 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12204 break;
12205 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12206 break;
12207 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12208 break;
12209 case 9300: hashes_buf[0].salt->salt_iter = 1;
12210 break;
12211 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12212 break;
12213 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12214 break;
12215 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12216 break;
12217 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12218 break;
12219 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12220 break;
12221 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12222 break;
12223 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12224 break;
12225 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12226 break;
12227 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12228 break;
12229 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12230 break;
12231 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12232 break;
12233 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12234 break;
12235 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12236 break;
12237 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12238 break;
12239 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12240 break;
12241 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12242 break;
12243 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12244 break;
12245 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12246 break;
12247 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12248 break;
12249 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12250 break;
12251 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12252 break;
12253 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12254 break;
12255 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12256 break;
12257 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12258 break;
12259 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12260 break;
12261 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12262 break;
12263 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12264 break;
12265 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12266 break;
12267 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12268 break;
12269 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12270 break;
12271 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12272 break;
12273 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12274 break;
12275 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12276 break;
12277 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12278 break;
12279 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12280 break;
12281 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12282 break;
12283 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12284 break;
12285 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12286 break;
12287 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12288 break;
12289 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12290 break;
12291 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12292 break;
12293 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12294 break;
12295 }
12296
12297 hashes_cnt = 1;
12298 }
12299
12300 if (show == 1 || left == 1)
12301 {
12302 for (uint i = 0; i < pot_cnt; i++)
12303 {
12304 pot_t *pot_ptr = &pot[i];
12305
12306 hash_t *hashes_buf = &pot_ptr->hash;
12307
12308 local_free (hashes_buf->digest);
12309
12310 if (isSalted)
12311 {
12312 local_free (hashes_buf->salt);
12313 }
12314 }
12315
12316 local_free (pot);
12317
12318 if (data.quiet == 0) log_info_nn ("");
12319
12320 return (0);
12321 }
12322
12323 if (keyspace == 0)
12324 {
12325 if (hashes_cnt == 0)
12326 {
12327 log_error ("ERROR: No hashes loaded");
12328
12329 return (-1);
12330 }
12331 }
12332
12333 /**
12334 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12335 */
12336
12337 if (data.outfile != NULL)
12338 {
12339 if (data.hashfile != NULL)
12340 {
12341 #ifdef _POSIX
12342 struct stat tmpstat_outfile;
12343 struct stat tmpstat_hashfile;
12344 #endif
12345
12346 #ifdef _WIN
12347 struct stat64 tmpstat_outfile;
12348 struct stat64 tmpstat_hashfile;
12349 #endif
12350
12351 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12352
12353 if (tmp_outfile_fp)
12354 {
12355 #ifdef _POSIX
12356 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12357 #endif
12358
12359 #ifdef _WIN
12360 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12361 #endif
12362
12363 fclose (tmp_outfile_fp);
12364 }
12365
12366 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12367
12368 if (tmp_hashfile_fp)
12369 {
12370 #ifdef _POSIX
12371 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12372 #endif
12373
12374 #ifdef _WIN
12375 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12376 #endif
12377
12378 fclose (tmp_hashfile_fp);
12379 }
12380
12381 if (tmp_outfile_fp && tmp_outfile_fp)
12382 {
12383 tmpstat_outfile.st_mode = 0;
12384 tmpstat_outfile.st_nlink = 0;
12385 tmpstat_outfile.st_uid = 0;
12386 tmpstat_outfile.st_gid = 0;
12387 tmpstat_outfile.st_rdev = 0;
12388 tmpstat_outfile.st_atime = 0;
12389
12390 tmpstat_hashfile.st_mode = 0;
12391 tmpstat_hashfile.st_nlink = 0;
12392 tmpstat_hashfile.st_uid = 0;
12393 tmpstat_hashfile.st_gid = 0;
12394 tmpstat_hashfile.st_rdev = 0;
12395 tmpstat_hashfile.st_atime = 0;
12396
12397 #ifdef _POSIX
12398 tmpstat_outfile.st_blksize = 0;
12399 tmpstat_outfile.st_blocks = 0;
12400
12401 tmpstat_hashfile.st_blksize = 0;
12402 tmpstat_hashfile.st_blocks = 0;
12403 #endif
12404
12405 #ifdef _POSIX
12406 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12407 {
12408 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12409
12410 return (-1);
12411 }
12412 #endif
12413
12414 #ifdef _WIN
12415 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12416 {
12417 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12418
12419 return (-1);
12420 }
12421 #endif
12422 }
12423 }
12424 }
12425
12426 /**
12427 * Remove duplicates
12428 */
12429
12430 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12431
12432 if (isSalted)
12433 {
12434 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12435 }
12436 else
12437 {
12438 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12439 }
12440
12441 uint hashes_cnt_orig = hashes_cnt;
12442
12443 hashes_cnt = 1;
12444
12445 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12446 {
12447 if (isSalted)
12448 {
12449 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12450 {
12451 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12452 }
12453 }
12454 else
12455 {
12456 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12457 }
12458
12459 if (hashes_pos > hashes_cnt)
12460 {
12461 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12462 }
12463
12464 hashes_cnt++;
12465 }
12466
12467 /**
12468 * Potfile removes
12469 */
12470
12471 uint potfile_remove_cracks = 0;
12472
12473 if (potfile_disable == 0)
12474 {
12475 hash_t hash_buf;
12476
12477 hash_buf.digest = mymalloc (dgst_size);
12478 hash_buf.salt = NULL;
12479 hash_buf.esalt = NULL;
12480 hash_buf.hash_info = NULL;
12481 hash_buf.cracked = 0;
12482
12483 if (isSalted)
12484 {
12485 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12486 }
12487
12488 if (esalt_size)
12489 {
12490 hash_buf.esalt = mymalloc (esalt_size);
12491 }
12492
12493 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12494
12495 // no solution for these special hash types (for instane because they use hashfile in output etc)
12496 if ((hash_mode != 5200) &&
12497 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12498 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12499 (hash_mode != 9000))
12500 {
12501 FILE *fp = fopen (potfile, "rb");
12502
12503 if (fp != NULL)
12504 {
12505 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12506
12507 // to be safe work with a copy (because of line_len loop, i etc)
12508 // moved up here because it's easier to handle continue case
12509 // it's just 64kb
12510
12511 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12512
12513 while (!feof (fp))
12514 {
12515 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12516
12517 if (ptr == NULL) break;
12518
12519 int line_len = strlen (line_buf);
12520
12521 if (line_len == 0) continue;
12522
12523 int iter = MAX_CUT_TRIES;
12524
12525 for (int i = line_len - 1; i && iter; i--, line_len--)
12526 {
12527 if (line_buf[i] != ':') continue;
12528
12529 if (isSalted)
12530 {
12531 memset (hash_buf.salt, 0, sizeof (salt_t));
12532 }
12533
12534 hash_t *found = NULL;
12535
12536 if (hash_mode == 6800)
12537 {
12538 if (i < 64) // 64 = 16 * uint in salt_buf[]
12539 {
12540 // manipulate salt_buf
12541 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12542
12543 hash_buf.salt->salt_len = i;
12544
12545 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12546 }
12547 }
12548 else if (hash_mode == 2500)
12549 {
12550 if (i < 64) // 64 = 16 * uint in salt_buf[]
12551 {
12552 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12553 // manipulate salt_buf
12554
12555 memcpy (line_buf_cpy, line_buf, i);
12556
12557 char *mac2_pos = strrchr (line_buf_cpy, ':');
12558
12559 if (mac2_pos == NULL) continue;
12560
12561 mac2_pos[0] = 0;
12562 mac2_pos++;
12563
12564 if (strlen (mac2_pos) != 12) continue;
12565
12566 char *mac1_pos = strrchr (line_buf_cpy, ':');
12567
12568 if (mac1_pos == NULL) continue;
12569
12570 mac1_pos[0] = 0;
12571 mac1_pos++;
12572
12573 if (strlen (mac1_pos) != 12) continue;
12574
12575 uint essid_length = mac1_pos - line_buf_cpy - 1;
12576
12577 // here we need the ESSID
12578 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12579
12580 hash_buf.salt->salt_len = essid_length;
12581
12582 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12583
12584 if (found)
12585 {
12586 wpa_t *wpa = (wpa_t *) found->esalt;
12587
12588 // compare hex string(s) vs binary MAC address(es)
12589
12590 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12591 {
12592 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12593 {
12594 found = NULL;
12595
12596 break;
12597 }
12598 }
12599
12600 // early skip ;)
12601 if (!found) continue;
12602
12603 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12604 {
12605 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12606 {
12607 found = NULL;
12608
12609 break;
12610 }
12611 }
12612 }
12613 }
12614 }
12615 else
12616 {
12617 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12618
12619 if (parser_status == PARSER_OK)
12620 {
12621 if (isSalted)
12622 {
12623 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12624 }
12625 else
12626 {
12627 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12628 }
12629 }
12630 }
12631
12632 if (found == NULL) continue;
12633
12634 if (!found->cracked) potfile_remove_cracks++;
12635
12636 found->cracked = 1;
12637
12638 if (found) break;
12639
12640 iter--;
12641 }
12642 }
12643
12644 myfree (line_buf_cpy);
12645
12646 myfree (line_buf);
12647
12648 fclose (fp);
12649 }
12650 }
12651
12652 if (esalt_size)
12653 {
12654 local_free (hash_buf.esalt);
12655 }
12656
12657 if (isSalted)
12658 {
12659 local_free (hash_buf.salt);
12660 }
12661
12662 local_free (hash_buf.digest);
12663 }
12664
12665 /**
12666 * Now generate all the buffers required for later
12667 */
12668
12669 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12670
12671 salt_t *salts_buf_new = NULL;
12672 void *esalts_buf_new = NULL;
12673
12674 if (isSalted)
12675 {
12676 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12677
12678 if (esalt_size)
12679 {
12680 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12681 }
12682 }
12683 else
12684 {
12685 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12686 }
12687
12688 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12689
12690 uint digests_cnt = hashes_cnt;
12691 uint digests_done = 0;
12692
12693 size_t size_digests = digests_cnt * dgst_size;
12694 size_t size_shown = digests_cnt * sizeof (uint);
12695
12696 uint *digests_shown = (uint *) mymalloc (size_shown);
12697 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12698
12699 uint salts_cnt = 0;
12700 uint salts_done = 0;
12701
12702 hashinfo_t **hash_info = NULL;
12703
12704 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12705 {
12706 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12707
12708 if (username && (remove || show))
12709 {
12710 uint user_pos;
12711
12712 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12713 {
12714 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12715
12716 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12717 }
12718 }
12719 }
12720
12721 uint *salts_shown = (uint *) mymalloc (size_shown);
12722
12723 salt_t *salt_buf;
12724
12725 {
12726 // copied from inner loop
12727
12728 salt_buf = &salts_buf_new[salts_cnt];
12729
12730 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12731
12732 if (esalt_size)
12733 {
12734 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12735 }
12736
12737 salt_buf->digests_cnt = 0;
12738 salt_buf->digests_done = 0;
12739 salt_buf->digests_offset = 0;
12740
12741 salts_cnt++;
12742 }
12743
12744 if (hashes_buf[0].cracked == 1)
12745 {
12746 digests_shown[0] = 1;
12747
12748 digests_done++;
12749
12750 salt_buf->digests_done++;
12751 }
12752
12753 salt_buf->digests_cnt++;
12754
12755 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12756
12757 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12758 {
12759 hash_info[0] = hashes_buf[0].hash_info;
12760 }
12761
12762 // copy from inner loop
12763
12764 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12765 {
12766 if (isSalted)
12767 {
12768 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12769 {
12770 salt_buf = &salts_buf_new[salts_cnt];
12771
12772 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12773
12774 if (esalt_size)
12775 {
12776 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12777 }
12778
12779 salt_buf->digests_cnt = 0;
12780 salt_buf->digests_done = 0;
12781 salt_buf->digests_offset = hashes_pos;
12782
12783 salts_cnt++;
12784 }
12785 }
12786
12787 if (hashes_buf[hashes_pos].cracked == 1)
12788 {
12789 digests_shown[hashes_pos] = 1;
12790
12791 digests_done++;
12792
12793 salt_buf->digests_done++;
12794 }
12795
12796 salt_buf->digests_cnt++;
12797
12798 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12799
12800 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12801 {
12802 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12803 }
12804 }
12805
12806 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12807 {
12808 salt_t *salt_buf = &salts_buf_new[salt_pos];
12809
12810 if (salt_buf->digests_done == salt_buf->digests_cnt)
12811 {
12812 salts_shown[salt_pos] = 1;
12813
12814 salts_done++;
12815 }
12816
12817 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12818 }
12819
12820 local_free (digests_buf);
12821 local_free (salts_buf);
12822 local_free (esalts_buf);
12823
12824 digests_buf = digests_buf_new;
12825 salts_buf = salts_buf_new;
12826 esalts_buf = esalts_buf_new;
12827
12828 local_free (hashes_buf);
12829
12830 /**
12831 * special modification not set from parser
12832 */
12833
12834 switch (hash_mode)
12835 {
12836 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12837 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12838 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12839 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12840 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12841 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12842 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12843 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12844 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12845 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12846 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12847 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12848 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12849 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12850 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12851 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12852 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12853 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12854 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12855 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12856 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12857 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12858 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12859 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12860 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12861 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12862 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12863 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12864 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12865 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12866 }
12867
12868 if (truecrypt_keyfiles)
12869 {
12870 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12871
12872 char *keyfiles = strdup (truecrypt_keyfiles);
12873
12874 char *keyfile = strtok (keyfiles, ",");
12875
12876 do
12877 {
12878 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12879
12880 } while ((keyfile = strtok (NULL, ",")) != NULL);
12881
12882 free (keyfiles);
12883 }
12884
12885 if (veracrypt_keyfiles)
12886 {
12887 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12888
12889 char *keyfiles = strdup (veracrypt_keyfiles);
12890
12891 char *keyfile = strtok (keyfiles, ",");
12892
12893 do
12894 {
12895 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12896
12897 } while ((keyfile = strtok (NULL, ",")) != NULL);
12898
12899 free (keyfiles);
12900 }
12901
12902 data.digests_cnt = digests_cnt;
12903 data.digests_done = digests_done;
12904 data.digests_buf = digests_buf;
12905 data.digests_shown = digests_shown;
12906 data.digests_shown_tmp = digests_shown_tmp;
12907
12908 data.salts_cnt = salts_cnt;
12909 data.salts_done = salts_done;
12910 data.salts_buf = salts_buf;
12911 data.salts_shown = salts_shown;
12912
12913 data.esalts_buf = esalts_buf;
12914 data.hash_info = hash_info;
12915
12916 /**
12917 * Automatic Optimizers
12918 */
12919
12920 if (salts_cnt == 1)
12921 opti_type |= OPTI_TYPE_SINGLE_SALT;
12922
12923 if (digests_cnt == 1)
12924 opti_type |= OPTI_TYPE_SINGLE_HASH;
12925
12926 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12927 opti_type |= OPTI_TYPE_NOT_ITERATED;
12928
12929 if (attack_mode == ATTACK_MODE_BF)
12930 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12931
12932 data.opti_type = opti_type;
12933
12934 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12935 {
12936 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12937 {
12938 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12939 {
12940 if (opts_type & OPTS_TYPE_ST_ADD80)
12941 {
12942 opts_type &= ~OPTS_TYPE_ST_ADD80;
12943 opts_type |= OPTS_TYPE_PT_ADD80;
12944 }
12945
12946 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12947 {
12948 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12949 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12950 }
12951
12952 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12953 {
12954 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12955 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12956 }
12957 }
12958 }
12959 }
12960
12961 /**
12962 * Some algorithm, like descrypt, can benefit from JIT compilation
12963 */
12964
12965 int force_jit_compilation = -1;
12966
12967 if (hash_mode == 8900)
12968 {
12969 force_jit_compilation = 8900;
12970 }
12971 else if (hash_mode == 9300)
12972 {
12973 force_jit_compilation = 8900;
12974 }
12975 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12976 {
12977 force_jit_compilation = 1500;
12978 }
12979
12980 /**
12981 * generate bitmap tables
12982 */
12983
12984 const uint bitmap_shift1 = 5;
12985 const uint bitmap_shift2 = 13;
12986
12987 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12988
12989 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12990 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12991 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12992 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12993 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12994 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12995 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12996 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12997
12998 uint bitmap_bits;
12999 uint bitmap_nums;
13000 uint bitmap_mask;
13001 uint bitmap_size;
13002
13003 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13004 {
13005 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13006
13007 bitmap_nums = 1 << bitmap_bits;
13008
13009 bitmap_mask = bitmap_nums - 1;
13010
13011 bitmap_size = bitmap_nums * sizeof (uint);
13012
13013 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13014
13015 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;
13016 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;
13017
13018 break;
13019 }
13020
13021 bitmap_nums = 1 << bitmap_bits;
13022
13023 bitmap_mask = bitmap_nums - 1;
13024
13025 bitmap_size = bitmap_nums * sizeof (uint);
13026
13027 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);
13028 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);
13029
13030 /**
13031 * prepare quick rule
13032 */
13033
13034 data.rule_buf_l = rule_buf_l;
13035 data.rule_buf_r = rule_buf_r;
13036
13037 int rule_len_l = (int) strlen (rule_buf_l);
13038 int rule_len_r = (int) strlen (rule_buf_r);
13039
13040 data.rule_len_l = rule_len_l;
13041 data.rule_len_r = rule_len_r;
13042
13043 /**
13044 * load rules
13045 */
13046
13047 uint *all_kernel_rules_cnt = NULL;
13048
13049 kernel_rule_t **all_kernel_rules_buf = NULL;
13050
13051 if (rp_files_cnt)
13052 {
13053 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13054
13055 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13056 }
13057
13058 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13059
13060 int rule_len = 0;
13061
13062 for (uint i = 0; i < rp_files_cnt; i++)
13063 {
13064 uint kernel_rules_avail = 0;
13065
13066 uint kernel_rules_cnt = 0;
13067
13068 kernel_rule_t *kernel_rules_buf = NULL;
13069
13070 char *rp_file = rp_files[i];
13071
13072 char in[BLOCK_SIZE] = { 0 };
13073 char out[BLOCK_SIZE] = { 0 };
13074
13075 FILE *fp = NULL;
13076
13077 uint rule_line = 0;
13078
13079 if ((fp = fopen (rp_file, "rb")) == NULL)
13080 {
13081 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13082
13083 return (-1);
13084 }
13085
13086 while (!feof (fp))
13087 {
13088 memset (rule_buf, 0, HCBUFSIZ);
13089
13090 rule_len = fgetl (fp, rule_buf);
13091
13092 rule_line++;
13093
13094 if (rule_len == 0) continue;
13095
13096 if (rule_buf[0] == '#') continue;
13097
13098 if (kernel_rules_avail == kernel_rules_cnt)
13099 {
13100 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13101
13102 kernel_rules_avail += INCR_RULES;
13103 }
13104
13105 memset (in, 0, BLOCK_SIZE);
13106 memset (out, 0, BLOCK_SIZE);
13107
13108 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13109
13110 if (result == -1)
13111 {
13112 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13113
13114 continue;
13115 }
13116
13117 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13118 {
13119 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13120
13121 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13122
13123 continue;
13124 }
13125
13126 /* its so slow
13127 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13128 {
13129 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13130
13131 continue;
13132 }
13133 */
13134
13135 kernel_rules_cnt++;
13136 }
13137
13138 fclose (fp);
13139
13140 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13141
13142 all_kernel_rules_buf[i] = kernel_rules_buf;
13143 }
13144
13145 /**
13146 * merge rules or automatic rule generator
13147 */
13148
13149 uint kernel_rules_cnt = 0;
13150
13151 kernel_rule_t *kernel_rules_buf = NULL;
13152
13153 if (attack_mode == ATTACK_MODE_STRAIGHT)
13154 {
13155 if (rp_files_cnt)
13156 {
13157 kernel_rules_cnt = 1;
13158
13159 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13160
13161 repeats[0] = kernel_rules_cnt;
13162
13163 for (uint i = 0; i < rp_files_cnt; i++)
13164 {
13165 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13166
13167 repeats[i + 1] = kernel_rules_cnt;
13168 }
13169
13170 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13171
13172 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13173
13174 for (uint i = 0; i < kernel_rules_cnt; i++)
13175 {
13176 uint out_pos = 0;
13177
13178 kernel_rule_t *out = &kernel_rules_buf[i];
13179
13180 for (uint j = 0; j < rp_files_cnt; j++)
13181 {
13182 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13183 uint in_pos;
13184
13185 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13186
13187 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13188 {
13189 if (out_pos == RULES_MAX - 1)
13190 {
13191 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13192
13193 break;
13194 }
13195
13196 out->cmds[out_pos] = in->cmds[in_pos];
13197 }
13198 }
13199 }
13200
13201 local_free (repeats);
13202 }
13203 else if (rp_gen)
13204 {
13205 uint kernel_rules_avail = 0;
13206
13207 while (kernel_rules_cnt < rp_gen)
13208 {
13209 if (kernel_rules_avail == kernel_rules_cnt)
13210 {
13211 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13212
13213 kernel_rules_avail += INCR_RULES;
13214 }
13215
13216 memset (rule_buf, 0, HCBUFSIZ);
13217
13218 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13219
13220 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13221
13222 kernel_rules_cnt++;
13223 }
13224 }
13225 }
13226
13227 myfree (rule_buf);
13228
13229 /**
13230 * generate NOP rules
13231 */
13232
13233 if (kernel_rules_cnt == 0)
13234 {
13235 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13236
13237 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13238
13239 kernel_rules_cnt++;
13240 }
13241
13242 data.kernel_rules_cnt = kernel_rules_cnt;
13243 data.kernel_rules_buf = kernel_rules_buf;
13244
13245 /**
13246 * OpenCL platforms: detect
13247 */
13248
13249 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13250 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13251
13252 cl_uint platforms_cnt = 0;
13253 cl_uint platform_devices_cnt = 0;
13254
13255 if (keyspace == 0)
13256 {
13257 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13258
13259 if (platforms_cnt == 0)
13260 {
13261 log_info ("");
13262 log_info ("ATTENTION! No OpenCL compatible platform found");
13263 log_info ("");
13264 log_info ("You're probably missing the OpenCL runtime installation");
13265 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13266 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13267 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13268 log_info ("");
13269
13270 return (-1);
13271 }
13272
13273 if (opencl_platforms_filter != (uint) -1)
13274 {
13275 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13276
13277 if (opencl_platforms_filter > platform_cnt_mask)
13278 {
13279 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13280
13281 return (-1);
13282 }
13283 }
13284 }
13285
13286 /**
13287 * OpenCL device types:
13288 * 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.
13289 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13290 */
13291
13292 if (opencl_device_types == NULL)
13293 {
13294 cl_device_type device_types_all = 0;
13295
13296 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13297 {
13298 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13299
13300 cl_platform_id platform = platforms[platform_id];
13301
13302 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13303
13304 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13305 {
13306 cl_device_id device = platform_devices[platform_devices_id];
13307
13308 cl_device_type device_type;
13309
13310 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13311
13312 device_types_all |= device_type;
13313 }
13314 }
13315
13316 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13317 {
13318 device_types_filter |= CL_DEVICE_TYPE_CPU;
13319 }
13320 }
13321
13322 /**
13323 * OpenCL devices: simply push all devices from all platforms into the same device array
13324 */
13325
13326 int need_adl = 0;
13327 int need_nvml = 0;
13328
13329 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13330
13331 data.devices_param = devices_param;
13332
13333 uint devices_cnt = 0;
13334
13335 uint devices_active = 0;
13336
13337 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13338 {
13339 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13340
13341 cl_platform_id platform = platforms[platform_id];
13342
13343 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13344
13345 char platform_vendor[INFOSZ] = { 0 };
13346
13347 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13348
13349 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13350 // this causes trouble with vendor id based macros
13351 // we'll assign generic to those without special optimization available
13352
13353 cl_uint platform_vendor_id = 0;
13354
13355 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13356 {
13357 platform_vendor_id = VENDOR_ID_AMD;
13358 }
13359 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13360 {
13361 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13362 }
13363 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13364 {
13365 platform_vendor_id = VENDOR_ID_APPLE;
13366 }
13367 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13368 {
13369 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13370 }
13371 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13372 {
13373 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13374 }
13375 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13376 {
13377 platform_vendor_id = VENDOR_ID_MESA;
13378 }
13379 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13380 {
13381 platform_vendor_id = VENDOR_ID_NV;
13382 }
13383 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13384 {
13385 platform_vendor_id = VENDOR_ID_POCL;
13386 }
13387 else
13388 {
13389 platform_vendor_id = VENDOR_ID_GENERIC;
13390 }
13391
13392 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13393 {
13394 size_t param_value_size = 0;
13395
13396 const uint device_id = devices_cnt;
13397
13398 hc_device_param_t *device_param = &data.devices_param[device_id];
13399
13400 device_param->platform_vendor_id = platform_vendor_id;
13401
13402 device_param->device = platform_devices[platform_devices_id];
13403
13404 device_param->device_id = device_id;
13405
13406 device_param->platform_devices_id = platform_devices_id;
13407
13408 // device_type
13409
13410 cl_device_type device_type;
13411
13412 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13413
13414 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13415
13416 device_param->device_type = device_type;
13417
13418 // device_name
13419
13420 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13421
13422 char *device_name = (char *) mymalloc (param_value_size);
13423
13424 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13425
13426 device_param->device_name = device_name;
13427
13428 // device_vendor
13429
13430 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13431
13432 char *device_vendor = (char *) mymalloc (param_value_size);
13433
13434 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13435
13436 device_param->device_vendor = device_vendor;
13437
13438 cl_uint device_vendor_id = 0;
13439
13440 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13441 {
13442 device_vendor_id = VENDOR_ID_AMD;
13443 }
13444 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13445 {
13446 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13447 }
13448 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13449 {
13450 device_vendor_id = VENDOR_ID_APPLE;
13451 }
13452 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13453 {
13454 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13455 }
13456 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13457 {
13458 device_vendor_id = VENDOR_ID_INTEL_SDK;
13459 }
13460 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13461 {
13462 device_vendor_id = VENDOR_ID_MESA;
13463 }
13464 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13465 {
13466 device_vendor_id = VENDOR_ID_NV;
13467 }
13468 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13469 {
13470 device_vendor_id = VENDOR_ID_POCL;
13471 }
13472 else
13473 {
13474 device_vendor_id = VENDOR_ID_GENERIC;
13475 }
13476
13477 device_param->device_vendor_id = device_vendor_id;
13478
13479 // tuning db
13480
13481 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13482
13483 // device_version
13484
13485 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13486
13487 char *device_version = (char *) mymalloc (param_value_size);
13488
13489 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13490
13491 device_param->device_version = device_version;
13492
13493 // device_opencl_version
13494
13495 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13496
13497 char *device_opencl_version = (char *) mymalloc (param_value_size);
13498
13499 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13500
13501 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13502
13503 myfree (device_opencl_version);
13504
13505 // vector_width
13506
13507 cl_uint vector_width;
13508
13509 if (opencl_vector_width_chgd == 0)
13510 {
13511 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13512 {
13513 if (opti_type & OPTI_TYPE_USES_BITS_64)
13514 {
13515 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13516 }
13517 else
13518 {
13519 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13520 }
13521 }
13522 else
13523 {
13524 vector_width = (cl_uint) tuningdb_entry->vector_width;
13525 }
13526 }
13527 else
13528 {
13529 vector_width = opencl_vector_width;
13530 }
13531
13532 if (vector_width > 16) vector_width = 16;
13533
13534 device_param->vector_width = vector_width;
13535
13536 // max_compute_units
13537
13538 cl_uint device_processors;
13539
13540 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13541
13542 device_param->device_processors = device_processors;
13543
13544 // device_maxmem_alloc
13545 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13546
13547 cl_ulong device_maxmem_alloc;
13548
13549 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13550
13551 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13552
13553 // device_global_mem
13554
13555 cl_ulong device_global_mem;
13556
13557 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13558
13559 device_param->device_global_mem = device_global_mem;
13560
13561 // max_work_group_size
13562
13563 size_t device_maxworkgroup_size;
13564
13565 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13566
13567 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13568
13569 // max_clock_frequency
13570
13571 cl_uint device_maxclock_frequency;
13572
13573 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13574
13575 device_param->device_maxclock_frequency = device_maxclock_frequency;
13576
13577 // device_endian_little
13578
13579 cl_bool device_endian_little;
13580
13581 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13582
13583 if (device_endian_little == CL_FALSE)
13584 {
13585 if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13586
13587 device_param->skipped = 1;
13588 }
13589
13590 // device_available
13591
13592 cl_bool device_available;
13593
13594 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13595
13596 if (device_available == CL_FALSE)
13597 {
13598 if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
13599
13600 device_param->skipped = 1;
13601 }
13602
13603 // device_compiler_available
13604
13605 cl_bool device_compiler_available;
13606
13607 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13608
13609 if (device_compiler_available == CL_FALSE)
13610 {
13611 if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13612
13613 device_param->skipped = 1;
13614 }
13615
13616 // device_execution_capabilities
13617
13618 cl_device_exec_capabilities device_execution_capabilities;
13619
13620 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13621
13622 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13623 {
13624 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13625
13626 device_param->skipped = 1;
13627 }
13628
13629 // device_extensions
13630
13631 size_t device_extensions_size;
13632
13633 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13634
13635 char *device_extensions = mymalloc (device_extensions_size + 1);
13636
13637 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13638
13639 if (strstr (device_extensions, "base_atomics") == 0)
13640 {
13641 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13642
13643 device_param->skipped = 1;
13644 }
13645
13646 if (strstr (device_extensions, "byte_addressable_store") == 0)
13647 {
13648 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13649
13650 device_param->skipped = 1;
13651 }
13652
13653 myfree (device_extensions);
13654
13655 // device_local_mem_size
13656
13657 cl_ulong device_local_mem_size;
13658
13659 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13660
13661 if (device_local_mem_size < 32768)
13662 {
13663 if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13664
13665 device_param->skipped = 1;
13666 }
13667
13668 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13669 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13670 // This results in both utilizing it for 50%
13671 // However, Intel has much better SIMD control over their own hardware
13672 // It makes sense to give them full control over their own hardware
13673
13674 if (device_type & CL_DEVICE_TYPE_CPU)
13675 {
13676 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13677 {
13678 if (data.quiet == 0) log_info ("Device #%u: WARNING: not native intel opencl platform", device_id + 1);
13679
13680 device_param->skipped = 1;
13681 }
13682 }
13683
13684 // skipped
13685
13686 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13687 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13688
13689 // driver_version
13690
13691 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13692
13693 char *driver_version = (char *) mymalloc (param_value_size);
13694
13695 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13696
13697 device_param->driver_version = driver_version;
13698
13699 // device_name_chksum
13700
13701 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13702
13703 #if __x86_64__
13704 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->platform_vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13705 #else
13706 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->platform_vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13707 #endif
13708
13709 uint device_name_digest[4] = { 0 };
13710
13711 md5_64 ((uint *) device_name_chksum, device_name_digest);
13712
13713 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13714
13715 device_param->device_name_chksum = device_name_chksum;
13716
13717 // device_processor_cores
13718
13719 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
13720 {
13721 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
13722 {
13723 need_adl = 1;
13724 }
13725
13726 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
13727 {
13728 need_nvml = 1;
13729 }
13730 }
13731
13732 // device_processor_cores
13733
13734 if (device_type & CL_DEVICE_TYPE_CPU)
13735 {
13736 cl_uint device_processor_cores = 1;
13737
13738 device_param->device_processor_cores = device_processor_cores;
13739 }
13740
13741 if (device_type & CL_DEVICE_TYPE_GPU)
13742 {
13743 if (device_vendor_id == VENDOR_ID_AMD)
13744 {
13745 cl_uint device_processor_cores = 0;
13746
13747 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13748
13749 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13750
13751 device_param->device_processor_cores = device_processor_cores;
13752 }
13753 else if (device_vendor_id == VENDOR_ID_NV)
13754 {
13755 cl_uint kernel_exec_timeout = 0;
13756
13757 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13758
13759 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13760
13761 device_param->kernel_exec_timeout = kernel_exec_timeout;
13762
13763 cl_uint device_processor_cores = 0;
13764
13765 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13766
13767 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13768
13769 device_param->device_processor_cores = device_processor_cores;
13770
13771 cl_uint sm_minor = 0;
13772 cl_uint sm_major = 0;
13773
13774 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13775 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13776
13777 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13778 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13779
13780 device_param->sm_minor = sm_minor;
13781 device_param->sm_major = sm_major;
13782 }
13783 else
13784 {
13785 cl_uint device_processor_cores = 1;
13786
13787 device_param->device_processor_cores = device_processor_cores;
13788 }
13789 }
13790
13791 // display results
13792
13793 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13794 {
13795 if (machine_readable == 0)
13796 {
13797 if (device_param->skipped == 0)
13798 {
13799 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13800 device_id + 1,
13801 device_name,
13802 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13803 (unsigned int) (device_global_mem / 1024 / 1024),
13804 (unsigned int) device_processors);
13805 }
13806 else
13807 {
13808 log_info ("Device #%u: %s, skipped",
13809 device_id + 1,
13810 device_name);
13811 }
13812 }
13813 }
13814
13815 // common driver check
13816
13817 if (device_param->skipped == 0)
13818 {
13819 if (device_type & CL_DEVICE_TYPE_GPU)
13820 {
13821 if (platform_vendor_id == VENDOR_ID_AMD)
13822 {
13823 int catalyst_check = (force == 1) ? 0 : 1;
13824
13825 int catalyst_warn = 0;
13826
13827 int catalyst_broken = 0;
13828
13829 if (catalyst_check == 1)
13830 {
13831 catalyst_warn = 1;
13832
13833 // v14.9 and higher
13834 if (atoi (device_param->driver_version) >= 1573)
13835 {
13836 catalyst_warn = 0;
13837 }
13838
13839 catalyst_check = 0;
13840 }
13841
13842 if (catalyst_broken == 1)
13843 {
13844 log_info ("");
13845 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13846 log_info ("It will pass over cracked hashes and does not report them as cracked");
13847 log_info ("You are STRONGLY encouraged not to use it");
13848 log_info ("You can use --force to override this but do not post error reports if you do so");
13849 log_info ("");
13850
13851 return (-1);
13852 }
13853
13854 if (catalyst_warn == 1)
13855 {
13856 log_info ("");
13857 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13858 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13859 log_info ("See hashcat's homepage for official supported catalyst drivers");
13860 #ifdef _WIN
13861 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13862 #endif
13863 log_info ("You can use --force to override this but do not post error reports if you do so");
13864 log_info ("");
13865
13866 return (-1);
13867 }
13868 }
13869 else if (platform_vendor_id == VENDOR_ID_NV)
13870 {
13871 if (device_param->kernel_exec_timeout != 0)
13872 {
13873 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);
13874 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13875 }
13876 }
13877 }
13878
13879 /* turns out pocl still creates segfaults (because of llvm)
13880 if (device_type & CL_DEVICE_TYPE_CPU)
13881 {
13882 if (platform_vendor_id == VENDOR_ID_AMD)
13883 {
13884 if (force == 0)
13885 {
13886 log_info ("");
13887 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13888 log_info ("You are STRONGLY encouraged not to use it");
13889 log_info ("You can use --force to override this but do not post error reports if you do so");
13890 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13891 log_info ("");
13892
13893 return (-1);
13894 }
13895 }
13896 }
13897 */
13898
13899 /**
13900 * kernel accel and loops tuning db adjustment
13901 */
13902
13903 device_param->kernel_accel_min = 1;
13904 device_param->kernel_accel_max = 1024;
13905
13906 device_param->kernel_loops_min = 1;
13907 device_param->kernel_loops_max = 1024;
13908
13909 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13910
13911 if (tuningdb_entry)
13912 {
13913 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13914 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13915
13916 if (_kernel_accel)
13917 {
13918 device_param->kernel_accel_min = _kernel_accel;
13919 device_param->kernel_accel_max = _kernel_accel;
13920 }
13921
13922 if (_kernel_loops)
13923 {
13924 if (workload_profile == 1)
13925 {
13926 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13927 }
13928 else if (workload_profile == 2)
13929 {
13930 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13931 }
13932
13933 device_param->kernel_loops_min = _kernel_loops;
13934 device_param->kernel_loops_max = _kernel_loops;
13935 }
13936 }
13937
13938 // commandline parameters overwrite tuningdb entries
13939
13940 if (kernel_accel)
13941 {
13942 device_param->kernel_accel_min = kernel_accel;
13943 device_param->kernel_accel_max = kernel_accel;
13944 }
13945
13946 if (kernel_loops)
13947 {
13948 device_param->kernel_loops_min = kernel_loops;
13949 device_param->kernel_loops_max = kernel_loops;
13950 }
13951
13952 /**
13953 * activate device
13954 */
13955
13956 devices_active++;
13957 }
13958
13959 // next please
13960
13961 devices_cnt++;
13962 }
13963 }
13964
13965 if (keyspace == 0 && devices_active == 0)
13966 {
13967 log_error ("ERROR: No devices found/left");
13968
13969 return (-1);
13970 }
13971
13972 // 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)
13973
13974 if (devices_filter != (uint) -1)
13975 {
13976 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13977
13978 if (devices_filter > devices_cnt_mask)
13979 {
13980 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13981
13982 return (-1);
13983 }
13984 }
13985
13986 data.devices_cnt = devices_cnt;
13987
13988 data.devices_active = devices_active;
13989
13990 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13991 {
13992 if (machine_readable == 0)
13993 {
13994 log_info ("");
13995 }
13996 }
13997
13998 /**
13999 * HM devices: init
14000 */
14001
14002 #ifdef HAVE_HWMON
14003 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
14004 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
14005
14006 if (gpu_temp_disable == 0)
14007 {
14008 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14009 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14010
14011 data.hm_amd = NULL;
14012 data.hm_nv = NULL;
14013
14014 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14015 {
14016 data.hm_nv = nvml;
14017 }
14018
14019 if (data.hm_nv)
14020 {
14021 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
14022 {
14023 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
14024
14025 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14026
14027 int tmp_out = 0;
14028
14029 for (int i = 0; i < tmp_in; i++)
14030 {
14031 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14032 }
14033
14034 for (int i = 0; i < tmp_out; i++)
14035 {
14036 unsigned int speed;
14037
14038 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 0, hm_adapters_nv[i].adapter_index.nv, &speed) == NVML_SUCCESS) hm_adapters_nv[i].fan_get_supported = 1;
14039
14040 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14041
14042 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, NVML_GOM_ALL_ON);
14043 }
14044 }
14045 }
14046
14047 if ((need_adl == 1) && (adl_init (adl) == 0))
14048 {
14049 data.hm_amd = adl;
14050 }
14051
14052 if (data.hm_amd)
14053 {
14054 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14055 {
14056 // total number of adapters
14057
14058 int hm_adapters_num;
14059
14060 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
14061
14062 // adapter info
14063
14064 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
14065
14066 if (lpAdapterInfo == NULL) return (-1);
14067
14068 // get a list (of ids of) valid/usable adapters
14069
14070 int num_adl_adapters = 0;
14071
14072 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14073
14074 if (num_adl_adapters > 0)
14075 {
14076 hc_thread_mutex_lock (mux_adl);
14077
14078 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
14079
14080 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14081
14082 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14083 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14084
14085 hc_thread_mutex_unlock (mux_adl);
14086 }
14087
14088 myfree (valid_adl_device_list);
14089 myfree (lpAdapterInfo);
14090 }
14091 }
14092
14093 if (data.hm_amd == NULL && data.hm_nv == NULL)
14094 {
14095 gpu_temp_disable = 1;
14096 }
14097 }
14098
14099 /**
14100 * OpenCL devices: allocate buffer for device specific information
14101 */
14102
14103 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14104 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14105
14106 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14107
14108 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14109
14110 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14111
14112 /**
14113 * User-defined GPU temp handling
14114 */
14115
14116 if (gpu_temp_disable == 1)
14117 {
14118 gpu_temp_abort = 0;
14119 gpu_temp_retain = 0;
14120 }
14121
14122 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14123 {
14124 if (gpu_temp_abort < gpu_temp_retain)
14125 {
14126 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14127
14128 return (-1);
14129 }
14130 }
14131
14132 data.gpu_temp_disable = gpu_temp_disable;
14133 data.gpu_temp_abort = gpu_temp_abort;
14134 data.gpu_temp_retain = gpu_temp_retain;
14135 #endif
14136
14137 /**
14138 * enable custom signal handler(s)
14139 */
14140
14141 if (benchmark == 0)
14142 {
14143 hc_signal (sigHandler_default);
14144 }
14145 else
14146 {
14147 hc_signal (sigHandler_benchmark);
14148 }
14149
14150 /**
14151 * inform the user
14152 */
14153
14154 if (data.quiet == 0)
14155 {
14156 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14157
14158 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);
14159
14160 if (attack_mode == ATTACK_MODE_STRAIGHT)
14161 {
14162 log_info ("Rules: %u", kernel_rules_cnt);
14163 }
14164
14165 if (opti_type)
14166 {
14167 log_info ("Applicable Optimizers:");
14168
14169 for (uint i = 0; i < 32; i++)
14170 {
14171 const uint opti_bit = 1u << i;
14172
14173 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14174 }
14175 }
14176
14177 /**
14178 * Watchdog and Temperature balance
14179 */
14180
14181 #ifdef HAVE_HWMON
14182 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
14183 {
14184 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14185 }
14186
14187 if (gpu_temp_abort == 0)
14188 {
14189 log_info ("Watchdog: Temperature abort trigger disabled");
14190 }
14191 else
14192 {
14193 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14194 }
14195
14196 if (gpu_temp_retain == 0)
14197 {
14198 log_info ("Watchdog: Temperature retain trigger disabled");
14199 }
14200 else
14201 {
14202 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14203 }
14204
14205 if (data.quiet == 0) log_info ("");
14206 #endif
14207 }
14208
14209 #ifdef HAVE_HWMON
14210
14211 /**
14212 * HM devices: copy
14213 */
14214
14215 if (gpu_temp_disable == 0)
14216 {
14217 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14218 {
14219 hc_device_param_t *device_param = &data.devices_param[device_id];
14220
14221 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14222
14223 if (device_param->skipped) continue;
14224
14225 const uint platform_devices_id = device_param->platform_devices_id;
14226
14227 if (device_param->device_vendor_id == VENDOR_ID_NV)
14228 {
14229 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14230 }
14231
14232 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14233 {
14234 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14235 }
14236 }
14237 }
14238
14239 /**
14240 * powertune on user request
14241 */
14242
14243 if (powertune_enable == 1)
14244 {
14245 hc_thread_mutex_lock (mux_adl);
14246
14247 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14248 {
14249 hc_device_param_t *device_param = &data.devices_param[device_id];
14250
14251 if (device_param->skipped) continue;
14252
14253 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14254 {
14255 /**
14256 * Temporary fix:
14257 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14258 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14259 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14260 * Driver / ADL bug?
14261 */
14262
14263 if (data.hm_device[device_id].od_version == 6)
14264 {
14265 int ADL_rc;
14266
14267 // check powertune capabilities first, if not available then skip device
14268
14269 int powertune_supported = 0;
14270
14271 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14272 {
14273 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14274
14275 return (-1);
14276 }
14277
14278 // first backup current value, we will restore it later
14279
14280 if (powertune_supported != 0)
14281 {
14282 // powercontrol settings
14283
14284 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14285
14286 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14287 {
14288 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14289 }
14290
14291 if (ADL_rc != ADL_OK)
14292 {
14293 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14294
14295 return (-1);
14296 }
14297
14298 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14299 {
14300 log_error ("ERROR: Failed to set new ADL PowerControl values");
14301
14302 return (-1);
14303 }
14304
14305 // clocks
14306
14307 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14308
14309 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14310
14311 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)
14312 {
14313 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14314
14315 return (-1);
14316 }
14317
14318 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14319
14320 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14321
14322 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14323 {
14324 log_error ("ERROR: Failed to get ADL device capabilities");
14325
14326 return (-1);
14327 }
14328
14329 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14330 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14331
14332 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14333 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14334
14335 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14336 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14337
14338 // warning if profile has too low max values
14339
14340 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14341 {
14342 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14343 }
14344
14345 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14346 {
14347 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14348 }
14349
14350 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14351
14352 performance_state->iNumberOfPerformanceLevels = 2;
14353
14354 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14355 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14356 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14357 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14358
14359 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)
14360 {
14361 log_info ("ERROR: Failed to set ADL performance state");
14362
14363 return (-1);
14364 }
14365
14366 local_free (performance_state);
14367 }
14368
14369 // set powertune value only
14370
14371 if (powertune_supported != 0)
14372 {
14373 // powertune set
14374 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14375
14376 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14377 {
14378 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14379
14380 return (-1);
14381 }
14382
14383 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14384 {
14385 log_error ("ERROR: Failed to set new ADL PowerControl values");
14386
14387 return (-1);
14388 }
14389 }
14390 }
14391 }
14392
14393 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14394 {
14395 // first backup current value, we will restore it later
14396
14397 unsigned int limit;
14398
14399 int powertune_supported = 0;
14400
14401 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nv, 0, data.hm_device[device_id].adapter_index.nv, &limit) == NVML_SUCCESS)
14402 {
14403 powertune_supported = 1;
14404 }
14405
14406 // if backup worked, activate the maximum allowed
14407
14408 if (powertune_supported != 0)
14409 {
14410 unsigned int minLimit;
14411 unsigned int maxLimit;
14412
14413 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nv, 0, data.hm_device[device_id].adapter_index.nv, &minLimit, &maxLimit) == NVML_SUCCESS)
14414 {
14415 if (maxLimit > 0)
14416 {
14417 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nv, 0, data.hm_device[device_id].adapter_index.nv, maxLimit) == NVML_SUCCESS)
14418 {
14419 // now we can be sure we need to reset later
14420
14421 nvml_power_limit[device_id] = limit;
14422 }
14423 }
14424 }
14425 }
14426 }
14427 }
14428
14429 hc_thread_mutex_unlock (mux_adl);
14430 }
14431
14432 #endif // HAVE_HWMON
14433
14434 #ifdef DEBUG
14435 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14436 #endif
14437
14438 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14439
14440 uint kernel_power_all = 0;
14441
14442 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14443 {
14444 /**
14445 * host buffer
14446 */
14447
14448 hc_device_param_t *device_param = &data.devices_param[device_id];
14449
14450 if (device_param->skipped) continue;
14451
14452 /**
14453 * device properties
14454 */
14455
14456 const char *device_name_chksum = device_param->device_name_chksum;
14457 const u32 device_processors = device_param->device_processors;
14458 const u32 device_processor_cores = device_param->device_processor_cores;
14459
14460 /**
14461 * create context for each device
14462 */
14463
14464 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14465
14466 /**
14467 * create command-queue
14468 */
14469
14470 // not supported with NV
14471 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14472
14473 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14474
14475 /**
14476 * kernel threads: some algorithms need a fixed kernel-threads count
14477 * because of shared memory usage or bitslice
14478 * there needs to be some upper limit, otherwise there's too much overhead
14479 */
14480
14481 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14482
14483 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14484 {
14485 kernel_threads = KERNEL_THREADS_MAX_CPU;
14486 }
14487
14488 if (hash_mode == 1500) kernel_threads = 64; // DES
14489 if (hash_mode == 3000) kernel_threads = 64; // DES
14490 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14491 if (hash_mode == 7500) kernel_threads = 64; // RC4
14492 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14493 if (hash_mode == 9700) kernel_threads = 64; // RC4
14494 if (hash_mode == 9710) kernel_threads = 64; // RC4
14495 if (hash_mode == 9800) kernel_threads = 64; // RC4
14496 if (hash_mode == 9810) kernel_threads = 64; // RC4
14497 if (hash_mode == 10400) kernel_threads = 64; // RC4
14498 if (hash_mode == 10410) kernel_threads = 64; // RC4
14499 if (hash_mode == 10500) kernel_threads = 64; // RC4
14500 if (hash_mode == 13100) kernel_threads = 64; // RC4
14501
14502 /**
14503 * create input buffers on device : calculate size of fixed memory buffers
14504 */
14505
14506 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14507 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14508
14509 device_param->size_root_css = size_root_css;
14510 device_param->size_markov_css = size_markov_css;
14511
14512 size_t size_results = sizeof (uint);
14513
14514 device_param->size_results = size_results;
14515
14516 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14517 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14518
14519 size_t size_plains = digests_cnt * sizeof (plain_t);
14520 size_t size_salts = salts_cnt * sizeof (salt_t);
14521 size_t size_esalts = salts_cnt * esalt_size;
14522
14523 device_param->size_plains = size_plains;
14524 device_param->size_digests = size_digests;
14525 device_param->size_shown = size_shown;
14526 device_param->size_salts = size_salts;
14527
14528 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14529 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14530 size_t size_tm = 32 * sizeof (bs_word_t);
14531
14532 // scryptV stuff
14533
14534 size_t size_scryptV = 1;
14535
14536 if ((hash_mode == 8900) || (hash_mode == 9300))
14537 {
14538 uint tmto_start = 0;
14539 uint tmto_stop = 10;
14540
14541 if (scrypt_tmto)
14542 {
14543 tmto_start = scrypt_tmto;
14544 }
14545 else
14546 {
14547 // in case the user did not specify the tmto manually
14548 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14549 // but set the lower end only in case the user has a device with too less memory
14550
14551 if (hash_mode == 8900)
14552 {
14553 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14554 {
14555 tmto_start = 1;
14556 }
14557 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14558 {
14559 tmto_start = 2;
14560 }
14561 }
14562 else if (hash_mode == 9300)
14563 {
14564 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14565 {
14566 tmto_start = 2;
14567 }
14568 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14569 {
14570 tmto_start = 2;
14571 }
14572 }
14573 }
14574
14575 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14576 {
14577 // TODO: in theory the following calculation needs to be done per salt, not global
14578 // we assume all hashes have the same scrypt settings
14579
14580 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14581
14582 size_scryptV /= 1 << tmto;
14583
14584 size_scryptV *= device_processors * device_processor_cores;
14585
14586 if (size_scryptV > device_param->device_maxmem_alloc)
14587 {
14588 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14589
14590 continue;
14591 }
14592
14593 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14594 {
14595 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14596 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14597 }
14598
14599 break;
14600 }
14601
14602 if (data.salts_buf[0].scrypt_phy == 0)
14603 {
14604 log_error ("ERROR: can't allocate enough device memory");
14605
14606 return -1;
14607 }
14608
14609 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14610 }
14611
14612 /**
14613 * some algorithms need a fixed kernel-loops count
14614 */
14615
14616 if (hash_mode == 1500)
14617 {
14618 const u32 kernel_loops_fixed = 1024;
14619
14620 device_param->kernel_loops_min = kernel_loops_fixed;
14621 device_param->kernel_loops_max = kernel_loops_fixed;
14622 }
14623
14624 if (hash_mode == 3000)
14625 {
14626 const u32 kernel_loops_fixed = 1024;
14627
14628 device_param->kernel_loops_min = kernel_loops_fixed;
14629 device_param->kernel_loops_max = kernel_loops_fixed;
14630 }
14631
14632 if (hash_mode == 8900)
14633 {
14634 const u32 kernel_loops_fixed = 1;
14635
14636 device_param->kernel_loops_min = kernel_loops_fixed;
14637 device_param->kernel_loops_max = kernel_loops_fixed;
14638 }
14639
14640 if (hash_mode == 9300)
14641 {
14642 const u32 kernel_loops_fixed = 1;
14643
14644 device_param->kernel_loops_min = kernel_loops_fixed;
14645 device_param->kernel_loops_max = kernel_loops_fixed;
14646 }
14647
14648 if (hash_mode == 12500)
14649 {
14650 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14651
14652 device_param->kernel_loops_min = kernel_loops_fixed;
14653 device_param->kernel_loops_max = kernel_loops_fixed;
14654 }
14655
14656 /**
14657 * some algorithms have a maximum kernel-loops count
14658 */
14659
14660 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14661 {
14662 u32 innerloop_cnt = 0;
14663
14664 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14665 {
14666 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14667 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14668 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14669 }
14670 else
14671 {
14672 innerloop_cnt = data.salts_buf[0].salt_iter;
14673 }
14674
14675 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14676 (innerloop_cnt <= device_param->kernel_loops_max))
14677 {
14678 device_param->kernel_loops_max = innerloop_cnt;
14679 }
14680 }
14681
14682 u32 kernel_accel_min = device_param->kernel_accel_min;
14683 u32 kernel_accel_max = device_param->kernel_accel_max;
14684
14685 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14686
14687 size_t size_pws = 4;
14688 size_t size_tmps = 4;
14689 size_t size_hooks = 4;
14690
14691 while (kernel_accel_max >= kernel_accel_min)
14692 {
14693 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14694
14695 // size_pws
14696
14697 size_pws = kernel_power_max * sizeof (pw_t);
14698
14699 // size_tmps
14700
14701 switch (hash_mode)
14702 {
14703 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14704 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14705 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14706 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14707 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14708 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14709 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14710 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14711 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14712 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14713 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14714 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14715 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14716 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14717 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14718 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14719 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14720 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14721 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14722 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14723 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14724 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14725 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14726 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14727 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14728 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14729 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14730 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14731 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14732 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14733 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14734 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14735 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14736 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14737 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14738 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14739 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14740 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14741 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14742 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14743 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14744 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14745 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14746 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14747 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14748 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14749 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14750 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14751 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14752 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14753 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14754 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14755 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14756 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14757 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14758 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14759 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14760 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14761 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14762 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14763 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14764 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14765 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14766 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14767 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14768 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14769 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14770 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14771 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14772 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14773 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14774 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14775 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14776 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14777 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14778 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14779 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14780 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14781 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14782 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14783 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14784 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14785 };
14786
14787 // size_hooks
14788
14789 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14790 {
14791 // none yet
14792 }
14793
14794 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14795 // if not, decrease amplifier and try again
14796
14797 int skip = 0;
14798
14799 const u64 size_total
14800 = bitmap_size
14801 + bitmap_size
14802 + bitmap_size
14803 + bitmap_size
14804 + bitmap_size
14805 + bitmap_size
14806 + bitmap_size
14807 + bitmap_size
14808 + size_bfs
14809 + size_combs
14810 + size_digests
14811 + size_esalts
14812 + size_hooks
14813 + size_markov_css
14814 + size_plains
14815 + size_pws
14816 + size_pws // not a bug
14817 + size_results
14818 + size_root_css
14819 + size_rules
14820 + size_rules_c
14821 + size_salts
14822 + size_scryptV
14823 + size_shown
14824 + size_tm
14825 + size_tmps;
14826
14827 // Don't ask me, ask AMD!
14828
14829 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14830 if (size_total > device_param->device_global_mem) skip = 1;
14831
14832 if (skip == 1)
14833 {
14834 kernel_accel_max--;
14835
14836 continue;
14837 }
14838
14839 break;
14840 }
14841
14842 /*
14843 if (kernel_accel_max == 0)
14844 {
14845 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14846
14847 return -1;
14848 }
14849 */
14850
14851 device_param->kernel_accel_min = kernel_accel_min;
14852 device_param->kernel_accel_max = kernel_accel_max;
14853
14854 /*
14855 if (kernel_accel_max < kernel_accel)
14856 {
14857 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14858
14859 device_param->kernel_accel = kernel_accel_max;
14860 }
14861 */
14862
14863 device_param->size_bfs = size_bfs;
14864 device_param->size_combs = size_combs;
14865 device_param->size_rules = size_rules;
14866 device_param->size_rules_c = size_rules_c;
14867 device_param->size_pws = size_pws;
14868 device_param->size_tmps = size_tmps;
14869 device_param->size_hooks = size_hooks;
14870
14871 // do not confuse kernel_accel_max with kernel_accel here
14872
14873 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14874
14875 device_param->kernel_threads = kernel_threads;
14876 device_param->kernel_power_user = kernel_power;
14877
14878 kernel_power_all += kernel_power;
14879
14880 /**
14881 * default building options
14882 */
14883
14884 char build_opts[1024] = { 0 };
14885
14886 // we don't have sm_* on vendors not NV but it doesn't matter
14887
14888 #if _WIN
14889 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\\OpenCL\\\" -I '%s\\OpenCL\\' -I %s\\OpenCL\\ -I\"%s\\OpenCL\\\" -I'%s\\OpenCL\\' -I%s\\OpenCL\\", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
14890 #else
14891 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s/OpenCL/\" -I '%s/OpenCL/' -I %s/OpenCL/ -I\"%s/OpenCL/\" -I'%s/OpenCL/' -I%s/OpenCL/", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
14892 #endif
14893
14894 char build_opts_new[1024] = { 0 };
14895
14896 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
14897
14898 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14899
14900 /*
14901 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14902 {
14903 // we do vectorizing much better than the auto-vectorizer
14904
14905 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14906
14907 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14908 }
14909 */
14910
14911 #ifdef DEBUG
14912 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14913 #endif
14914
14915 /**
14916 * main kernel
14917 */
14918
14919 {
14920 /**
14921 * kernel source filename
14922 */
14923
14924 char source_file[256] = { 0 };
14925
14926 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14927
14928 struct stat sst;
14929
14930 if (stat (source_file, &sst) == -1)
14931 {
14932 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14933
14934 return -1;
14935 }
14936
14937 /**
14938 * kernel cached filename
14939 */
14940
14941 char cached_file[256] = { 0 };
14942
14943 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14944
14945 int cached = 1;
14946
14947 struct stat cst;
14948
14949 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14950 {
14951 cached = 0;
14952 }
14953
14954 /**
14955 * kernel compile or load
14956 */
14957
14958 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14959
14960 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14961
14962 if (force_jit_compilation == -1)
14963 {
14964 if (cached == 0)
14965 {
14966 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14967
14968 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14969
14970 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14971
14972 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14973
14974 #ifdef DEBUG
14975 size_t build_log_size = 0;
14976
14977 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14978
14979 if (build_log_size > 1)
14980 {
14981 char *build_log = (char *) malloc (build_log_size + 1);
14982
14983 memset (build_log, 0, build_log_size + 1);
14984
14985 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14986
14987 puts (build_log);
14988
14989 free (build_log);
14990 }
14991 #endif
14992
14993 if (rc != 0)
14994 {
14995 device_param->skipped = true;
14996
14997 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14998
14999 continue;
15000 }
15001
15002 size_t binary_size;
15003
15004 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15005
15006 u8 *binary = (u8 *) mymalloc (binary_size);
15007
15008 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15009
15010 writeProgramBin (cached_file, binary, binary_size);
15011
15012 local_free (binary);
15013 }
15014 else
15015 {
15016 #ifdef DEBUG
15017 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15018 #endif
15019
15020 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15021
15022 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15023
15024 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15025 }
15026 }
15027 else
15028 {
15029 #ifdef DEBUG
15030 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15031 #endif
15032
15033 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15034
15035 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15036
15037 char build_opts_update[1024] = { 0 };
15038
15039 if (force_jit_compilation == 1500)
15040 {
15041 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15042 }
15043 else if (force_jit_compilation == 8900)
15044 {
15045 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);
15046 }
15047 else
15048 {
15049 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15050 }
15051
15052 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15053
15054 #ifdef DEBUG
15055 size_t build_log_size = 0;
15056
15057 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15058
15059 if (build_log_size > 1)
15060 {
15061 char *build_log = (char *) malloc (build_log_size + 1);
15062
15063 memset (build_log, 0, build_log_size + 1);
15064
15065 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15066
15067 puts (build_log);
15068
15069 free (build_log);
15070 }
15071 #endif
15072
15073 if (rc != 0)
15074 {
15075 device_param->skipped = true;
15076
15077 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15078 }
15079 }
15080
15081 local_free (kernel_lengths);
15082 local_free (kernel_sources[0]);
15083 local_free (kernel_sources);
15084 }
15085
15086 /**
15087 * word generator kernel
15088 */
15089
15090 if (attack_mode != ATTACK_MODE_STRAIGHT)
15091 {
15092 /**
15093 * kernel mp source filename
15094 */
15095
15096 char source_file[256] = { 0 };
15097
15098 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15099
15100 struct stat sst;
15101
15102 if (stat (source_file, &sst) == -1)
15103 {
15104 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15105
15106 return -1;
15107 }
15108
15109 /**
15110 * kernel mp cached filename
15111 */
15112
15113 char cached_file[256] = { 0 };
15114
15115 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15116
15117 int cached = 1;
15118
15119 struct stat cst;
15120
15121 if (stat (cached_file, &cst) == -1)
15122 {
15123 cached = 0;
15124 }
15125
15126 /**
15127 * kernel compile or load
15128 */
15129
15130 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15131
15132 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15133
15134 if (cached == 0)
15135 {
15136 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15137 if (quiet == 0) log_info ("");
15138
15139 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15140
15141 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15142
15143 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15144
15145 if (rc != 0)
15146 {
15147 device_param->skipped = true;
15148
15149 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15150
15151 continue;
15152 }
15153
15154 size_t binary_size;
15155
15156 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15157
15158 u8 *binary = (u8 *) mymalloc (binary_size);
15159
15160 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15161
15162 writeProgramBin (cached_file, binary, binary_size);
15163
15164 local_free (binary);
15165 }
15166 else
15167 {
15168 #ifdef DEBUG
15169 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15170 #endif
15171
15172 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15173
15174 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15175
15176 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15177 }
15178
15179 local_free (kernel_lengths);
15180 local_free (kernel_sources[0]);
15181 local_free (kernel_sources);
15182 }
15183
15184 /**
15185 * amplifier kernel
15186 */
15187
15188 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15189 {
15190
15191 }
15192 else
15193 {
15194 /**
15195 * kernel amp source filename
15196 */
15197
15198 char source_file[256] = { 0 };
15199
15200 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15201
15202 struct stat sst;
15203
15204 if (stat (source_file, &sst) == -1)
15205 {
15206 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15207
15208 return -1;
15209 }
15210
15211 /**
15212 * kernel amp cached filename
15213 */
15214
15215 char cached_file[256] = { 0 };
15216
15217 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15218
15219 int cached = 1;
15220
15221 struct stat cst;
15222
15223 if (stat (cached_file, &cst) == -1)
15224 {
15225 cached = 0;
15226 }
15227
15228 /**
15229 * kernel compile or load
15230 */
15231
15232 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15233
15234 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15235
15236 if (cached == 0)
15237 {
15238 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15239 if (quiet == 0) log_info ("");
15240
15241 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15242
15243 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15244
15245 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15246
15247 if (rc != 0)
15248 {
15249 device_param->skipped = true;
15250
15251 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15252
15253 continue;
15254 }
15255
15256 size_t binary_size;
15257
15258 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15259
15260 u8 *binary = (u8 *) mymalloc (binary_size);
15261
15262 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15263
15264 writeProgramBin (cached_file, binary, binary_size);
15265
15266 local_free (binary);
15267 }
15268 else
15269 {
15270 #ifdef DEBUG
15271 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15272 #endif
15273
15274 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15275
15276 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15277
15278 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15279 }
15280
15281 local_free (kernel_lengths);
15282 local_free (kernel_sources[0]);
15283 local_free (kernel_sources);
15284 }
15285
15286 // some algorithm collide too fast, make that impossible
15287
15288 if (benchmark == 1)
15289 {
15290 ((uint *) digests_buf)[0] = -1;
15291 ((uint *) digests_buf)[1] = -1;
15292 ((uint *) digests_buf)[2] = -1;
15293 ((uint *) digests_buf)[3] = -1;
15294 }
15295
15296 /**
15297 * global buffers
15298 */
15299
15300 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15301 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15302 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15303 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15304 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15305 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15306 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15307 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15308 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15309 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15310 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15311 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15312 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15313 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15314 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15315 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15316 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15317 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15318
15319 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);
15320 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);
15321 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);
15322 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);
15323 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);
15324 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);
15325 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);
15326 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);
15327 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15328 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15329 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15330
15331 /**
15332 * special buffers
15333 */
15334
15335 if (attack_kern == ATTACK_KERN_STRAIGHT)
15336 {
15337 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15338 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15339
15340 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15341 }
15342 else if (attack_kern == ATTACK_KERN_COMBI)
15343 {
15344 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15345 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15346 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15347 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15348 }
15349 else if (attack_kern == ATTACK_KERN_BF)
15350 {
15351 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15352 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15353 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15354 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15355 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15356 }
15357
15358 if (size_esalts)
15359 {
15360 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15361
15362 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15363 }
15364
15365 /**
15366 * main host data
15367 */
15368
15369 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15370
15371 device_param->pws_buf = pws_buf;
15372
15373 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15374
15375 device_param->combs_buf = combs_buf;
15376
15377 void *hooks_buf = mymalloc (size_hooks);
15378
15379 device_param->hooks_buf = hooks_buf;
15380
15381 /**
15382 * kernel args
15383 */
15384
15385 device_param->kernel_params_buf32[21] = bitmap_mask;
15386 device_param->kernel_params_buf32[22] = bitmap_shift1;
15387 device_param->kernel_params_buf32[23] = bitmap_shift2;
15388 device_param->kernel_params_buf32[24] = 0; // salt_pos
15389 device_param->kernel_params_buf32[25] = 0; // loop_pos
15390 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15391 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15392 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15393 device_param->kernel_params_buf32[29] = 0; // digests_offset
15394 device_param->kernel_params_buf32[30] = 0; // combs_mode
15395 device_param->kernel_params_buf32[31] = 0; // gid_max
15396
15397 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15398 ? &device_param->d_pws_buf
15399 : &device_param->d_pws_amp_buf;
15400 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15401 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15402 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15403 device_param->kernel_params[ 4] = &device_param->d_tmps;
15404 device_param->kernel_params[ 5] = &device_param->d_hooks;
15405 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15406 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15407 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15408 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15409 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15410 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15411 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15412 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15413 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15414 device_param->kernel_params[15] = &device_param->d_digests_buf;
15415 device_param->kernel_params[16] = &device_param->d_digests_shown;
15416 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15417 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15418 device_param->kernel_params[19] = &device_param->d_result;
15419 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15420 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15421 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15422 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15423 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15424 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15425 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15426 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15427 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15428 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15429 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15430 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15431
15432 device_param->kernel_params_mp_buf64[3] = 0;
15433 device_param->kernel_params_mp_buf32[4] = 0;
15434 device_param->kernel_params_mp_buf32[5] = 0;
15435 device_param->kernel_params_mp_buf32[6] = 0;
15436 device_param->kernel_params_mp_buf32[7] = 0;
15437 device_param->kernel_params_mp_buf32[8] = 0;
15438
15439 device_param->kernel_params_mp[0] = NULL;
15440 device_param->kernel_params_mp[1] = NULL;
15441 device_param->kernel_params_mp[2] = NULL;
15442 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15443 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15444 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15445 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15446 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15447 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15448
15449 device_param->kernel_params_mp_l_buf64[3] = 0;
15450 device_param->kernel_params_mp_l_buf32[4] = 0;
15451 device_param->kernel_params_mp_l_buf32[5] = 0;
15452 device_param->kernel_params_mp_l_buf32[6] = 0;
15453 device_param->kernel_params_mp_l_buf32[7] = 0;
15454 device_param->kernel_params_mp_l_buf32[8] = 0;
15455 device_param->kernel_params_mp_l_buf32[9] = 0;
15456
15457 device_param->kernel_params_mp_l[0] = NULL;
15458 device_param->kernel_params_mp_l[1] = NULL;
15459 device_param->kernel_params_mp_l[2] = NULL;
15460 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15461 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15462 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15463 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15464 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15465 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15466 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15467
15468 device_param->kernel_params_mp_r_buf64[3] = 0;
15469 device_param->kernel_params_mp_r_buf32[4] = 0;
15470 device_param->kernel_params_mp_r_buf32[5] = 0;
15471 device_param->kernel_params_mp_r_buf32[6] = 0;
15472 device_param->kernel_params_mp_r_buf32[7] = 0;
15473 device_param->kernel_params_mp_r_buf32[8] = 0;
15474
15475 device_param->kernel_params_mp_r[0] = NULL;
15476 device_param->kernel_params_mp_r[1] = NULL;
15477 device_param->kernel_params_mp_r[2] = NULL;
15478 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15479 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15480 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15481 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15482 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15483 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15484
15485 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15486 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15487
15488 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15489 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15490 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15491 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15492 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15493 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15494 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15495
15496 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15497 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15498
15499 device_param->kernel_params_memset_buf32[1] = 0; // value
15500 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15501
15502 device_param->kernel_params_memset[0] = NULL;
15503 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15504 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15505
15506 /**
15507 * kernel name
15508 */
15509
15510 size_t kernel_wgs_tmp;
15511
15512 char kernel_name[64] = { 0 };
15513
15514 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15515 {
15516 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15517 {
15518 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15519
15520 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15521
15522 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15523
15524 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15525
15526 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15527
15528 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15529 }
15530 else
15531 {
15532 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15533
15534 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15535
15536 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15537
15538 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15539
15540 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15541
15542 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15543 }
15544
15545 if (data.attack_mode == ATTACK_MODE_BF)
15546 {
15547 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15548 {
15549 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15550
15551 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15552
15553 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);
15554 }
15555 }
15556 }
15557 else
15558 {
15559 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15560
15561 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15562
15563 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15564
15565 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15566
15567 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15568
15569 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15570
15571 if (opts_type & OPTS_TYPE_HOOK12)
15572 {
15573 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15574
15575 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15576
15577 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);
15578 }
15579
15580 if (opts_type & OPTS_TYPE_HOOK23)
15581 {
15582 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15583
15584 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15585
15586 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);
15587 }
15588 }
15589
15590 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);
15591 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);
15592 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);
15593
15594 for (uint i = 0; i <= 20; i++)
15595 {
15596 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15597 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15598 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15599
15600 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15601 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15602 }
15603
15604 for (uint i = 21; i <= 31; i++)
15605 {
15606 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15607 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15608 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15609
15610 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15611 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15612 }
15613
15614 // GPU memset
15615
15616 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15617
15618 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_memset, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15619
15620 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15621 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15622 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15623
15624 // MP start
15625
15626 if (attack_mode == ATTACK_MODE_BF)
15627 {
15628 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15629 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15630
15631 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);
15632 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);
15633
15634 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15635 {
15636 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15637 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15638 }
15639 }
15640 else if (attack_mode == ATTACK_MODE_HYBRID1)
15641 {
15642 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15643
15644 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);
15645 }
15646 else if (attack_mode == ATTACK_MODE_HYBRID2)
15647 {
15648 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15649
15650 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);
15651 }
15652
15653 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15654 {
15655 // nothing to do
15656 }
15657 else
15658 {
15659 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15660
15661 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);
15662 }
15663
15664 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15665 {
15666 // nothing to do
15667 }
15668 else
15669 {
15670 for (uint i = 0; i < 5; i++)
15671 {
15672 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15673 }
15674
15675 for (uint i = 5; i < 7; i++)
15676 {
15677 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15678 }
15679 }
15680
15681 // maybe this has been updated by clGetKernelWorkGroupInfo()
15682 // value can only be decreased, so we don't need to reallocate buffers
15683
15684 device_param->kernel_threads = kernel_threads;
15685
15686 // zero some data buffers
15687
15688 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15689 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15690 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15691 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15692 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15693 run_kernel_bzero (device_param, device_param->d_result, size_results);
15694
15695 /**
15696 * special buffers
15697 */
15698
15699 if (attack_kern == ATTACK_KERN_STRAIGHT)
15700 {
15701 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15702 }
15703 else if (attack_kern == ATTACK_KERN_COMBI)
15704 {
15705 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15706 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15707 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15708 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15709 }
15710 else if (attack_kern == ATTACK_KERN_BF)
15711 {
15712 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15713 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15714 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15715 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15716 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15717 }
15718
15719 #if defined(HAVE_HWMON)
15720
15721 /**
15722 * Store thermal target temperature so we can send a notice to user
15723 */
15724
15725 if (gpu_temp_disable == 0)
15726 {
15727 const int gpu_temp_threshold_slowdown = hm_get_threshold_slowdown_with_device_id (device_id);
15728 const int gpu_temp_threshold_shutdown = hm_get_threshold_slowdown_with_device_id (device_id);
15729
15730 data.hm_device[device_id].gpu_temp_threshold_slowdown = (gpu_temp_threshold_slowdown > 0) ? gpu_temp_threshold_slowdown : 10000;
15731 data.hm_device[device_id].gpu_temp_threshold_shutdown = (gpu_temp_threshold_shutdown > 0) ? gpu_temp_threshold_shutdown : 10000;
15732
15733 // we could use those numbers for gpu_temp_retain and gpu_temp_abort, too
15734 }
15735
15736 /**
15737 * Store initial fanspeed if gpu_temp_retain is enabled
15738 */
15739
15740 if (gpu_temp_disable == 0)
15741 {
15742 if (gpu_temp_retain != 0)
15743 {
15744 hc_thread_mutex_lock (mux_adl);
15745
15746 if (data.hm_device[device_id].fan_get_supported == 1)
15747 {
15748 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15749 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15750
15751 temp_retain_fanspeed_value[device_id] = fanspeed;
15752 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15753
15754 // we also set it to tell the OS we take control over the fan and it's automatic controller
15755 // if it was set to automatic. we do not control user-defined fanspeeds.
15756
15757 if (fanpolicy == 1)
15758 {
15759 data.hm_device[device_id].fan_set_supported = 1;
15760
15761 int rc = -1;
15762
15763 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15764 {
15765 rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 1);
15766 }
15767 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15768 {
15769
15770 }
15771
15772 if (rc == 0)
15773 {
15774 data.hm_device[device_id].fan_set_supported = 1;
15775 }
15776 else
15777 {
15778 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15779
15780 data.hm_device[device_id].fan_set_supported = 0;
15781 }
15782 }
15783 else
15784 {
15785 data.hm_device[device_id].fan_set_supported = 0;
15786 }
15787 }
15788
15789 hc_thread_mutex_unlock (mux_adl);
15790 }
15791 }
15792
15793 #endif // HAVE_HWMON
15794 }
15795
15796 data.kernel_power_all = kernel_power_all;
15797
15798 if (data.quiet == 0) log_info_nn ("");
15799
15800 /**
15801 * In benchmark-mode, inform user which algorithm is checked
15802 */
15803
15804 if (benchmark == 1)
15805 {
15806 if (machine_readable == 0)
15807 {
15808 quiet = 0;
15809
15810 data.quiet = quiet;
15811
15812 char *hash_type = strhashtype (data.hash_mode); // not a bug
15813
15814 log_info ("Hashtype: %s", hash_type);
15815 log_info ("");
15816 }
15817 }
15818
15819 /**
15820 * keep track of the progress
15821 */
15822
15823 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15824 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15825 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15826
15827 /**
15828 * open filehandles
15829 */
15830
15831 #if _WIN
15832 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15833 {
15834 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15835
15836 return (-1);
15837 }
15838
15839 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15840 {
15841 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15842
15843 return (-1);
15844 }
15845
15846 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15847 {
15848 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15849
15850 return (-1);
15851 }
15852 #endif
15853
15854 /**
15855 * dictionary pad
15856 */
15857
15858 segment_size *= (1024 * 1024);
15859
15860 data.segment_size = segment_size;
15861
15862 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15863
15864 wl_data->buf = (char *) mymalloc (segment_size);
15865 wl_data->avail = segment_size;
15866 wl_data->incr = segment_size;
15867 wl_data->cnt = 0;
15868 wl_data->pos = 0;
15869
15870 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15871
15872 data.wordlist_mode = wordlist_mode;
15873
15874 cs_t *css_buf = NULL;
15875 uint css_cnt = 0;
15876 uint dictcnt = 0;
15877 uint maskcnt = 1;
15878 char **masks = NULL;
15879 char **dictfiles = NULL;
15880
15881 uint mask_from_file = 0;
15882
15883 if (attack_mode == ATTACK_MODE_STRAIGHT)
15884 {
15885 if (wordlist_mode == WL_MODE_FILE)
15886 {
15887 int wls_left = myargc - (optind + 1);
15888
15889 for (int i = 0; i < wls_left; i++)
15890 {
15891 char *l0_filename = myargv[optind + 1 + i];
15892
15893 struct stat l0_stat;
15894
15895 if (stat (l0_filename, &l0_stat) == -1)
15896 {
15897 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15898
15899 return (-1);
15900 }
15901
15902 uint is_dir = S_ISDIR (l0_stat.st_mode);
15903
15904 if (is_dir == 0)
15905 {
15906 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15907
15908 dictcnt++;
15909
15910 dictfiles[dictcnt - 1] = l0_filename;
15911 }
15912 else
15913 {
15914 // do not allow --keyspace w/ a directory
15915
15916 if (keyspace == 1)
15917 {
15918 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15919
15920 return (-1);
15921 }
15922
15923 char **dictionary_files = NULL;
15924
15925 dictionary_files = scan_directory (l0_filename);
15926
15927 if (dictionary_files != NULL)
15928 {
15929 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15930
15931 for (int d = 0; dictionary_files[d] != NULL; d++)
15932 {
15933 char *l1_filename = dictionary_files[d];
15934
15935 struct stat l1_stat;
15936
15937 if (stat (l1_filename, &l1_stat) == -1)
15938 {
15939 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15940
15941 return (-1);
15942 }
15943
15944 if (S_ISREG (l1_stat.st_mode))
15945 {
15946 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15947
15948 dictcnt++;
15949
15950 dictfiles[dictcnt - 1] = strdup (l1_filename);
15951 }
15952 }
15953 }
15954
15955 local_free (dictionary_files);
15956 }
15957 }
15958
15959 if (dictcnt < 1)
15960 {
15961 log_error ("ERROR: No usable dictionary file found.");
15962
15963 return (-1);
15964 }
15965 }
15966 else if (wordlist_mode == WL_MODE_STDIN)
15967 {
15968 dictcnt = 1;
15969 }
15970 }
15971 else if (attack_mode == ATTACK_MODE_COMBI)
15972 {
15973 // display
15974
15975 char *dictfile1 = myargv[optind + 1 + 0];
15976 char *dictfile2 = myargv[optind + 1 + 1];
15977
15978 // find the bigger dictionary and use as base
15979
15980 FILE *fp1 = NULL;
15981 FILE *fp2 = NULL;
15982
15983 struct stat tmp_stat;
15984
15985 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15986 {
15987 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15988
15989 return (-1);
15990 }
15991
15992 if (stat (dictfile1, &tmp_stat) == -1)
15993 {
15994 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15995
15996 fclose (fp1);
15997
15998 return (-1);
15999 }
16000
16001 if (S_ISDIR (tmp_stat.st_mode))
16002 {
16003 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16004
16005 fclose (fp1);
16006
16007 return (-1);
16008 }
16009
16010 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16011 {
16012 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16013
16014 fclose (fp1);
16015
16016 return (-1);
16017 }
16018
16019 if (stat (dictfile2, &tmp_stat) == -1)
16020 {
16021 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16022
16023 fclose (fp1);
16024 fclose (fp2);
16025
16026 return (-1);
16027 }
16028
16029 if (S_ISDIR (tmp_stat.st_mode))
16030 {
16031 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16032
16033 fclose (fp1);
16034 fclose (fp2);
16035
16036 return (-1);
16037 }
16038
16039 data.combs_cnt = 1;
16040
16041 data.quiet = 1;
16042
16043 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16044
16045 data.quiet = quiet;
16046
16047 if (words1_cnt == 0)
16048 {
16049 log_error ("ERROR: %s: empty file", dictfile1);
16050
16051 fclose (fp1);
16052 fclose (fp2);
16053
16054 return (-1);
16055 }
16056
16057 data.combs_cnt = 1;
16058
16059 data.quiet = 1;
16060
16061 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16062
16063 data.quiet = quiet;
16064
16065 if (words2_cnt == 0)
16066 {
16067 log_error ("ERROR: %s: empty file", dictfile2);
16068
16069 fclose (fp1);
16070 fclose (fp2);
16071
16072 return (-1);
16073 }
16074
16075 fclose (fp1);
16076 fclose (fp2);
16077
16078 data.dictfile = dictfile1;
16079 data.dictfile2 = dictfile2;
16080
16081 if (words1_cnt >= words2_cnt)
16082 {
16083 data.combs_cnt = words2_cnt;
16084 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16085
16086 dictfiles = &data.dictfile;
16087
16088 dictcnt = 1;
16089 }
16090 else
16091 {
16092 data.combs_cnt = words1_cnt;
16093 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16094
16095 dictfiles = &data.dictfile2;
16096
16097 dictcnt = 1;
16098
16099 // we also have to switch wordlist related rules!
16100
16101 char *tmpc = data.rule_buf_l;
16102
16103 data.rule_buf_l = data.rule_buf_r;
16104 data.rule_buf_r = tmpc;
16105
16106 int tmpi = data.rule_len_l;
16107
16108 data.rule_len_l = data.rule_len_r;
16109 data.rule_len_r = tmpi;
16110 }
16111 }
16112 else if (attack_mode == ATTACK_MODE_BF)
16113 {
16114 char *mask = NULL;
16115
16116 maskcnt = 0;
16117
16118 if (benchmark == 0)
16119 {
16120 mask = myargv[optind + 1];
16121
16122 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16123
16124 if ((optind + 2) <= myargc)
16125 {
16126 struct stat file_stat;
16127
16128 if (stat (mask, &file_stat) == -1)
16129 {
16130 maskcnt = 1;
16131
16132 masks[maskcnt - 1] = mystrdup (mask);
16133 }
16134 else
16135 {
16136 int wls_left = myargc - (optind + 1);
16137
16138 uint masks_avail = INCR_MASKS;
16139
16140 for (int i = 0; i < wls_left; i++)
16141 {
16142 if (i != 0)
16143 {
16144 mask = myargv[optind + 1 + i];
16145
16146 if (stat (mask, &file_stat) == -1)
16147 {
16148 log_error ("ERROR: %s: %s", mask, strerror (errno));
16149
16150 return (-1);
16151 }
16152 }
16153
16154 uint is_file = S_ISREG (file_stat.st_mode);
16155
16156 if (is_file == 1)
16157 {
16158 FILE *mask_fp;
16159
16160 if ((mask_fp = fopen (mask, "r")) == NULL)
16161 {
16162 log_error ("ERROR: %s: %s", mask, strerror (errno));
16163
16164 return (-1);
16165 }
16166
16167 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16168
16169 while (!feof (mask_fp))
16170 {
16171 memset (line_buf, 0, HCBUFSIZ);
16172
16173 int line_len = fgetl (mask_fp, line_buf);
16174
16175 if (line_len == 0) continue;
16176
16177 if (line_buf[0] == '#') continue;
16178
16179 if (masks_avail == maskcnt)
16180 {
16181 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16182
16183 masks_avail += INCR_MASKS;
16184 }
16185
16186 masks[maskcnt] = mystrdup (line_buf);
16187
16188 maskcnt++;
16189 }
16190
16191 myfree (line_buf);
16192
16193 fclose (mask_fp);
16194 }
16195 else
16196 {
16197 log_error ("ERROR: %s: unsupported file-type", mask);
16198
16199 return (-1);
16200 }
16201 }
16202
16203 mask_from_file = 1;
16204 }
16205 }
16206 else
16207 {
16208 custom_charset_1 = (char *) "?l?d?u";
16209 custom_charset_2 = (char *) "?l?d";
16210 custom_charset_3 = (char *) "?l?d*!$@_";
16211
16212 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16213 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16214 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16215
16216 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16217
16218 wordlist_mode = WL_MODE_MASK;
16219
16220 data.wordlist_mode = wordlist_mode;
16221
16222 increment = 1;
16223
16224 maskcnt = 1;
16225 }
16226 }
16227 else
16228 {
16229 /**
16230 * generate full masks and charsets
16231 */
16232
16233 masks = (char **) mymalloc (sizeof (char *));
16234
16235 switch (hash_mode)
16236 {
16237 case 1731: pw_min = 5;
16238 pw_max = 5;
16239 mask = mystrdup ("?b?b?b?b?b");
16240 break;
16241 case 12500: pw_min = 5;
16242 pw_max = 5;
16243 mask = mystrdup ("?b?b?b?b?b");
16244 break;
16245 default: pw_min = 7;
16246 pw_max = 7;
16247 mask = mystrdup ("?b?b?b?b?b?b?b");
16248 break;
16249 }
16250
16251 maskcnt = 1;
16252
16253 masks[maskcnt - 1] = mystrdup (mask);
16254
16255 wordlist_mode = WL_MODE_MASK;
16256
16257 data.wordlist_mode = wordlist_mode;
16258
16259 increment = 1;
16260 }
16261
16262 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16263
16264 if (increment)
16265 {
16266 if (increment_min > pw_min) pw_min = increment_min;
16267
16268 if (increment_max < pw_max) pw_max = increment_max;
16269 }
16270 }
16271 else if (attack_mode == ATTACK_MODE_HYBRID1)
16272 {
16273 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16274
16275 // display
16276
16277 char *mask = myargv[myargc - 1];
16278
16279 maskcnt = 0;
16280
16281 masks = (char **) mymalloc (1 * sizeof (char *));
16282
16283 // mod
16284
16285 struct stat file_stat;
16286
16287 if (stat (mask, &file_stat) == -1)
16288 {
16289 maskcnt = 1;
16290
16291 masks[maskcnt - 1] = mystrdup (mask);
16292 }
16293 else
16294 {
16295 uint is_file = S_ISREG (file_stat.st_mode);
16296
16297 if (is_file == 1)
16298 {
16299 FILE *mask_fp;
16300
16301 if ((mask_fp = fopen (mask, "r")) == NULL)
16302 {
16303 log_error ("ERROR: %s: %s", mask, strerror (errno));
16304
16305 return (-1);
16306 }
16307
16308 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16309
16310 uint masks_avail = 1;
16311
16312 while (!feof (mask_fp))
16313 {
16314 memset (line_buf, 0, HCBUFSIZ);
16315
16316 int line_len = fgetl (mask_fp, line_buf);
16317
16318 if (line_len == 0) continue;
16319
16320 if (line_buf[0] == '#') continue;
16321
16322 if (masks_avail == maskcnt)
16323 {
16324 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16325
16326 masks_avail += INCR_MASKS;
16327 }
16328
16329 masks[maskcnt] = mystrdup (line_buf);
16330
16331 maskcnt++;
16332 }
16333
16334 myfree (line_buf);
16335
16336 fclose (mask_fp);
16337
16338 mask_from_file = 1;
16339 }
16340 else
16341 {
16342 maskcnt = 1;
16343
16344 masks[maskcnt - 1] = mystrdup (mask);
16345 }
16346 }
16347
16348 // base
16349
16350 int wls_left = myargc - (optind + 2);
16351
16352 for (int i = 0; i < wls_left; i++)
16353 {
16354 char *filename = myargv[optind + 1 + i];
16355
16356 struct stat file_stat;
16357
16358 if (stat (filename, &file_stat) == -1)
16359 {
16360 log_error ("ERROR: %s: %s", filename, strerror (errno));
16361
16362 return (-1);
16363 }
16364
16365 uint is_dir = S_ISDIR (file_stat.st_mode);
16366
16367 if (is_dir == 0)
16368 {
16369 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16370
16371 dictcnt++;
16372
16373 dictfiles[dictcnt - 1] = filename;
16374 }
16375 else
16376 {
16377 // do not allow --keyspace w/ a directory
16378
16379 if (keyspace == 1)
16380 {
16381 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16382
16383 return (-1);
16384 }
16385
16386 char **dictionary_files = NULL;
16387
16388 dictionary_files = scan_directory (filename);
16389
16390 if (dictionary_files != NULL)
16391 {
16392 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16393
16394 for (int d = 0; dictionary_files[d] != NULL; d++)
16395 {
16396 char *l1_filename = dictionary_files[d];
16397
16398 struct stat l1_stat;
16399
16400 if (stat (l1_filename, &l1_stat) == -1)
16401 {
16402 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16403
16404 return (-1);
16405 }
16406
16407 if (S_ISREG (l1_stat.st_mode))
16408 {
16409 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16410
16411 dictcnt++;
16412
16413 dictfiles[dictcnt - 1] = strdup (l1_filename);
16414 }
16415 }
16416 }
16417
16418 local_free (dictionary_files);
16419 }
16420 }
16421
16422 if (dictcnt < 1)
16423 {
16424 log_error ("ERROR: No usable dictionary file found.");
16425
16426 return (-1);
16427 }
16428
16429 if (increment)
16430 {
16431 maskcnt = 0;
16432
16433 uint mask_min = increment_min; // we can't reject smaller masks here
16434 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16435
16436 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16437 {
16438 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16439
16440 if (cur_mask == NULL) break;
16441
16442 masks[maskcnt] = cur_mask;
16443
16444 maskcnt++;
16445
16446 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16447 }
16448 }
16449 }
16450 else if (attack_mode == ATTACK_MODE_HYBRID2)
16451 {
16452 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16453
16454 // display
16455
16456 char *mask = myargv[optind + 1 + 0];
16457
16458 maskcnt = 0;
16459
16460 masks = (char **) mymalloc (1 * sizeof (char *));
16461
16462 // mod
16463
16464 struct stat file_stat;
16465
16466 if (stat (mask, &file_stat) == -1)
16467 {
16468 maskcnt = 1;
16469
16470 masks[maskcnt - 1] = mystrdup (mask);
16471 }
16472 else
16473 {
16474 uint is_file = S_ISREG (file_stat.st_mode);
16475
16476 if (is_file == 1)
16477 {
16478 FILE *mask_fp;
16479
16480 if ((mask_fp = fopen (mask, "r")) == NULL)
16481 {
16482 log_error ("ERROR: %s: %s", mask, strerror (errno));
16483
16484 return (-1);
16485 }
16486
16487 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16488
16489 uint masks_avail = 1;
16490
16491 while (!feof (mask_fp))
16492 {
16493 memset (line_buf, 0, HCBUFSIZ);
16494
16495 int line_len = fgetl (mask_fp, line_buf);
16496
16497 if (line_len == 0) continue;
16498
16499 if (line_buf[0] == '#') continue;
16500
16501 if (masks_avail == maskcnt)
16502 {
16503 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16504
16505 masks_avail += INCR_MASKS;
16506 }
16507
16508 masks[maskcnt] = mystrdup (line_buf);
16509
16510 maskcnt++;
16511 }
16512
16513 myfree (line_buf);
16514
16515 fclose (mask_fp);
16516
16517 mask_from_file = 1;
16518 }
16519 else
16520 {
16521 maskcnt = 1;
16522
16523 masks[maskcnt - 1] = mystrdup (mask);
16524 }
16525 }
16526
16527 // base
16528
16529 int wls_left = myargc - (optind + 2);
16530
16531 for (int i = 0; i < wls_left; i++)
16532 {
16533 char *filename = myargv[optind + 2 + i];
16534
16535 struct stat file_stat;
16536
16537 if (stat (filename, &file_stat) == -1)
16538 {
16539 log_error ("ERROR: %s: %s", filename, strerror (errno));
16540
16541 return (-1);
16542 }
16543
16544 uint is_dir = S_ISDIR (file_stat.st_mode);
16545
16546 if (is_dir == 0)
16547 {
16548 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16549
16550 dictcnt++;
16551
16552 dictfiles[dictcnt - 1] = filename;
16553 }
16554 else
16555 {
16556 // do not allow --keyspace w/ a directory
16557
16558 if (keyspace == 1)
16559 {
16560 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16561
16562 return (-1);
16563 }
16564
16565 char **dictionary_files = NULL;
16566
16567 dictionary_files = scan_directory (filename);
16568
16569 if (dictionary_files != NULL)
16570 {
16571 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16572
16573 for (int d = 0; dictionary_files[d] != NULL; d++)
16574 {
16575 char *l1_filename = dictionary_files[d];
16576
16577 struct stat l1_stat;
16578
16579 if (stat (l1_filename, &l1_stat) == -1)
16580 {
16581 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16582
16583 return (-1);
16584 }
16585
16586 if (S_ISREG (l1_stat.st_mode))
16587 {
16588 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16589
16590 dictcnt++;
16591
16592 dictfiles[dictcnt - 1] = strdup (l1_filename);
16593 }
16594 }
16595 }
16596
16597 local_free (dictionary_files);
16598 }
16599 }
16600
16601 if (dictcnt < 1)
16602 {
16603 log_error ("ERROR: No usable dictionary file found.");
16604
16605 return (-1);
16606 }
16607
16608 if (increment)
16609 {
16610 maskcnt = 0;
16611
16612 uint mask_min = increment_min; // we can't reject smaller masks here
16613 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16614
16615 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16616 {
16617 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16618
16619 if (cur_mask == NULL) break;
16620
16621 masks[maskcnt] = cur_mask;
16622
16623 maskcnt++;
16624
16625 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16626 }
16627 }
16628 }
16629
16630 data.pw_min = pw_min;
16631 data.pw_max = pw_max;
16632
16633 /**
16634 * weak hash check
16635 */
16636
16637 if (weak_hash_threshold >= salts_cnt)
16638 {
16639 hc_device_param_t *device_param = NULL;
16640
16641 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16642 {
16643 device_param = &data.devices_param[device_id];
16644
16645 if (device_param->skipped) continue;
16646
16647 break;
16648 }
16649
16650 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16651
16652 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16653 {
16654 weak_hash_check (device_param, salt_pos);
16655 }
16656
16657 // Display hack, guarantee that there is at least one \r before real start
16658
16659 //if (data.quiet == 0) log_info ("");
16660 }
16661
16662 /**
16663 * status and monitor threads
16664 */
16665
16666 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16667
16668 hc_thread_t i_thread = 0;
16669
16670 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16671 {
16672 hc_thread_create (i_thread, thread_keypress, &benchmark);
16673 }
16674
16675 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16676
16677 uint ni_threads_cnt = 0;
16678
16679 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16680
16681 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16682
16683 ni_threads_cnt++;
16684
16685 /**
16686 * Outfile remove
16687 */
16688
16689 if (keyspace == 0)
16690 {
16691 if (outfile_check_timer != 0)
16692 {
16693 if (data.outfile_check_directory != NULL)
16694 {
16695 if ((hash_mode != 5200) &&
16696 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16697 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16698 (hash_mode != 9000))
16699 {
16700 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16701
16702 ni_threads_cnt++;
16703 }
16704 else
16705 {
16706 outfile_check_timer = 0;
16707 }
16708 }
16709 else
16710 {
16711 outfile_check_timer = 0;
16712 }
16713 }
16714 }
16715
16716 /**
16717 * Inform the user if we got some hashes remove because of the pot file remove feature
16718 */
16719
16720 if (data.quiet == 0)
16721 {
16722 if (potfile_remove_cracks > 0)
16723 {
16724 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16725 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16726 }
16727 }
16728
16729 data.outfile_check_timer = outfile_check_timer;
16730
16731 /**
16732 * main loop
16733 */
16734
16735 char **induction_dictionaries = NULL;
16736
16737 int induction_dictionaries_cnt = 0;
16738
16739 hcstat_table_t *root_table_buf = NULL;
16740 hcstat_table_t *markov_table_buf = NULL;
16741
16742 uint initial_restore_done = 0;
16743
16744 data.maskcnt = maskcnt;
16745
16746 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16747 {
16748 if (data.devices_status == STATUS_CRACKED) break;
16749
16750 data.devices_status = STATUS_INIT;
16751
16752 if (maskpos > rd->maskpos)
16753 {
16754 rd->dictpos = 0;
16755 }
16756
16757 rd->maskpos = maskpos;
16758 data.maskpos = maskpos;
16759
16760 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16761 {
16762 char *mask = masks[maskpos];
16763
16764 if (mask_from_file == 1)
16765 {
16766 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16767
16768 char *str_ptr;
16769 uint str_pos;
16770
16771 uint mask_offset = 0;
16772
16773 uint separator_cnt;
16774
16775 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16776 {
16777 str_ptr = strstr (mask + mask_offset, ",");
16778
16779 if (str_ptr == NULL) break;
16780
16781 str_pos = str_ptr - mask;
16782
16783 // escaped separator, i.e. "\,"
16784
16785 if (str_pos > 0)
16786 {
16787 if (mask[str_pos - 1] == '\\')
16788 {
16789 separator_cnt --;
16790
16791 mask_offset = str_pos + 1;
16792
16793 continue;
16794 }
16795 }
16796
16797 // reset the offset
16798
16799 mask_offset = 0;
16800
16801 mask[str_pos] = '\0';
16802
16803 switch (separator_cnt)
16804 {
16805 case 0:
16806 mp_reset_usr (mp_usr, 0);
16807
16808 custom_charset_1 = mask;
16809 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16810 break;
16811
16812 case 1:
16813 mp_reset_usr (mp_usr, 1);
16814
16815 custom_charset_2 = mask;
16816 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16817 break;
16818
16819 case 2:
16820 mp_reset_usr (mp_usr, 2);
16821
16822 custom_charset_3 = mask;
16823 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16824 break;
16825
16826 case 3:
16827 mp_reset_usr (mp_usr, 3);
16828
16829 custom_charset_4 = mask;
16830 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16831 break;
16832 }
16833
16834 mask = mask + str_pos + 1;
16835 }
16836 }
16837
16838 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16839 {
16840 if (maskpos > 0)
16841 {
16842 local_free (css_buf);
16843 local_free (data.root_css_buf);
16844 local_free (data.markov_css_buf);
16845
16846 local_free (masks[maskpos - 1]);
16847 }
16848
16849 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16850
16851 data.mask = mask;
16852 data.css_cnt = css_cnt;
16853 data.css_buf = css_buf;
16854
16855 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16856
16857 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16858
16859 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16860 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16861
16862 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16863
16864 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16865
16866 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16867 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16868
16869 data.root_css_buf = root_css_buf;
16870 data.markov_css_buf = markov_css_buf;
16871
16872 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16873
16874 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16875
16876 local_free (root_table_buf);
16877 local_free (markov_table_buf);
16878
16879 // args
16880
16881 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16882 {
16883 hc_device_param_t *device_param = &data.devices_param[device_id];
16884
16885 if (device_param->skipped) continue;
16886
16887 device_param->kernel_params_mp[0] = &device_param->d_combs;
16888 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16889 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16890
16891 device_param->kernel_params_mp_buf64[3] = 0;
16892 device_param->kernel_params_mp_buf32[4] = css_cnt;
16893 device_param->kernel_params_mp_buf32[5] = 0;
16894 device_param->kernel_params_mp_buf32[6] = 0;
16895 device_param->kernel_params_mp_buf32[7] = 0;
16896
16897 if (attack_mode == ATTACK_MODE_HYBRID1)
16898 {
16899 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16900 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16901 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16902 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16903 }
16904 else if (attack_mode == ATTACK_MODE_HYBRID2)
16905 {
16906 device_param->kernel_params_mp_buf32[5] = 0;
16907 device_param->kernel_params_mp_buf32[6] = 0;
16908 device_param->kernel_params_mp_buf32[7] = 0;
16909 }
16910
16911 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]);
16912 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]);
16913 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]);
16914
16915 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);
16916 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);
16917 }
16918 }
16919 else if (attack_mode == ATTACK_MODE_BF)
16920 {
16921 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16922
16923 if (increment)
16924 {
16925 for (uint i = 0; i < dictcnt; i++)
16926 {
16927 local_free (dictfiles[i]);
16928 }
16929
16930 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16931 {
16932 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16933
16934 if (l1_filename == NULL) break;
16935
16936 dictcnt++;
16937
16938 dictfiles[dictcnt - 1] = l1_filename;
16939 }
16940 }
16941 else
16942 {
16943 dictcnt++;
16944
16945 dictfiles[dictcnt - 1] = mask;
16946 }
16947
16948 if (dictcnt == 0)
16949 {
16950 log_error ("ERROR: Mask is too small");
16951
16952 return (-1);
16953 }
16954 }
16955 }
16956
16957 free (induction_dictionaries);
16958
16959 // induction_dictionaries_cnt = 0; // implied
16960
16961 if (attack_mode != ATTACK_MODE_BF)
16962 {
16963 if (keyspace == 0)
16964 {
16965 induction_dictionaries = scan_directory (induction_directory);
16966
16967 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16968 }
16969 }
16970
16971 if (induction_dictionaries_cnt)
16972 {
16973 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16974 }
16975
16976 /**
16977 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16978 */
16979 if (keyspace == 1)
16980 {
16981 if ((maskcnt > 1) || (dictcnt > 1))
16982 {
16983 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16984
16985 return (-1);
16986 }
16987 }
16988
16989 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16990 {
16991 char *subid = logfile_generate_subid ();
16992
16993 data.subid = subid;
16994
16995 logfile_sub_msg ("START");
16996
16997 data.devices_status = STATUS_INIT;
16998
16999 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17000 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17001 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17002
17003 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17004
17005 data.cpt_pos = 0;
17006
17007 data.cpt_start = time (NULL);
17008
17009 data.cpt_total = 0;
17010
17011 if (data.restore == 0)
17012 {
17013 rd->words_cur = skip;
17014
17015 skip = 0;
17016
17017 data.skip = 0;
17018 }
17019
17020 data.ms_paused = 0;
17021
17022 data.words_cur = rd->words_cur;
17023
17024 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17025 {
17026 hc_device_param_t *device_param = &data.devices_param[device_id];
17027
17028 if (device_param->skipped) continue;
17029
17030 device_param->speed_pos = 0;
17031
17032 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17033 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17034
17035 device_param->exec_pos = 0;
17036
17037 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17038
17039 device_param->kernel_power = device_param->kernel_power_user;
17040
17041 device_param->outerloop_pos = 0;
17042 device_param->outerloop_left = 0;
17043 device_param->innerloop_pos = 0;
17044 device_param->innerloop_left = 0;
17045
17046 // some more resets:
17047
17048 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17049
17050 device_param->pws_cnt = 0;
17051
17052 device_param->words_off = 0;
17053 device_param->words_done = 0;
17054 }
17055
17056 data.kernel_power_div = 0;
17057
17058 // figure out some workload
17059
17060 if (attack_mode == ATTACK_MODE_STRAIGHT)
17061 {
17062 if (data.wordlist_mode == WL_MODE_FILE)
17063 {
17064 char *dictfile = NULL;
17065
17066 if (induction_dictionaries_cnt)
17067 {
17068 dictfile = induction_dictionaries[0];
17069 }
17070 else
17071 {
17072 dictfile = dictfiles[dictpos];
17073 }
17074
17075 data.dictfile = dictfile;
17076
17077 logfile_sub_string (dictfile);
17078
17079 for (uint i = 0; i < rp_files_cnt; i++)
17080 {
17081 logfile_sub_var_string ("rulefile", rp_files[i]);
17082 }
17083
17084 FILE *fd2 = fopen (dictfile, "rb");
17085
17086 if (fd2 == NULL)
17087 {
17088 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17089
17090 return (-1);
17091 }
17092
17093 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17094
17095 fclose (fd2);
17096
17097 if (data.words_cnt == 0)
17098 {
17099 if (data.devices_status == STATUS_CRACKED) break;
17100 if (data.devices_status == STATUS_ABORTED) break;
17101
17102 dictpos++;
17103
17104 continue;
17105 }
17106 }
17107 }
17108 else if (attack_mode == ATTACK_MODE_COMBI)
17109 {
17110 char *dictfile = data.dictfile;
17111 char *dictfile2 = data.dictfile2;
17112
17113 logfile_sub_string (dictfile);
17114 logfile_sub_string (dictfile2);
17115
17116 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17117 {
17118 FILE *fd2 = fopen (dictfile, "rb");
17119
17120 if (fd2 == NULL)
17121 {
17122 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17123
17124 return (-1);
17125 }
17126
17127 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17128
17129 fclose (fd2);
17130 }
17131 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17132 {
17133 FILE *fd2 = fopen (dictfile2, "rb");
17134
17135 if (fd2 == NULL)
17136 {
17137 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17138
17139 return (-1);
17140 }
17141
17142 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17143
17144 fclose (fd2);
17145 }
17146
17147 if (data.words_cnt == 0)
17148 {
17149 if (data.devices_status == STATUS_CRACKED) break;
17150 if (data.devices_status == STATUS_ABORTED) break;
17151
17152 dictpos++;
17153
17154 continue;
17155 }
17156 }
17157 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17158 {
17159 char *dictfile = NULL;
17160
17161 if (induction_dictionaries_cnt)
17162 {
17163 dictfile = induction_dictionaries[0];
17164 }
17165 else
17166 {
17167 dictfile = dictfiles[dictpos];
17168 }
17169
17170 data.dictfile = dictfile;
17171
17172 char *mask = data.mask;
17173
17174 logfile_sub_string (dictfile);
17175 logfile_sub_string (mask);
17176
17177 FILE *fd2 = fopen (dictfile, "rb");
17178
17179 if (fd2 == NULL)
17180 {
17181 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17182
17183 return (-1);
17184 }
17185
17186 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17187
17188 fclose (fd2);
17189
17190 if (data.words_cnt == 0)
17191 {
17192 if (data.devices_status == STATUS_CRACKED) break;
17193 if (data.devices_status == STATUS_ABORTED) break;
17194
17195 dictpos++;
17196
17197 continue;
17198 }
17199 }
17200 else if (attack_mode == ATTACK_MODE_BF)
17201 {
17202 local_free (css_buf);
17203 local_free (data.root_css_buf);
17204 local_free (data.markov_css_buf);
17205
17206 char *mask = dictfiles[dictpos];
17207
17208 logfile_sub_string (mask);
17209
17210 // base
17211
17212 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17213
17214 if (opts_type & OPTS_TYPE_PT_UNICODE)
17215 {
17216 uint css_cnt_unicode = css_cnt * 2;
17217
17218 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17219
17220 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17221 {
17222 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17223
17224 css_buf_unicode[j + 1].cs_buf[0] = 0;
17225 css_buf_unicode[j + 1].cs_len = 1;
17226 }
17227
17228 free (css_buf);
17229
17230 css_buf = css_buf_unicode;
17231 css_cnt = css_cnt_unicode;
17232 }
17233
17234 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17235
17236 uint mask_min = pw_min;
17237 uint mask_max = pw_max;
17238
17239 if (opts_type & OPTS_TYPE_PT_UNICODE)
17240 {
17241 mask_min *= 2;
17242 mask_max *= 2;
17243 }
17244
17245 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17246 {
17247 if (css_cnt < mask_min)
17248 {
17249 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17250 }
17251
17252 if (css_cnt > mask_max)
17253 {
17254 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17255 }
17256
17257 // skip to next mask
17258
17259 dictpos++;
17260
17261 rd->dictpos = dictpos;
17262
17263 logfile_sub_msg ("STOP");
17264
17265 continue;
17266 }
17267
17268 uint save_css_cnt = css_cnt;
17269
17270 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17271 {
17272 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17273 {
17274 uint salt_len = (uint) data.salts_buf[0].salt_len;
17275 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17276
17277 uint css_cnt_salt = css_cnt + salt_len;
17278
17279 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17280
17281 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17282
17283 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17284 {
17285 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17286 css_buf_salt[j].cs_len = 1;
17287 }
17288
17289 free (css_buf);
17290
17291 css_buf = css_buf_salt;
17292 css_cnt = css_cnt_salt;
17293 }
17294 }
17295
17296 data.mask = mask;
17297 data.css_cnt = css_cnt;
17298 data.css_buf = css_buf;
17299
17300 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17301
17302 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17303
17304 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17305
17306 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17307 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17308
17309 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17310
17311 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17312
17313 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17314 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17315
17316 data.root_css_buf = root_css_buf;
17317 data.markov_css_buf = markov_css_buf;
17318
17319 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17320
17321 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17322
17323 local_free (root_table_buf);
17324 local_free (markov_table_buf);
17325
17326 // copy + args
17327
17328 uint css_cnt_l = css_cnt;
17329 uint css_cnt_r;
17330
17331 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17332 {
17333 if (save_css_cnt < 6)
17334 {
17335 css_cnt_r = 1;
17336 }
17337 else if (save_css_cnt == 6)
17338 {
17339 css_cnt_r = 2;
17340 }
17341 else
17342 {
17343 if (opts_type & OPTS_TYPE_PT_UNICODE)
17344 {
17345 if (save_css_cnt == 8 || save_css_cnt == 10)
17346 {
17347 css_cnt_r = 2;
17348 }
17349 else
17350 {
17351 css_cnt_r = 4;
17352 }
17353 }
17354 else
17355 {
17356 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17357 {
17358 css_cnt_r = 3;
17359 }
17360 else
17361 {
17362 css_cnt_r = 4;
17363 }
17364 }
17365 }
17366 }
17367 else
17368 {
17369 css_cnt_r = 1;
17370
17371 /* unfinished code?
17372 int sum = css_buf[css_cnt_r - 1].cs_len;
17373
17374 for (uint i = 1; i < 4 && i < css_cnt; i++)
17375 {
17376 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17377
17378 css_cnt_r++;
17379
17380 sum *= css_buf[css_cnt_r - 1].cs_len;
17381 }
17382 */
17383 }
17384
17385 css_cnt_l -= css_cnt_r;
17386
17387 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17388
17389 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17390 {
17391 hc_device_param_t *device_param = &data.devices_param[device_id];
17392
17393 if (device_param->skipped) continue;
17394
17395 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17396 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17397 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17398
17399 device_param->kernel_params_mp_l_buf64[3] = 0;
17400 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17401 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17402 device_param->kernel_params_mp_l_buf32[6] = 0;
17403 device_param->kernel_params_mp_l_buf32[7] = 0;
17404 device_param->kernel_params_mp_l_buf32[8] = 0;
17405
17406 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17407 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17408 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17409 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17410
17411 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17412 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17413 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17414
17415 device_param->kernel_params_mp_r_buf64[3] = 0;
17416 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17417 device_param->kernel_params_mp_r_buf32[5] = 0;
17418 device_param->kernel_params_mp_r_buf32[6] = 0;
17419 device_param->kernel_params_mp_r_buf32[7] = 0;
17420
17421 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]);
17422 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]);
17423 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]);
17424
17425 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]);
17426 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]);
17427 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]);
17428
17429 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);
17430 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);
17431 }
17432 }
17433
17434 u64 words_base = data.words_cnt;
17435
17436 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17437 {
17438 if (data.kernel_rules_cnt)
17439 {
17440 words_base /= data.kernel_rules_cnt;
17441 }
17442 }
17443 else if (data.attack_kern == ATTACK_KERN_COMBI)
17444 {
17445 if (data.combs_cnt)
17446 {
17447 words_base /= data.combs_cnt;
17448 }
17449 }
17450 else if (data.attack_kern == ATTACK_KERN_BF)
17451 {
17452 if (data.bfs_cnt)
17453 {
17454 words_base /= data.bfs_cnt;
17455 }
17456 }
17457
17458 data.words_base = words_base;
17459
17460 if (keyspace == 1)
17461 {
17462 log_info ("%llu", (unsigned long long int) words_base);
17463
17464 return (0);
17465 }
17466
17467 if (data.words_cur > data.words_base)
17468 {
17469 log_error ("ERROR: restore value greater keyspace");
17470
17471 return (-1);
17472 }
17473
17474 if (data.words_cur)
17475 {
17476 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17477 {
17478 for (uint i = 0; i < data.salts_cnt; i++)
17479 {
17480 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17481 }
17482 }
17483 else if (data.attack_kern == ATTACK_KERN_COMBI)
17484 {
17485 for (uint i = 0; i < data.salts_cnt; i++)
17486 {
17487 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17488 }
17489 }
17490 else if (data.attack_kern == ATTACK_KERN_BF)
17491 {
17492 for (uint i = 0; i < data.salts_cnt; i++)
17493 {
17494 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17495 }
17496 }
17497 }
17498
17499 /*
17500 * Inform user about possible slow speeds
17501 */
17502
17503 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17504 {
17505 if (data.words_base < kernel_power_all)
17506 {
17507 if (quiet == 0)
17508 {
17509 log_info ("ATTENTION!");
17510 log_info (" The wordlist or mask you are using is too small.");
17511 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17512 log_info (" The cracking speed will drop.");
17513 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17514 log_info ("");
17515 }
17516 }
17517 }
17518
17519 /*
17520 * Update loopback file
17521 */
17522
17523 if (loopback == 1)
17524 {
17525 time_t now;
17526
17527 time (&now);
17528
17529 uint random_num = get_random_num (0, 9999);
17530
17531 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17532
17533 data.loopback_file = loopback_file;
17534 }
17535
17536 /*
17537 * Update dictionary statistic
17538 */
17539
17540 if (keyspace == 0)
17541 {
17542 dictstat_fp = fopen (dictstat, "wb");
17543
17544 if (dictstat_fp)
17545 {
17546 lock_file (dictstat_fp);
17547
17548 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17549
17550 fclose (dictstat_fp);
17551 }
17552 }
17553
17554 data.devices_status = STATUS_RUNNING;
17555
17556 if (initial_restore_done == 0)
17557 {
17558 if (data.restore_disable == 0) cycle_restore ();
17559
17560 initial_restore_done = 1;
17561 }
17562
17563 hc_timer_set (&data.timer_running);
17564
17565 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17566 {
17567 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17568 {
17569 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17570 if (quiet == 0) fflush (stdout);
17571 }
17572 }
17573 else if (wordlist_mode == WL_MODE_STDIN)
17574 {
17575 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17576 if (data.quiet == 0) log_info ("");
17577 }
17578
17579 time_t runtime_start;
17580
17581 time (&runtime_start);
17582
17583 data.runtime_start = runtime_start;
17584
17585 /**
17586 * create cracker threads
17587 */
17588
17589 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17590
17591 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17592 {
17593 hc_device_param_t *device_param = &devices_param[device_id];
17594
17595 if (wordlist_mode == WL_MODE_STDIN)
17596 {
17597 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17598 }
17599 else
17600 {
17601 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17602 }
17603 }
17604
17605 // wait for crack threads to exit
17606
17607 hc_thread_wait (data.devices_cnt, c_threads);
17608
17609 local_free (c_threads);
17610
17611 data.restore = 0;
17612
17613 // finalize task
17614
17615 logfile_sub_var_uint ("status-after-work", data.devices_status);
17616
17617 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17618
17619 if (data.devices_status == STATUS_CRACKED) break;
17620 if (data.devices_status == STATUS_ABORTED) break;
17621
17622 if (data.devices_status == STATUS_BYPASS)
17623 {
17624 data.devices_status = STATUS_RUNNING;
17625 }
17626
17627 if (induction_dictionaries_cnt)
17628 {
17629 unlink (induction_dictionaries[0]);
17630 }
17631
17632 free (induction_dictionaries);
17633
17634 if (attack_mode != ATTACK_MODE_BF)
17635 {
17636 induction_dictionaries = scan_directory (induction_directory);
17637
17638 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17639 }
17640
17641 if (benchmark == 0)
17642 {
17643 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17644 {
17645 if (quiet == 0) clear_prompt ();
17646
17647 if (quiet == 0) log_info ("");
17648
17649 if (status == 1)
17650 {
17651 status_display ();
17652 }
17653 else
17654 {
17655 if (quiet == 0) status_display ();
17656 }
17657
17658 if (quiet == 0) log_info ("");
17659 }
17660 }
17661
17662 if (attack_mode == ATTACK_MODE_BF)
17663 {
17664 dictpos++;
17665
17666 rd->dictpos = dictpos;
17667 }
17668 else
17669 {
17670 if (induction_dictionaries_cnt)
17671 {
17672 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17673 }
17674 else
17675 {
17676 dictpos++;
17677
17678 rd->dictpos = dictpos;
17679 }
17680 }
17681
17682 time_t runtime_stop;
17683
17684 time (&runtime_stop);
17685
17686 data.runtime_stop = runtime_stop;
17687
17688 logfile_sub_uint (runtime_start);
17689 logfile_sub_uint (runtime_stop);
17690
17691 logfile_sub_msg ("STOP");
17692
17693 global_free (subid);
17694 }
17695
17696 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17697
17698 if (data.devices_status == STATUS_CRACKED) break;
17699 if (data.devices_status == STATUS_ABORTED) break;
17700 if (data.devices_status == STATUS_QUIT) break;
17701
17702 if (data.devices_status == STATUS_BYPASS)
17703 {
17704 data.devices_status = STATUS_RUNNING;
17705 }
17706 }
17707
17708 // 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
17709
17710 if (attack_mode == ATTACK_MODE_STRAIGHT)
17711 {
17712 if (data.wordlist_mode == WL_MODE_FILE)
17713 {
17714 if (data.dictfile == NULL)
17715 {
17716 if (dictfiles != NULL)
17717 {
17718 data.dictfile = dictfiles[0];
17719
17720 hc_timer_set (&data.timer_running);
17721 }
17722 }
17723 }
17724 }
17725 // NOTE: combi is okay because it is already set beforehand
17726 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17727 {
17728 if (data.dictfile == NULL)
17729 {
17730 if (dictfiles != NULL)
17731 {
17732 hc_timer_set (&data.timer_running);
17733
17734 data.dictfile = dictfiles[0];
17735 }
17736 }
17737 }
17738 else if (attack_mode == ATTACK_MODE_BF)
17739 {
17740 if (data.mask == NULL)
17741 {
17742 hc_timer_set (&data.timer_running);
17743
17744 data.mask = masks[0];
17745 }
17746 }
17747
17748 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17749 {
17750 data.devices_status = STATUS_EXHAUSTED;
17751 }
17752
17753 // if cracked / aborted remove last induction dictionary
17754
17755 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17756 {
17757 struct stat induct_stat;
17758
17759 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17760 {
17761 unlink (induction_dictionaries[file_pos]);
17762 }
17763 }
17764
17765 // wait for non-interactive threads
17766
17767 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17768 {
17769 hc_thread_wait (1, &ni_threads[thread_idx]);
17770 }
17771
17772 local_free (ni_threads);
17773
17774 // wait for interactive threads
17775
17776 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17777 {
17778 hc_thread_wait (1, &i_thread);
17779 }
17780
17781 // we dont need restore file anymore
17782 if (data.restore_disable == 0)
17783 {
17784 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17785 {
17786 unlink (eff_restore_file);
17787 unlink (new_restore_file);
17788 }
17789 else
17790 {
17791 cycle_restore ();
17792 }
17793 }
17794
17795 // finally save left hashes
17796
17797 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17798 {
17799 save_hash ();
17800 }
17801
17802 /**
17803 * Clean up
17804 */
17805
17806 if (benchmark == 1)
17807 {
17808 status_benchmark ();
17809
17810 if (machine_readable == 0)
17811 {
17812 log_info ("");
17813 }
17814 }
17815 else
17816 {
17817 if (quiet == 0) clear_prompt ();
17818
17819 if (quiet == 0) log_info ("");
17820
17821 if (status == 1)
17822 {
17823 status_display ();
17824 }
17825 else
17826 {
17827 if (quiet == 0) status_display ();
17828 }
17829
17830 if (quiet == 0) log_info ("");
17831 }
17832
17833 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17834 {
17835 hc_device_param_t *device_param = &data.devices_param[device_id];
17836
17837 if (device_param->skipped) continue;
17838
17839 local_free (device_param->combs_buf);
17840
17841 local_free (device_param->hooks_buf);
17842
17843 local_free (device_param->device_name);
17844
17845 local_free (device_param->device_name_chksum);
17846
17847 local_free (device_param->device_version);
17848
17849 local_free (device_param->driver_version);
17850
17851 if (device_param->pws_buf) myfree (device_param->pws_buf);
17852 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17853 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17854 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17855 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17856 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17857 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17858 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17859 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17860 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17861 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17862 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17863 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17864 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17865 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17866 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17867 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17868 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17869 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17870 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17871 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17872 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17873 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17874 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17875 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17876 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17877 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17878 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17879 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17880
17881 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17882 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17883 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17884 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17885 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17886 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17887 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17888 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17889 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17890 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17891 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17892
17893 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17894 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17895 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17896
17897 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17898 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17899 }
17900
17901 // reset default fan speed
17902
17903 #ifdef HAVE_HWMON
17904 if (gpu_temp_disable == 0)
17905 {
17906 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17907 {
17908 hc_thread_mutex_lock (mux_adl);
17909
17910 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17911 {
17912 hc_device_param_t *device_param = &data.devices_param[device_id];
17913
17914 if (device_param->skipped) continue;
17915
17916 if (data.hm_device[device_id].fan_set_supported == 1)
17917 {
17918 int fanspeed = temp_retain_fanspeed_value[device_id];
17919 int fanpolicy = temp_retain_fanpolicy_value[device_id];
17920
17921 if (fanpolicy == 1)
17922 {
17923 int rc = -1;
17924
17925 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17926 {
17927 rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 0);
17928 }
17929 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17930 {
17931
17932 }
17933
17934 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
17935 }
17936 }
17937 }
17938
17939 hc_thread_mutex_unlock (mux_adl);
17940 }
17941 }
17942
17943 // reset power tuning
17944
17945 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17946 {
17947 hc_thread_mutex_lock (mux_adl);
17948
17949 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17950 {
17951 hc_device_param_t *device_param = &data.devices_param[device_id];
17952
17953 if (device_param->skipped) continue;
17954
17955 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
17956 {
17957 if (data.hm_device[device_id].od_version == 6)
17958 {
17959 // check powertune capabilities first, if not available then skip device
17960
17961 int powertune_supported = 0;
17962
17963 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17964 {
17965 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17966
17967 return (-1);
17968 }
17969
17970 if (powertune_supported != 0)
17971 {
17972 // powercontrol settings
17973
17974 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)
17975 {
17976 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17977
17978 return (-1);
17979 }
17980
17981 // clocks
17982
17983 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17984
17985 performance_state->iNumberOfPerformanceLevels = 2;
17986
17987 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17988 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17989 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17990 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17991
17992 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)
17993 {
17994 log_info ("ERROR: Failed to restore ADL performance state");
17995
17996 return (-1);
17997 }
17998
17999 local_free (performance_state);
18000 }
18001 }
18002 }
18003
18004 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18005 {
18006 unsigned int limit = nvml_power_limit[device_id];
18007
18008 if (limit > 0)
18009 {
18010 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nv, 0, data.hm_device[device_id].adapter_index.nv, limit);
18011 }
18012 }
18013 }
18014
18015 hc_thread_mutex_unlock (mux_adl);
18016 }
18017
18018 if (gpu_temp_disable == 0)
18019 {
18020 if (data.hm_nv)
18021 {
18022 hm_NVML_nvmlShutdown (data.hm_nv);
18023
18024 nvml_close (data.hm_nv);
18025
18026 data.hm_nv = NULL;
18027 }
18028
18029 if (data.hm_amd)
18030 {
18031 hm_ADL_Main_Control_Destroy (data.hm_amd);
18032
18033 adl_close (data.hm_amd);
18034
18035 data.hm_amd = NULL;
18036 }
18037 }
18038 #endif // HAVE_HWMON
18039
18040 // free memory
18041
18042 local_free (masks);
18043
18044 local_free (dictstat_base);
18045
18046 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18047 {
18048 pot_t *pot_ptr = &pot[pot_pos];
18049
18050 hash_t *hash = &pot_ptr->hash;
18051
18052 local_free (hash->digest);
18053
18054 if (isSalted)
18055 {
18056 local_free (hash->salt);
18057 }
18058 }
18059
18060 local_free (pot);
18061
18062 local_free (all_kernel_rules_cnt);
18063 local_free (all_kernel_rules_buf);
18064
18065 local_free (wl_data->buf);
18066 local_free (wl_data);
18067
18068 local_free (bitmap_s1_a);
18069 local_free (bitmap_s1_b);
18070 local_free (bitmap_s1_c);
18071 local_free (bitmap_s1_d);
18072 local_free (bitmap_s2_a);
18073 local_free (bitmap_s2_b);
18074 local_free (bitmap_s2_c);
18075 local_free (bitmap_s2_d);
18076
18077 #ifdef HAVE_HWMON
18078 local_free (temp_retain_fanspeed_value);
18079 local_free (od_clock_mem_status);
18080 local_free (od_power_control_status);
18081 local_free (nvml_power_limit);
18082 #endif
18083
18084 global_free (devices_param);
18085
18086 global_free (kernel_rules_buf);
18087
18088 global_free (root_css_buf);
18089 global_free (markov_css_buf);
18090
18091 global_free (digests_buf);
18092 global_free (digests_shown);
18093 global_free (digests_shown_tmp);
18094
18095 global_free (salts_buf);
18096 global_free (salts_shown);
18097
18098 global_free (esalts_buf);
18099
18100 global_free (words_progress_done);
18101 global_free (words_progress_rejected);
18102 global_free (words_progress_restored);
18103
18104 if (pot_fp) fclose (pot_fp);
18105
18106 if (data.devices_status == STATUS_QUIT) break;
18107 }
18108
18109 // destroy others mutex
18110
18111 hc_thread_mutex_delete (mux_dispatcher);
18112 hc_thread_mutex_delete (mux_counter);
18113 hc_thread_mutex_delete (mux_display);
18114 hc_thread_mutex_delete (mux_adl);
18115
18116 // free memory
18117
18118 local_free (eff_restore_file);
18119 local_free (new_restore_file);
18120
18121 local_free (rd);
18122
18123 // tuning db
18124
18125 tuning_db_destroy (tuning_db);
18126
18127 // loopback
18128
18129 local_free (loopback_file);
18130
18131 if (loopback == 1) unlink (loopback_file);
18132
18133 // induction directory
18134
18135 if (induction_dir == NULL)
18136 {
18137 if (attack_mode != ATTACK_MODE_BF)
18138 {
18139 if (rmdir (induction_directory) == -1)
18140 {
18141 if (errno == ENOENT)
18142 {
18143 // good, we can ignore
18144 }
18145 else if (errno == ENOTEMPTY)
18146 {
18147 // good, we can ignore
18148 }
18149 else
18150 {
18151 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18152
18153 return (-1);
18154 }
18155 }
18156
18157 local_free (induction_directory);
18158 }
18159 }
18160
18161 // outfile-check directory
18162
18163 if (outfile_check_dir == NULL)
18164 {
18165 if (rmdir (outfile_check_directory) == -1)
18166 {
18167 if (errno == ENOENT)
18168 {
18169 // good, we can ignore
18170 }
18171 else if (errno == ENOTEMPTY)
18172 {
18173 // good, we can ignore
18174 }
18175 else
18176 {
18177 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18178
18179 return (-1);
18180 }
18181 }
18182
18183 local_free (outfile_check_directory);
18184 }
18185
18186 time_t proc_stop;
18187
18188 time (&proc_stop);
18189
18190 logfile_top_uint (proc_start);
18191 logfile_top_uint (proc_stop);
18192
18193 logfile_top_msg ("STOP");
18194
18195 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18196 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18197
18198 if (data.ocl) ocl_close (data.ocl);
18199
18200 if (data.devices_status == STATUS_ABORTED) return 2;
18201 if (data.devices_status == STATUS_QUIT) return 2;
18202 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18203 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18204 if (data.devices_status == STATUS_CRACKED) return 0;
18205
18206 return -1;
18207 }
Hashcat additions to support pwdhash