projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fixed DES kernel_loops only in case of BF
[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 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
168 #define HC_API_CALL __stdcall
169 #else
170 #define HC_API_CALL
171 #endif
172
173 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
174 {
175 900,
176 0,
177 5100,
178 100,
179 1400,
180 10800,
181 1700,
182 5000,
183 10100,
184 6000,
185 6100,
186 6900,
187 11700,
188 11800,
189 400,
190 8900,
191 11900,
192 12000,
193 10900,
194 12100,
195 23,
196 2500,
197 5300,
198 5400,
199 5500,
200 5600,
201 7300,
202 7500,
203 13100,
204 8300,
205 11100,
206 11200,
207 11400,
208 121,
209 2611,
210 2711,
211 2811,
212 8400,
213 11,
214 2612,
215 7900,
216 21,
217 11000,
218 124,
219 10000,
220 3711,
221 7600,
222 12,
223 131,
224 132,
225 1731,
226 200,
227 300,
228 3100,
229 112,
230 12300,
231 8000,
232 141,
233 1441,
234 1600,
235 12600,
236 1421,
237 101,
238 111,
239 1711,
240 3000,
241 1000,
242 1100,
243 2100,
244 12800,
245 1500,
246 12400,
247 500,
248 3200,
249 7400,
250 1800,
251 122,
252 1722,
253 7100,
254 6300,
255 6700,
256 6400,
257 6500,
258 2400,
259 2410,
260 5700,
261 9200,
262 9300,
263 22,
264 501,
265 5800,
266 8100,
267 8500,
268 7200,
269 9900,
270 7700,
271 7800,
272 10300,
273 8600,
274 8700,
275 9100,
276 133,
277 13500,
278 11600,
279 13600,
280 12500,
281 13000,
282 13200,
283 13300,
284 6211,
285 6221,
286 6231,
287 6241,
288 13711,
289 13721,
290 13731,
291 13741,
292 13751,
293 13761,
294 8800,
295 12900,
296 12200,
297 9700,
298 9710,
299 9800,
300 9810,
301 9400,
302 9500,
303 9600,
304 10400,
305 10410,
306 10500,
307 10600,
308 10700,
309 9000,
310 5200,
311 6800,
312 6600,
313 8200,
314 11300,
315 12700,
316 13400,
317 125
318 };
319
320 /**
321 * types
322 */
323
324 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
325
326 /**
327 * globals
328 */
329
330 static unsigned int full01 = 0x01010101;
331 static unsigned int full80 = 0x80808080;
332
333 int SUPPRESS_OUTPUT = 0;
334
335 hc_thread_mutex_t mux_adl;
336 hc_thread_mutex_t mux_counter;
337 hc_thread_mutex_t mux_dispatcher;
338 hc_thread_mutex_t mux_display;
339
340 hc_global_data_t data;
341
342 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
343
344 const char *USAGE_MINI[] =
345 {
346 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
347 "",
348 "Try --help for more help.",
349 NULL
350 };
351
352 const char *USAGE_BIG[] =
353 {
354 "%s, advanced password recovery",
355 "",
356 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
357 "",
358 "- [ Options ] -",
359 "",
360 " Options Short / Long | Type | Description | Example",
361 "===============================|======|======================================================|=======================",
362 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
363 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
364 " -V, --version | | Print version |",
365 " -h, --help | | Print help |",
366 " --quiet | | Suppress output |",
367 " --hex-charset | | Assume charset is given in hex |",
368 " --hex-salt | | Assume salt is given in hex |",
369 " --hex-wordlist | | Assume words in wordlist is given in hex |",
370 " --force | | Ignore warnings |",
371 " --status | | Enable automatic update of the status-screen |",
372 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
373 " --machine-readable | | Display the status view in a machine readable format |",
374 " --loopback | | Add new plains to induct directory |",
375 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
376 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
377 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
378 " --markov-classic | | Enables classic markov-chains, no per-position |",
379 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
380 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
381 " --session | Str | Define specific session name | --session=mysession",
382 " --restore | | Restore session from --session |",
383 " --restore-disable | | Do not write restore file |",
384 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
385 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
386 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
387 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
388 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
389 " --show | | Show cracked passwords only |",
390 " --left | | Show un-cracked passwords only |",
391 " --username | | Enable ignoring of usernames in hashfile |",
392 " --remove | | Enable remove of hash once it is cracked |",
393 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
394 " --potfile-disable | | Do not write potfile |",
395 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
396 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
397 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
398 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
399 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
400 " --logfile-disable | | Disable the logfile |",
401 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
402 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
403 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
404 " -b, --benchmark | | Run benchmark |",
405 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
406 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
407 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
408 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
409 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
410 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
411 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
412 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
413 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
414 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
415 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
416 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
417 #ifdef HAVE_HWMON
418 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
419 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
420 " --powertune-enable | | Enable power tuning, restores settings when finished |",
421 #endif
422 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
423 " -s, --skip | Num | Skip X words from the start | -s 1000000",
424 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
425 " --keyspace | | Show keyspace base:mod values and quit |",
426 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
427 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
428 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
429 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
430 " --generate-rules-func-min | Num | Force min X funcs per rule |",
431 " --generate-rules-func-max | Num | Force max X funcs per rule |",
432 " --generate-rules-seed | Num | Force RNG seed set to X |",
433 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
434 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
435 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
436 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
437 " -i, --increment | | Enable mask increment mode |",
438 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
439 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
440 "",
441 "- [ Hash modes ] -",
442 "",
443 " # | Name | Category",
444 " ======+==================================================+======================================",
445 " 900 | MD4 | Raw Hash",
446 " 0 | MD5 | Raw Hash",
447 " 5100 | Half MD5 | Raw Hash",
448 " 100 | SHA1 | Raw Hash",
449 " 10800 | SHA-384 | Raw Hash",
450 " 1400 | SHA-256 | Raw Hash",
451 " 1700 | SHA-512 | Raw Hash",
452 " 5000 | SHA-3(Keccak) | Raw Hash",
453 " 10100 | SipHash | Raw Hash",
454 " 6000 | RipeMD160 | Raw Hash",
455 " 6100 | Whirlpool | Raw Hash",
456 " 6900 | GOST R 34.11-94 | Raw Hash",
457 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
458 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
459 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
460 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
461 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
462 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
463 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
464 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
465 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
466 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
467 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
468 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
469 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
470 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
471 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
472 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
473 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
474 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
476 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
477 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
478 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
479 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
480 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
481 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
482 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
483 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
484 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
485 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
486 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
487 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
488 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
489 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
490 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
491 " 400 | phpass | Generic KDF",
492 " 8900 | scrypt | Generic KDF",
493 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
494 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
495 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
496 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
497 " 23 | Skype | Network protocols",
498 " 2500 | WPA/WPA2 | Network protocols",
499 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
500 " 5300 | IKE-PSK MD5 | Network protocols",
501 " 5400 | IKE-PSK SHA1 | Network protocols",
502 " 5500 | NetNTLMv1 | Network protocols",
503 " 5500 | NetNTLMv1 + ESS | Network protocols",
504 " 5600 | NetNTLMv2 | Network protocols",
505 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
506 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
507 " 8300 | DNSSEC (NSEC3) | Network protocols",
508 " 10200 | Cram MD5 | Network protocols",
509 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
510 " 11200 | MySQL CRAM (SHA1) | Network protocols",
511 " 11400 | SIP digest authentication (MD5) | Network protocols",
512 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
513 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
514 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
515 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
516 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
517 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
518 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
519 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
520 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
521 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
522 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
523 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
524 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
525 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
526 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
527 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
528 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
529 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
530 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
531 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
532 " 12 | PostgreSQL | Database Server",
533 " 131 | MSSQL(2000) | Database Server",
534 " 132 | MSSQL(2005) | Database Server",
535 " 1731 | MSSQL(2012) | Database Server",
536 " 1731 | MSSQL(2014) | Database Server",
537 " 200 | MySQL323 | Database Server",
538 " 300 | MySQL4.1/MySQL5 | Database Server",
539 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
540 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
541 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
542 " 8000 | Sybase ASE | Database Server",
543 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
544 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
545 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
546 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
547 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
548 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
549 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
550 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
551 " 11500 | CRC32 | Checksums",
552 " 3000 | LM | Operating-Systems",
553 " 1000 | NTLM | Operating-Systems",
554 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
555 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
556 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
557 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
558 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
559 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
560 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
561 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
562 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
563 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
564 " 1722 | OSX v10.7 | Operating-Systems",
565 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
566 " 6300 | AIX {smd5} | Operating-Systems",
567 " 6700 | AIX {ssha1} | Operating-Systems",
568 " 6400 | AIX {ssha256} | Operating-Systems",
569 " 6500 | AIX {ssha512} | Operating-Systems",
570 " 2400 | Cisco-PIX | Operating-Systems",
571 " 2410 | Cisco-ASA | Operating-Systems",
572 " 500 | Cisco-IOS $1$ | Operating-Systems",
573 " 5700 | Cisco-IOS $4$ | Operating-Systems",
574 " 9200 | Cisco-IOS $8$ | Operating-Systems",
575 " 9300 | Cisco-IOS $9$ | Operating-Systems",
576 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
577 " 501 | Juniper IVE | Operating-Systems",
578 " 5800 | Android PIN | Operating-Systems",
579 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
580 " 8100 | Citrix Netscaler | Operating-Systems",
581 " 8500 | RACF | Operating-Systems",
582 " 7200 | GRUB 2 | Operating-Systems",
583 " 9900 | Radmin2 | Operating-Systems",
584 " 125 | ArubaOS | Operating-Systems",
585 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
586 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
587 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
588 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
589 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
590 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
591 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
592 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
593 " 11600 | 7-Zip | Archives",
594 " 12500 | RAR3-hp | Archives",
595 " 13000 | RAR5 | Archives",
596 " 13200 | AxCrypt | Archives",
597 " 13300 | AxCrypt in memory SHA1 | Archives",
598 " 13600 | WinZip | Archives",
599 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
600 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
601 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
602 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
603 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
604 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
605 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
606 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
607 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
608 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
609 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
610 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
612 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
613 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
614 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
615 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
616 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
617 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
618 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
619 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
620 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
621 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
622 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
623 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
624 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
625 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
626 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
627 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
628 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
629 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
630 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
632 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
633 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
634 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
635 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
636 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
637 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
638 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
639 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
640 " 9400 | MS Office 2007 | Documents",
641 " 9500 | MS Office 2010 | Documents",
642 " 9600 | MS Office 2013 | Documents",
643 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
644 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
645 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
646 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
647 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
648 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
649 " 9000 | Password Safe v2 | Password Managers",
650 " 5200 | Password Safe v3 | Password Managers",
651 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
652 " 6600 | 1Password, agilekeychain | Password Managers",
653 " 8200 | 1Password, cloudkeychain | Password Managers",
654 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
655 " 12700 | Blockchain, My Wallet | Password Managers",
656 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
657 "",
658 "- [ Outfile Formats ] -",
659 "",
660 " # | Format",
661 " ===+========",
662 " 1 | hash[:salt]",
663 " 2 | plain",
664 " 3 | hash[:salt]:plain",
665 " 4 | hex_plain",
666 " 5 | hash[:salt]:hex_plain",
667 " 6 | plain:hex_plain",
668 " 7 | hash[:salt]:plain:hex_plain",
669 " 8 | crackpos",
670 " 9 | hash[:salt]:crack_pos",
671 " 10 | plain:crack_pos",
672 " 11 | hash[:salt]:plain:crack_pos",
673 " 12 | hex_plain:crack_pos",
674 " 13 | hash[:salt]:hex_plain:crack_pos",
675 " 14 | plain:hex_plain:crack_pos",
676 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
677 "",
678 "- [ Rule Debugging Modes ] -",
679 "",
680 " # | Format",
681 " ===+========",
682 " 1 | Finding-Rule",
683 " 2 | Original-Word",
684 " 3 | Original-Word:Finding-Rule",
685 " 4 | Original-Word:Finding-Rule:Processed-Word",
686 "",
687 "- [ Attack Modes ] -",
688 "",
689 " # | Mode",
690 " ===+======",
691 " 0 | Straight",
692 " 1 | Combination",
693 " 3 | Brute-force",
694 " 6 | Hybrid Wordlist + Mask",
695 " 7 | Hybrid Mask + Wordlist",
696 "",
697 "- [ Built-in Charsets ] -",
698 "",
699 " ? | Charset",
700 " ===+=========",
701 " l | abcdefghijklmnopqrstuvwxyz",
702 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
703 " d | 0123456789",
704 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
705 " a | ?l?u?d?s",
706 " b | 0x00 - 0xff",
707 "",
708 "- [ OpenCL Device Types ] -",
709 "",
710 " # | Device Type",
711 " ===+=============",
712 " 1 | CPU",
713 " 2 | GPU",
714 " 3 | FPGA, DSP, Co-Processor",
715 "",
716 "- [ Workload Profiles ] -",
717 "",
718 " # | Performance | Runtime | Power Consumption | Desktop Impact",
719 " ===+=============+=========+===================+=================",
720 " 1 | Low | 2 ms | Low | Minimal",
721 " 2 | Default | 12 ms | Economic | Noticeable",
722 " 3 | High | 96 ms | High | Unresponsive",
723 " 4 | Nightmare | 480 ms | Insane | Headless",
724 "",
725 "If you have no idea what just happened then visit the following pages:",
726 "",
727 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
728 "* https://hashcat.net/wiki/#frequently_asked_questions",
729 "",
730 NULL
731 };
732
733 /**
734 * hashcat specific functions
735 */
736
737 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
738 {
739 int exec_pos = (int) device_param->exec_pos - last_num_entries;
740
741 if (exec_pos < 0) exec_pos += EXEC_CACHE;
742
743 double exec_ms_sum = 0;
744
745 int exec_ms_cnt = 0;
746
747 for (int i = 0; i < last_num_entries; i++)
748 {
749 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
750
751 if (exec_ms)
752 {
753 exec_ms_sum += exec_ms;
754
755 exec_ms_cnt++;
756 }
757 }
758
759 if (exec_ms_cnt == 0) return 0;
760
761 return exec_ms_sum / exec_ms_cnt;
762 }
763
764 void status_display_machine_readable ()
765 {
766 FILE *out = stdout;
767
768 fprintf (out, "STATUS\t%u\t", data.devices_status);
769
770 /**
771 * speed new
772 */
773
774 fprintf (out, "SPEED\t");
775
776 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
777 {
778 hc_device_param_t *device_param = &data.devices_param[device_id];
779
780 if (device_param->skipped) continue;
781
782 u64 speed_cnt = 0;
783 double speed_ms = 0;
784
785 for (int i = 0; i < SPEED_CACHE; i++)
786 {
787 speed_cnt += device_param->speed_cnt[i];
788 speed_ms += device_param->speed_ms[i];
789 }
790
791 speed_cnt /= SPEED_CACHE;
792 speed_ms /= SPEED_CACHE;
793
794 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
795 }
796
797 /**
798 * exec time
799 */
800
801 fprintf (out, "EXEC_RUNTIME\t");
802
803 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
804 {
805 hc_device_param_t *device_param = &data.devices_param[device_id];
806
807 if (device_param->skipped) continue;
808
809 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
810
811 fprintf (out, "%f\t", exec_ms_avg);
812 }
813
814 /**
815 * words_cur
816 */
817
818 u64 words_cur = get_lowest_words_done ();
819
820 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
821
822 /**
823 * counter
824 */
825
826 u64 progress_total = data.words_cnt * data.salts_cnt;
827
828 u64 all_done = 0;
829 u64 all_rejected = 0;
830 u64 all_restored = 0;
831
832 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
833 {
834 all_done += data.words_progress_done[salt_pos];
835 all_rejected += data.words_progress_rejected[salt_pos];
836 all_restored += data.words_progress_restored[salt_pos];
837 }
838
839 u64 progress_cur = all_restored + all_done + all_rejected;
840 u64 progress_end = progress_total;
841
842 u64 progress_skip = 0;
843
844 if (data.skip)
845 {
846 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
847
848 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
849 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
850 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
851 }
852
853 if (data.limit)
854 {
855 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
856
857 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
858 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
859 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
860 }
861
862 u64 progress_cur_relative_skip = progress_cur - progress_skip;
863 u64 progress_end_relative_skip = progress_end - progress_skip;
864
865 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
866
867 /**
868 * cracks
869 */
870
871 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
872 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
873
874 /**
875 * temperature
876 */
877
878 #ifdef HAVE_HWMON
879 if (data.gpu_temp_disable == 0)
880 {
881 fprintf (out, "TEMP\t");
882
883 hc_thread_mutex_lock (mux_adl);
884
885 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
886 {
887 hc_device_param_t *device_param = &data.devices_param[device_id];
888
889 if (device_param->skipped) continue;
890
891 int temp = hm_get_temperature_with_device_id (device_id);
892
893 fprintf (out, "%d\t", temp);
894 }
895
896 hc_thread_mutex_unlock (mux_adl);
897 }
898 #endif // HAVE_HWMON
899
900 /**
901 * flush
902 */
903
904 #ifdef _WIN
905 fputc ('\r', out);
906 fputc ('\n', out);
907 #endif
908
909 #ifdef _POSIX
910 fputc ('\n', out);
911 #endif
912
913 fflush (out);
914 }
915
916 void status_display ()
917 {
918 if (data.devices_status == STATUS_INIT) return;
919 if (data.devices_status == STATUS_STARTING) return;
920 if (data.devices_status == STATUS_BYPASS) return;
921
922 if (data.machine_readable == 1)
923 {
924 status_display_machine_readable ();
925
926 return;
927 }
928
929 char tmp_buf[1000] = { 0 };
930
931 uint tmp_len = 0;
932
933 log_info ("Session.Name...: %s", data.session);
934
935 char *status_type = strstatus (data.devices_status);
936
937 uint hash_mode = data.hash_mode;
938
939 char *hash_type = strhashtype (hash_mode); // not a bug
940
941 log_info ("Status.........: %s", status_type);
942
943 /**
944 * show rules
945 */
946
947 if (data.rp_files_cnt)
948 {
949 uint i;
950
951 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
952 {
953 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
954 }
955
956 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
957
958 log_info ("Rules.Type.....: %s", tmp_buf);
959
960 tmp_len = 0;
961 }
962
963 if (data.rp_gen)
964 {
965 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
966
967 if (data.rp_gen_seed)
968 {
969 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
970 }
971 }
972
973 /**
974 * show input
975 */
976
977 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
978 {
979 if (data.wordlist_mode == WL_MODE_FILE)
980 {
981 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
982 }
983 else if (data.wordlist_mode == WL_MODE_STDIN)
984 {
985 log_info ("Input.Mode.....: Pipe");
986 }
987 }
988 else if (data.attack_mode == ATTACK_MODE_COMBI)
989 {
990 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
991 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
992 }
993 else if (data.attack_mode == ATTACK_MODE_BF)
994 {
995 char *mask = data.mask;
996
997 if (mask != NULL)
998 {
999 uint mask_len = data.css_cnt;
1000
1001 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1002
1003 if (mask_len > 0)
1004 {
1005 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1006 {
1007 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1008 {
1009 mask_len -= data.salts_buf[0].salt_len;
1010 }
1011 }
1012
1013 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1014
1015 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1016 }
1017
1018 if (data.maskcnt > 1)
1019 {
1020 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1021
1022 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1023 }
1024
1025 log_info ("Input.Mode.....: %s", tmp_buf);
1026 }
1027
1028 tmp_len = 0;
1029 }
1030 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1031 {
1032 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1033 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1034 }
1035 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1036 {
1037 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1038 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1039 }
1040
1041 if (data.digests_cnt == 1)
1042 {
1043 if (data.hash_mode == 2500)
1044 {
1045 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1046
1047 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1048 (char *) data.salts_buf[0].salt_buf,
1049 wpa->orig_mac1[0],
1050 wpa->orig_mac1[1],
1051 wpa->orig_mac1[2],
1052 wpa->orig_mac1[3],
1053 wpa->orig_mac1[4],
1054 wpa->orig_mac1[5],
1055 wpa->orig_mac2[0],
1056 wpa->orig_mac2[1],
1057 wpa->orig_mac2[2],
1058 wpa->orig_mac2[3],
1059 wpa->orig_mac2[4],
1060 wpa->orig_mac2[5]);
1061 }
1062 else if (data.hash_mode == 5200)
1063 {
1064 log_info ("Hash.Target....: File (%s)", data.hashfile);
1065 }
1066 else if (data.hash_mode == 9000)
1067 {
1068 log_info ("Hash.Target....: File (%s)", data.hashfile);
1069 }
1070 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1071 {
1072 log_info ("Hash.Target....: File (%s)", data.hashfile);
1073 }
1074 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1075 {
1076 log_info ("Hash.Target....: File (%s)", data.hashfile);
1077 }
1078 else
1079 {
1080 char out_buf[HCBUFSIZ] = { 0 };
1081
1082 ascii_digest (out_buf, 0, 0);
1083
1084 // limit length
1085 if (strlen (out_buf) > 40)
1086 {
1087 out_buf[41] = '.';
1088 out_buf[42] = '.';
1089 out_buf[43] = '.';
1090 out_buf[44] = 0;
1091 }
1092
1093 log_info ("Hash.Target....: %s", out_buf);
1094 }
1095 }
1096 else
1097 {
1098 if (data.hash_mode == 3000)
1099 {
1100 char out_buf1[32] = { 0 };
1101 char out_buf2[32] = { 0 };
1102
1103 ascii_digest (out_buf1, 0, 0);
1104 ascii_digest (out_buf2, 0, 1);
1105
1106 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1107 }
1108 else
1109 {
1110 log_info ("Hash.Target....: File (%s)", data.hashfile);
1111 }
1112 }
1113
1114 log_info ("Hash.Type......: %s", hash_type);
1115
1116 /**
1117 * speed new
1118 */
1119
1120 u64 speed_cnt[DEVICES_MAX] = { 0 };
1121 double speed_ms[DEVICES_MAX] = { 0 };
1122
1123 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1124 {
1125 hc_device_param_t *device_param = &data.devices_param[device_id];
1126
1127 if (device_param->skipped) continue;
1128
1129 speed_cnt[device_id] = 0;
1130 speed_ms[device_id] = 0;
1131
1132 for (int i = 0; i < SPEED_CACHE; i++)
1133 {
1134 speed_cnt[device_id] += device_param->speed_cnt[i];
1135 speed_ms[device_id] += device_param->speed_ms[i];
1136 }
1137
1138 speed_cnt[device_id] /= SPEED_CACHE;
1139 speed_ms[device_id] /= SPEED_CACHE;
1140 }
1141
1142 double hashes_all_ms = 0;
1143
1144 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1145
1146 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1147 {
1148 hc_device_param_t *device_param = &data.devices_param[device_id];
1149
1150 if (device_param->skipped) continue;
1151
1152 hashes_dev_ms[device_id] = 0;
1153
1154 if (speed_ms[device_id])
1155 {
1156 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1157
1158 hashes_all_ms += hashes_dev_ms[device_id];
1159 }
1160 }
1161
1162 /**
1163 * exec time
1164 */
1165
1166 double exec_all_ms[DEVICES_MAX] = { 0 };
1167
1168 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1169 {
1170 hc_device_param_t *device_param = &data.devices_param[device_id];
1171
1172 if (device_param->skipped) continue;
1173
1174 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1175
1176 exec_all_ms[device_id] = exec_ms_avg;
1177 }
1178
1179 /**
1180 * timers
1181 */
1182
1183 double ms_running = 0;
1184
1185 hc_timer_get (data.timer_running, ms_running);
1186
1187 double ms_paused = data.ms_paused;
1188
1189 if (data.devices_status == STATUS_PAUSED)
1190 {
1191 double ms_paused_tmp = 0;
1192
1193 hc_timer_get (data.timer_paused, ms_paused_tmp);
1194
1195 ms_paused += ms_paused_tmp;
1196 }
1197
1198 #ifdef WIN
1199
1200 __time64_t sec_run = ms_running / 1000;
1201
1202 #else
1203
1204 time_t sec_run = ms_running / 1000;
1205
1206 #endif
1207
1208 if (sec_run)
1209 {
1210 char display_run[32] = { 0 };
1211
1212 struct tm tm_run;
1213
1214 struct tm *tmp = NULL;
1215
1216 #ifdef WIN
1217
1218 tmp = _gmtime64 (&sec_run);
1219
1220 #else
1221
1222 tmp = gmtime (&sec_run);
1223
1224 #endif
1225
1226 if (tmp != NULL)
1227 {
1228 memset (&tm_run, 0, sizeof (tm_run));
1229
1230 memcpy (&tm_run, tmp, sizeof (tm_run));
1231
1232 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1233
1234 char *start = ctime (&data.proc_start);
1235
1236 size_t start_len = strlen (start);
1237
1238 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1239 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1240
1241 log_info ("Time.Started...: %s (%s)", start, display_run);
1242 }
1243 }
1244 else
1245 {
1246 log_info ("Time.Started...: 0 secs");
1247 }
1248
1249 /**
1250 * counters
1251 */
1252
1253 u64 progress_total = data.words_cnt * data.salts_cnt;
1254
1255 u64 all_done = 0;
1256 u64 all_rejected = 0;
1257 u64 all_restored = 0;
1258
1259 u64 progress_noneed = 0;
1260
1261 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1262 {
1263 all_done += data.words_progress_done[salt_pos];
1264 all_rejected += data.words_progress_rejected[salt_pos];
1265 all_restored += data.words_progress_restored[salt_pos];
1266
1267 // Important for ETA only
1268
1269 if (data.salts_shown[salt_pos] == 1)
1270 {
1271 const u64 all = data.words_progress_done[salt_pos]
1272 + data.words_progress_rejected[salt_pos]
1273 + data.words_progress_restored[salt_pos];
1274
1275 const u64 left = data.words_cnt - all;
1276
1277 progress_noneed += left;
1278 }
1279 }
1280
1281 u64 progress_cur = all_restored + all_done + all_rejected;
1282 u64 progress_end = progress_total;
1283
1284 u64 progress_skip = 0;
1285
1286 if (data.skip)
1287 {
1288 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1289
1290 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1291 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1292 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1293 }
1294
1295 if (data.limit)
1296 {
1297 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1298
1299 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1300 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1301 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1302 }
1303
1304 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1305 u64 progress_end_relative_skip = progress_end - progress_skip;
1306
1307 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1308 {
1309 if (data.devices_status != STATUS_CRACKED)
1310 {
1311 #ifdef WIN
1312 __time64_t sec_etc = 0;
1313 #else
1314 time_t sec_etc = 0;
1315 #endif
1316
1317 if (hashes_all_ms)
1318 {
1319 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1320
1321 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1322
1323 sec_etc = ms_left / 1000;
1324 }
1325
1326 if (sec_etc == 0)
1327 {
1328 //log_info ("Time.Estimated.: 0 secs");
1329 }
1330 else if ((u64) sec_etc > ETC_MAX)
1331 {
1332 log_info ("Time.Estimated.: > 10 Years");
1333 }
1334 else
1335 {
1336 char display_etc[32] = { 0 };
1337
1338 struct tm tm_etc;
1339
1340 struct tm *tmp = NULL;
1341
1342 #ifdef WIN
1343
1344 tmp = _gmtime64 (&sec_etc);
1345
1346 #else
1347
1348 tmp = gmtime (&sec_etc);
1349
1350 #endif
1351
1352 if (tmp != NULL)
1353 {
1354 memset (&tm_etc, 0, sizeof (tm_etc));
1355
1356 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1357
1358 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1359
1360 time_t now;
1361
1362 time (&now);
1363
1364 now += sec_etc;
1365
1366 char *etc = ctime (&now);
1367
1368 size_t etc_len = strlen (etc);
1369
1370 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1371 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1372
1373 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1374 }
1375 }
1376 }
1377 }
1378
1379 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1380 {
1381 hc_device_param_t *device_param = &data.devices_param[device_id];
1382
1383 if (device_param->skipped) continue;
1384
1385 char display_dev_cur[16] = { 0 };
1386
1387 strncpy (display_dev_cur, "0.00", 4);
1388
1389 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1390
1391 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1392 }
1393
1394 char display_all_cur[16] = { 0 };
1395
1396 strncpy (display_all_cur, "0.00", 4);
1397
1398 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1399
1400 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1401
1402 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1403 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1404
1405 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);
1406
1407 // crack-per-time
1408
1409 if (data.digests_cnt > 100)
1410 {
1411 time_t now = time (NULL);
1412
1413 int cpt_cur_min = 0;
1414 int cpt_cur_hour = 0;
1415 int cpt_cur_day = 0;
1416
1417 for (int i = 0; i < CPT_BUF; i++)
1418 {
1419 const uint cracked = data.cpt_buf[i].cracked;
1420 const time_t timestamp = data.cpt_buf[i].timestamp;
1421
1422 if ((timestamp + 60) > now)
1423 {
1424 cpt_cur_min += cracked;
1425 }
1426
1427 if ((timestamp + 3600) > now)
1428 {
1429 cpt_cur_hour += cracked;
1430 }
1431
1432 if ((timestamp + 86400) > now)
1433 {
1434 cpt_cur_day += cracked;
1435 }
1436 }
1437
1438 double ms_real = ms_running - ms_paused;
1439
1440 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1441 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1442 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1443
1444 if ((data.cpt_start + 86400) < now)
1445 {
1446 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1447 cpt_cur_min,
1448 cpt_cur_hour,
1449 cpt_cur_day,
1450 cpt_avg_min,
1451 cpt_avg_hour,
1452 cpt_avg_day);
1453 }
1454 else if ((data.cpt_start + 3600) < now)
1455 {
1456 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1457 cpt_cur_min,
1458 cpt_cur_hour,
1459 cpt_avg_min,
1460 cpt_avg_hour,
1461 cpt_avg_day);
1462 }
1463 else if ((data.cpt_start + 60) < now)
1464 {
1465 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1466 cpt_cur_min,
1467 cpt_avg_min,
1468 cpt_avg_hour,
1469 cpt_avg_day);
1470 }
1471 else
1472 {
1473 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1474 cpt_avg_min,
1475 cpt_avg_hour,
1476 cpt_avg_day);
1477 }
1478 }
1479
1480 // Restore point
1481
1482 u64 restore_point = get_lowest_words_done ();
1483
1484 u64 restore_total = data.words_base;
1485
1486 float percent_restore = 0;
1487
1488 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1489
1490 if (progress_end_relative_skip)
1491 {
1492 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1493 {
1494 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1495 float percent_rejected = 0.0;
1496
1497 if (progress_cur)
1498 {
1499 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1500 }
1501
1502 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);
1503 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1504
1505 if (data.restore_disable == 0)
1506 {
1507 if (percent_finished != 1)
1508 {
1509 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1510 }
1511 }
1512 }
1513 }
1514 else
1515 {
1516 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1517 {
1518 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1519 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1520
1521 if (data.restore_disable == 0)
1522 {
1523 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1524 }
1525 }
1526 else
1527 {
1528 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1529 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1530
1531 // --restore not allowed if stdin is used -- really? why?
1532
1533 //if (data.restore_disable == 0)
1534 //{
1535 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1536 //}
1537 }
1538 }
1539
1540 #ifdef HAVE_HWMON
1541
1542 if (data.devices_status == STATUS_EXHAUSTED) return;
1543 if (data.devices_status == STATUS_CRACKED) return;
1544 if (data.devices_status == STATUS_ABORTED) return;
1545 if (data.devices_status == STATUS_QUIT) return;
1546
1547 if (data.gpu_temp_disable == 0)
1548 {
1549 hc_thread_mutex_lock (mux_adl);
1550
1551 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1552 {
1553 hc_device_param_t *device_param = &data.devices_param[device_id];
1554
1555 if (device_param->skipped) continue;
1556
1557 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1558 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1559 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1560 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1561 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1562 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1563 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1564
1565 char output_buf[256] = { 0 };
1566
1567 int output_len = 0;
1568
1569 if (num_temperature >= 0)
1570 {
1571 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1572
1573 output_len = strlen (output_buf);
1574 }
1575
1576 if (num_fanspeed >= 0)
1577 {
1578 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1579
1580 output_len = strlen (output_buf);
1581 }
1582
1583 if (num_utilization >= 0)
1584 {
1585 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1586
1587 output_len = strlen (output_buf);
1588 }
1589
1590 if (num_corespeed >= 0)
1591 {
1592 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1593
1594 output_len = strlen (output_buf);
1595 }
1596
1597 if (num_memoryspeed >= 0)
1598 {
1599 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1600
1601 output_len = strlen (output_buf);
1602 }
1603
1604 if (num_buslanes >= 0)
1605 {
1606 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1607
1608 output_len = strlen (output_buf);
1609 }
1610
1611 if (num_throttle == 1)
1612 {
1613 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1614
1615 output_len = strlen (output_buf);
1616 }
1617
1618 if (output_len == 0)
1619 {
1620 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1621
1622 output_len = strlen (output_buf);
1623 }
1624
1625 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1626 }
1627
1628 hc_thread_mutex_unlock (mux_adl);
1629 }
1630
1631 #endif // HAVE_HWMON
1632 }
1633
1634 static void status_benchmark_automate ()
1635 {
1636 u64 speed_cnt[DEVICES_MAX] = { 0 };
1637 double speed_ms[DEVICES_MAX] = { 0 };
1638
1639 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1640 {
1641 hc_device_param_t *device_param = &data.devices_param[device_id];
1642
1643 if (device_param->skipped) continue;
1644
1645 speed_cnt[device_id] = device_param->speed_cnt[0];
1646 speed_ms[device_id] = device_param->speed_ms[0];
1647 }
1648
1649 double hashes_dev_ms[DEVICES_MAX] = { 0 };
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 hashes_dev_ms[device_id] = 0;
1658
1659 if (speed_ms[device_id])
1660 {
1661 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1662 }
1663 }
1664
1665 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1666 {
1667 hc_device_param_t *device_param = &data.devices_param[device_id];
1668
1669 if (device_param->skipped) continue;
1670
1671 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1672 }
1673 }
1674
1675 static void status_benchmark ()
1676 {
1677 if (data.devices_status == STATUS_INIT) return;
1678 if (data.devices_status == STATUS_STARTING) return;
1679 if (data.devices_status == STATUS_BYPASS) return;
1680
1681 if (data.machine_readable == 1)
1682 {
1683 status_benchmark_automate ();
1684
1685 return;
1686 }
1687
1688 u64 speed_cnt[DEVICES_MAX] = { 0 };
1689 double speed_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 speed_cnt[device_id] = device_param->speed_cnt[0];
1698 speed_ms[device_id] = device_param->speed_ms[0];
1699 }
1700
1701 double hashes_all_ms = 0;
1702
1703 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1704
1705 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1706 {
1707 hc_device_param_t *device_param = &data.devices_param[device_id];
1708
1709 if (device_param->skipped) continue;
1710
1711 hashes_dev_ms[device_id] = 0;
1712
1713 if (speed_ms[device_id])
1714 {
1715 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1716
1717 hashes_all_ms += hashes_dev_ms[device_id];
1718 }
1719 }
1720
1721 /**
1722 * exec time
1723 */
1724
1725 double exec_all_ms[DEVICES_MAX] = { 0 };
1726
1727 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1728 {
1729 hc_device_param_t *device_param = &data.devices_param[device_id];
1730
1731 if (device_param->skipped) continue;
1732
1733 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1734
1735 exec_all_ms[device_id] = exec_ms_avg;
1736 }
1737
1738 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1739 {
1740 hc_device_param_t *device_param = &data.devices_param[device_id];
1741
1742 if (device_param->skipped) continue;
1743
1744 char display_dev_cur[16] = { 0 };
1745
1746 strncpy (display_dev_cur, "0.00", 4);
1747
1748 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1749
1750 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1751 }
1752
1753 char display_all_cur[16] = { 0 };
1754
1755 strncpy (display_all_cur, "0.00", 4);
1756
1757 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1758
1759 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1760 }
1761
1762 /**
1763 * hashcat -only- functions
1764 */
1765
1766 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1767 {
1768 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1769 {
1770 if (attack_kern == ATTACK_KERN_STRAIGHT)
1771 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1772 else if (attack_kern == ATTACK_KERN_COMBI)
1773 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1774 else if (attack_kern == ATTACK_KERN_BF)
1775 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1776 }
1777 else
1778 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1779 }
1780
1781 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)
1782 {
1783 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1784 {
1785 if (attack_kern == ATTACK_KERN_STRAIGHT)
1786 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1787 else if (attack_kern == ATTACK_KERN_COMBI)
1788 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1789 else if (attack_kern == ATTACK_KERN_BF)
1790 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1791 }
1792 else
1793 {
1794 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1795 }
1796 }
1797
1798 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1799 {
1800 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1801 {
1802 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1803 }
1804 else
1805 {
1806 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1807 }
1808 }
1809
1810 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)
1811 {
1812 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1813 {
1814 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1815 }
1816 else
1817 {
1818 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1819 }
1820 }
1821
1822 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1823 {
1824 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1825 }
1826
1827 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1828 {
1829 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1830 }
1831
1832 static uint convert_from_hex (char *line_buf, const uint line_len)
1833 {
1834 if (line_len & 1) return (line_len); // not in hex
1835
1836 if (data.hex_wordlist == 1)
1837 {
1838 uint i;
1839 uint j;
1840
1841 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1842 {
1843 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1844 }
1845
1846 memset (line_buf + i, 0, line_len - i);
1847
1848 return (i);
1849 }
1850 else if (line_len >= 6) // $HEX[] = 6
1851 {
1852 if (line_buf[0] != '$') return (line_len);
1853 if (line_buf[1] != 'H') return (line_len);
1854 if (line_buf[2] != 'E') return (line_len);
1855 if (line_buf[3] != 'X') return (line_len);
1856 if (line_buf[4] != '[') return (line_len);
1857 if (line_buf[line_len - 1] != ']') return (line_len);
1858
1859 uint i;
1860 uint j;
1861
1862 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1863 {
1864 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1865 }
1866
1867 memset (line_buf + i, 0, line_len - i);
1868
1869 return (i);
1870 }
1871
1872 return (line_len);
1873 }
1874
1875 static void clear_prompt ()
1876 {
1877 fputc ('\r', stdout);
1878
1879 for (size_t i = 0; i < strlen (PROMPT); i++)
1880 {
1881 fputc (' ', stdout);
1882 }
1883
1884 fputc ('\r', stdout);
1885
1886 fflush (stdout);
1887 }
1888
1889 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1890 {
1891 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);
1892 }
1893
1894 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1895 {
1896 char *outfile = data.outfile;
1897 uint quiet = data.quiet;
1898 FILE *pot_fp = data.pot_fp;
1899 uint loopback = data.loopback;
1900 uint debug_mode = data.debug_mode;
1901 char *debug_file = data.debug_file;
1902
1903 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1904 int debug_rule_len = 0; // -1 error
1905 uint debug_plain_len = 0;
1906
1907 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1908
1909 // hash
1910
1911 char out_buf[HCBUFSIZ] = { 0 };
1912
1913 const u32 salt_pos = plain->salt_pos;
1914 const u32 digest_pos = plain->digest_pos; // relative
1915 const u32 gidvid = plain->gidvid;
1916 const u32 il_pos = plain->il_pos;
1917
1918 ascii_digest (out_buf, salt_pos, digest_pos);
1919
1920 // plain
1921
1922 u64 crackpos = device_param->words_off;
1923
1924 uint plain_buf[16] = { 0 };
1925
1926 u8 *plain_ptr = (u8 *) plain_buf;
1927
1928 unsigned int plain_len = 0;
1929
1930 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1931 {
1932 pw_t pw;
1933
1934 gidd_to_pw_t (device_param, gidvid, &pw);
1935
1936 for (int i = 0; i < 16; i++)
1937 {
1938 plain_buf[i] = pw.i[i];
1939 }
1940
1941 plain_len = pw.pw_len;
1942
1943 const uint off = device_param->innerloop_pos + il_pos;
1944
1945 if (debug_mode > 0)
1946 {
1947 debug_rule_len = 0;
1948
1949 // save rule
1950 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1951 {
1952 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1953
1954 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1955 }
1956
1957 // save plain
1958 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1959 {
1960 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1961
1962 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1963
1964 debug_plain_len = plain_len;
1965 }
1966 }
1967
1968 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1969
1970 crackpos += gidvid;
1971 crackpos *= data.kernel_rules_cnt;
1972 crackpos += device_param->innerloop_pos + il_pos;
1973
1974 if (plain_len > data.pw_max) plain_len = data.pw_max;
1975 }
1976 else if (data.attack_mode == ATTACK_MODE_COMBI)
1977 {
1978 pw_t pw;
1979
1980 gidd_to_pw_t (device_param, gidvid, &pw);
1981
1982 for (int i = 0; i < 16; i++)
1983 {
1984 plain_buf[i] = pw.i[i];
1985 }
1986
1987 plain_len = pw.pw_len;
1988
1989 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1990 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1991
1992 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1993 {
1994 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1995 }
1996 else
1997 {
1998 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1999
2000 memcpy (plain_ptr, comb_buf, comb_len);
2001 }
2002
2003 plain_len += comb_len;
2004
2005 crackpos += gidvid;
2006 crackpos *= data.combs_cnt;
2007 crackpos += device_param->innerloop_pos + il_pos;
2008
2009 if (data.pw_max != PW_DICTMAX1)
2010 {
2011 if (plain_len > data.pw_max) plain_len = data.pw_max;
2012 }
2013 }
2014 else if (data.attack_mode == ATTACK_MODE_BF)
2015 {
2016 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2017 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2018
2019 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2020 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2021
2022 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2023 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2024
2025 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2026 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2027
2028 plain_len = data.css_cnt;
2029
2030 crackpos += gidvid;
2031 crackpos *= data.bfs_cnt;
2032 crackpos += device_param->innerloop_pos + il_pos;
2033 }
2034 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2035 {
2036 pw_t pw;
2037
2038 gidd_to_pw_t (device_param, gidvid, &pw);
2039
2040 for (int i = 0; i < 16; i++)
2041 {
2042 plain_buf[i] = pw.i[i];
2043 }
2044
2045 plain_len = pw.pw_len;
2046
2047 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2048
2049 uint start = 0;
2050 uint stop = device_param->kernel_params_mp_buf32[4];
2051
2052 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2053
2054 plain_len += start + stop;
2055
2056 crackpos += gidvid;
2057 crackpos *= data.combs_cnt;
2058 crackpos += device_param->innerloop_pos + il_pos;
2059
2060 if (data.pw_max != PW_DICTMAX1)
2061 {
2062 if (plain_len > data.pw_max) plain_len = data.pw_max;
2063 }
2064 }
2065 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2066 {
2067 pw_t pw;
2068
2069 gidd_to_pw_t (device_param, gidvid, &pw);
2070
2071 for (int i = 0; i < 16; i++)
2072 {
2073 plain_buf[i] = pw.i[i];
2074 }
2075
2076 plain_len = pw.pw_len;
2077
2078 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2079
2080 uint start = 0;
2081 uint stop = device_param->kernel_params_mp_buf32[4];
2082
2083 memmove (plain_ptr + stop, plain_ptr, plain_len);
2084
2085 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2086
2087 plain_len += start + stop;
2088
2089 crackpos += gidvid;
2090 crackpos *= data.combs_cnt;
2091 crackpos += device_param->innerloop_pos + il_pos;
2092
2093 if (data.pw_max != PW_DICTMAX1)
2094 {
2095 if (plain_len > data.pw_max) plain_len = data.pw_max;
2096 }
2097 }
2098
2099 if (data.attack_mode == ATTACK_MODE_BF)
2100 {
2101 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2102 {
2103 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2104 {
2105 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2106 {
2107 plain_len = plain_len - data.salts_buf[0].salt_len;
2108 }
2109 }
2110
2111 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2112 {
2113 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2114 {
2115 plain_ptr[j] = plain_ptr[i];
2116 }
2117
2118 plain_len = plain_len / 2;
2119 }
2120 }
2121 }
2122
2123 // if enabled, update also the potfile
2124
2125 if (pot_fp)
2126 {
2127 lock_file (pot_fp);
2128
2129 fprintf (pot_fp, "%s:", out_buf);
2130
2131 format_plain (pot_fp, plain_ptr, plain_len, 1);
2132
2133 fputc ('\n', pot_fp);
2134
2135 fflush (pot_fp);
2136
2137 unlock_file (pot_fp);
2138 }
2139
2140 // outfile
2141
2142 FILE *out_fp = NULL;
2143
2144 if (outfile != NULL)
2145 {
2146 if ((out_fp = fopen (outfile, "ab")) == NULL)
2147 {
2148 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2149
2150 out_fp = stdout;
2151 }
2152
2153 lock_file (out_fp);
2154 }
2155 else
2156 {
2157 out_fp = stdout;
2158
2159 if (quiet == 0) clear_prompt ();
2160 }
2161
2162 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2163
2164 if (outfile != NULL)
2165 {
2166 if (out_fp != stdout)
2167 {
2168 fclose (out_fp);
2169 }
2170 }
2171 else
2172 {
2173 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2174 {
2175 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2176 {
2177 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2178 if (quiet == 0) fflush (stdout);
2179 }
2180 }
2181 }
2182
2183 // loopback
2184
2185 if (loopback)
2186 {
2187 char *loopback_file = data.loopback_file;
2188
2189 FILE *fb_fp = NULL;
2190
2191 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2192 {
2193 lock_file (fb_fp);
2194
2195 format_plain (fb_fp, plain_ptr, plain_len, 1);
2196
2197 fputc ('\n', fb_fp);
2198
2199 fclose (fb_fp);
2200 }
2201 }
2202
2203 // (rule) debug mode
2204
2205 // the next check implies that:
2206 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2207 // - debug_mode > 0
2208
2209 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2210 {
2211 if (debug_rule_len < 0) debug_rule_len = 0;
2212
2213 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2214
2215 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2216
2217 if ((quiet == 0) && (debug_file == NULL))
2218 {
2219 fprintf (stdout, "%s", PROMPT);
2220
2221 fflush (stdout);
2222 }
2223 }
2224 }
2225
2226 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2227 {
2228 salt_t *salt_buf = &data.salts_buf[salt_pos];
2229
2230 u32 num_cracked;
2231
2232 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2233
2234 if (num_cracked)
2235 {
2236 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2237
2238 log_info_nn ("");
2239
2240 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2241
2242 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);
2243
2244 uint cpt_cracked = 0;
2245
2246 for (uint i = 0; i < num_cracked; i++)
2247 {
2248 const uint hash_pos = cracked[i].hash_pos;
2249
2250 if (data.digests_shown[hash_pos] == 1) continue;
2251
2252 hc_thread_mutex_lock (mux_display);
2253
2254 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2255 {
2256 data.digests_shown[hash_pos] = 1;
2257
2258 data.digests_done++;
2259
2260 cpt_cracked++;
2261
2262 salt_buf->digests_done++;
2263
2264 if (salt_buf->digests_done == salt_buf->digests_cnt)
2265 {
2266 data.salts_shown[salt_pos] = 1;
2267
2268 data.salts_done++;
2269 }
2270 }
2271
2272 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2273
2274 hc_thread_mutex_unlock (mux_display);
2275
2276 check_hash (device_param, &cracked[i]);
2277 }
2278
2279 myfree (cracked);
2280
2281 if (cpt_cracked > 0)
2282 {
2283 hc_thread_mutex_lock (mux_display);
2284
2285 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2286 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2287
2288 data.cpt_pos++;
2289
2290 data.cpt_total += cpt_cracked;
2291
2292 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2293
2294 hc_thread_mutex_unlock (mux_display);
2295 }
2296
2297 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2298 {
2299 // we need to reset cracked state on the device
2300 // otherwise host thinks again and again the hash was cracked
2301 // and returns invalid password each time
2302
2303 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2304
2305 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);
2306 }
2307
2308 num_cracked = 0;
2309
2310 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2311 }
2312 }
2313
2314 static void save_hash ()
2315 {
2316 char *hashfile = data.hashfile;
2317
2318 char new_hashfile[256] = { 0 };
2319 char old_hashfile[256] = { 0 };
2320
2321 snprintf (new_hashfile, 255, "%s.new", hashfile);
2322 snprintf (old_hashfile, 255, "%s.old", hashfile);
2323
2324 unlink (new_hashfile);
2325
2326 char separator = data.separator;
2327
2328 FILE *fp = fopen (new_hashfile, "wb");
2329
2330 if (fp == NULL)
2331 {
2332 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2333
2334 exit (-1);
2335 }
2336
2337 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2338 {
2339 if (data.salts_shown[salt_pos] == 1) continue;
2340
2341 salt_t *salt_buf = &data.salts_buf[salt_pos];
2342
2343 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2344 {
2345 uint idx = salt_buf->digests_offset + digest_pos;
2346
2347 if (data.digests_shown[idx] == 1) continue;
2348
2349 if (data.hash_mode != 2500)
2350 {
2351 char out_buf[HCBUFSIZ] = { 0 };
2352
2353 if (data.username == 1)
2354 {
2355 user_t *user = data.hash_info[idx]->user;
2356
2357 uint i;
2358
2359 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2360
2361 fputc (separator, fp);
2362 }
2363
2364 ascii_digest (out_buf, salt_pos, digest_pos);
2365
2366 fputs (out_buf, fp);
2367
2368 log_out (fp, "");
2369 }
2370 else
2371 {
2372 hccap_t hccap;
2373
2374 to_hccap_t (&hccap, salt_pos, digest_pos);
2375
2376 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2377 }
2378 }
2379 }
2380
2381 fflush (fp);
2382
2383 fclose (fp);
2384
2385 unlink (old_hashfile);
2386
2387 if (rename (hashfile, old_hashfile) != 0)
2388 {
2389 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2390
2391 exit (-1);
2392 }
2393
2394 unlink (hashfile);
2395
2396 if (rename (new_hashfile, hashfile) != 0)
2397 {
2398 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2399
2400 exit (-1);
2401 }
2402
2403 unlink (old_hashfile);
2404 }
2405
2406 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2407 {
2408 uint num_elements = num;
2409
2410 device_param->kernel_params_buf32[30] = data.combs_mode;
2411 device_param->kernel_params_buf32[31] = num;
2412
2413 uint kernel_threads = device_param->kernel_threads;
2414
2415 while (num_elements % kernel_threads) num_elements++;
2416
2417 cl_kernel kernel = NULL;
2418
2419 switch (kern_run)
2420 {
2421 case KERN_RUN_1: kernel = device_param->kernel1; break;
2422 case KERN_RUN_12: kernel = device_param->kernel12; break;
2423 case KERN_RUN_2: kernel = device_param->kernel2; break;
2424 case KERN_RUN_23: kernel = device_param->kernel23; break;
2425 case KERN_RUN_3: kernel = device_param->kernel3; break;
2426 }
2427
2428 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2429 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2430 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2431 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2432 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2433 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2434 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2435 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2436 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2437 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2438 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2439
2440 cl_event event;
2441
2442 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2443 {
2444 const size_t global_work_size[3] = { num_elements, 32, 1 };
2445 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2446
2447 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2448 }
2449 else
2450 {
2451 if (kern_run == KERN_RUN_2)
2452 {
2453 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2454 {
2455 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2456 }
2457 }
2458
2459 while (num_elements % kernel_threads) num_elements++;
2460
2461 const size_t global_work_size[3] = { num_elements, 1, 1 };
2462 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2463
2464 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2465 }
2466
2467 hc_clFlush (data.ocl, device_param->command_queue);
2468
2469 hc_clWaitForEvents (data.ocl, 1, &event);
2470
2471 if (event_update)
2472 {
2473 cl_ulong time_start;
2474 cl_ulong time_end;
2475
2476 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2477 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2478
2479 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2480
2481 uint exec_pos = device_param->exec_pos;
2482
2483 device_param->exec_ms[exec_pos] = exec_time;
2484
2485 exec_pos++;
2486
2487 if (exec_pos == EXEC_CACHE)
2488 {
2489 exec_pos = 0;
2490 }
2491
2492 device_param->exec_pos = exec_pos;
2493 }
2494
2495 hc_clReleaseEvent (data.ocl, event);
2496
2497 hc_clFinish (data.ocl, device_param->command_queue);
2498 }
2499
2500 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2501 {
2502 uint num_elements = num;
2503
2504 switch (kern_run)
2505 {
2506 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2507 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2508 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2509 }
2510
2511 // causes problems with special threads like in bcrypt
2512 // const uint kernel_threads = device_param->kernel_threads;
2513
2514 uint kernel_threads = device_param->kernel_threads;
2515
2516 while (num_elements % kernel_threads) num_elements++;
2517
2518 cl_kernel kernel = NULL;
2519
2520 switch (kern_run)
2521 {
2522 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2523 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2524 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2525 }
2526
2527 switch (kern_run)
2528 {
2529 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2530 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2531 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2532 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2533 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2534 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2535 break;
2536 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2537 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2538 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2539 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2540 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2541 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2542 break;
2543 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2544 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2545 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2546 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2547 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2548 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2549 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2550 break;
2551 }
2552
2553 const size_t global_work_size[3] = { num_elements, 1, 1 };
2554 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2555
2556 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2557
2558 hc_clFlush (data.ocl, device_param->command_queue);
2559
2560 hc_clFinish (data.ocl, device_param->command_queue);
2561 }
2562
2563 static void run_kernel_tm (hc_device_param_t *device_param)
2564 {
2565 const uint num_elements = 1024; // fixed
2566
2567 uint kernel_threads = 32;
2568
2569 cl_kernel kernel = device_param->kernel_tm;
2570
2571 const size_t global_work_size[3] = { num_elements, 1, 1 };
2572 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2573
2574 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2575
2576 hc_clFlush (data.ocl, device_param->command_queue);
2577
2578 hc_clFinish (data.ocl, device_param->command_queue);
2579 }
2580
2581 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2582 {
2583 uint num_elements = num;
2584
2585 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2586 device_param->kernel_params_amp_buf32[6] = num_elements;
2587
2588 // causes problems with special threads like in bcrypt
2589 // const uint kernel_threads = device_param->kernel_threads;
2590
2591 uint kernel_threads = device_param->kernel_threads;
2592
2593 while (num_elements % kernel_threads) num_elements++;
2594
2595 cl_kernel kernel = device_param->kernel_amp;
2596
2597 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2598 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2599
2600 const size_t global_work_size[3] = { num_elements, 1, 1 };
2601 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2602
2603 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2604
2605 hc_clFlush (data.ocl, device_param->command_queue);
2606
2607 hc_clFinish (data.ocl, device_param->command_queue);
2608 }
2609
2610 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2611 {
2612 const u32 num16d = num / 16;
2613 const u32 num16m = num % 16;
2614
2615 if (num16d)
2616 {
2617 device_param->kernel_params_memset_buf32[1] = value;
2618 device_param->kernel_params_memset_buf32[2] = num16d;
2619
2620 uint kernel_threads = device_param->kernel_threads;
2621
2622 uint num_elements = num16d;
2623
2624 while (num_elements % kernel_threads) num_elements++;
2625
2626 cl_kernel kernel = device_param->kernel_memset;
2627
2628 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2629 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2630 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2631
2632 const size_t global_work_size[3] = { num_elements, 1, 1 };
2633 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2634
2635 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2636
2637 hc_clFlush (data.ocl, device_param->command_queue);
2638
2639 hc_clFinish (data.ocl, device_param->command_queue);
2640 }
2641
2642 if (num16m)
2643 {
2644 u32 tmp[4];
2645
2646 tmp[0] = value;
2647 tmp[1] = value;
2648 tmp[2] = value;
2649 tmp[3] = value;
2650
2651 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2652 }
2653 }
2654
2655 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2656 {
2657 run_kernel_memset (device_param, buf, 0, size);
2658
2659 /*
2660 int rc = -1;
2661
2662 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2663 {
2664 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2665
2666 const cl_uchar zero = 0;
2667
2668 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2669 }
2670
2671 if (rc != 0)
2672 {
2673 // NOTE: clEnqueueFillBuffer () always fails with -59
2674 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2675 // How's that possible, OpenCL 1.2 support is advertised??
2676 // We need to workaround...
2677
2678 #define FILLSZ 0x100000
2679
2680 char *tmp = (char *) mymalloc (FILLSZ);
2681
2682 for (size_t i = 0; i < size; i += FILLSZ)
2683 {
2684 const size_t left = size - i;
2685
2686 const size_t fillsz = MIN (FILLSZ, left);
2687
2688 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2689 }
2690
2691 myfree (tmp);
2692 }
2693 */
2694 }
2695
2696 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)
2697 {
2698 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2699 {
2700 if (attack_mode == ATTACK_MODE_BF)
2701 {
2702 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2703 {
2704 const uint size_tm = 32 * sizeof (bs_word_t);
2705
2706 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2707
2708 run_kernel_tm (device_param);
2709
2710 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);
2711 }
2712 }
2713
2714 if (highest_pw_len < 16)
2715 {
2716 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2717 }
2718 else if (highest_pw_len < 32)
2719 {
2720 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2721 }
2722 else
2723 {
2724 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2725 }
2726 }
2727 else
2728 {
2729 run_kernel_amp (device_param, pws_cnt);
2730
2731 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2732
2733 if (opts_type & OPTS_TYPE_HOOK12)
2734 {
2735 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2736 }
2737
2738 uint iter = salt_buf->salt_iter;
2739
2740 uint loop_step = device_param->kernel_loops;
2741
2742 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2743 {
2744 uint loop_left = iter - loop_pos;
2745
2746 loop_left = MIN (loop_left, loop_step);
2747
2748 device_param->kernel_params_buf32[25] = loop_pos;
2749 device_param->kernel_params_buf32[26] = loop_left;
2750
2751 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2752
2753 if (data.devices_status == STATUS_CRACKED) break;
2754 if (data.devices_status == STATUS_ABORTED) break;
2755 if (data.devices_status == STATUS_QUIT) break;
2756
2757 /**
2758 * speed
2759 */
2760
2761 const float iter_part = (float) (loop_pos + loop_left) / iter;
2762
2763 const u64 perf_sum_all = pws_cnt * iter_part;
2764
2765 double speed_ms;
2766
2767 hc_timer_get (device_param->timer_speed, speed_ms);
2768
2769 const u32 speed_pos = device_param->speed_pos;
2770
2771 device_param->speed_cnt[speed_pos] = perf_sum_all;
2772
2773 device_param->speed_ms[speed_pos] = speed_ms;
2774
2775 if (data.benchmark == 1)
2776 {
2777 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2778 }
2779 }
2780
2781 if (opts_type & OPTS_TYPE_HOOK23)
2782 {
2783 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2784
2785 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);
2786
2787 // do something with data
2788
2789 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);
2790 }
2791
2792 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2793 }
2794 }
2795
2796 static int run_rule_engine (const int rule_len, const char *rule_buf)
2797 {
2798 if (rule_len == 0)
2799 {
2800 return 0;
2801 }
2802 else if (rule_len == 1)
2803 {
2804 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2805 }
2806
2807 return 1;
2808 }
2809
2810 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2811 {
2812 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2813 {
2814 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);
2815 }
2816 else if (data.attack_kern == ATTACK_KERN_COMBI)
2817 {
2818 if (data.attack_mode == ATTACK_MODE_COMBI)
2819 {
2820 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2821 {
2822 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2823 {
2824 for (u32 i = 0; i < pws_cnt; i++)
2825 {
2826 const u32 pw_len = device_param->pws_buf[i].pw_len;
2827
2828 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2829
2830 ptr[pw_len] = 0x01;
2831 }
2832 }
2833 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2834 {
2835 for (u32 i = 0; i < pws_cnt; i++)
2836 {
2837 const u32 pw_len = device_param->pws_buf[i].pw_len;
2838
2839 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2840
2841 ptr[pw_len] = 0x80;
2842 }
2843 }
2844 }
2845 }
2846 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2847 {
2848 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2849 {
2850 for (u32 i = 0; i < pws_cnt; i++)
2851 {
2852 const u32 pw_len = device_param->pws_buf[i].pw_len;
2853
2854 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2855
2856 ptr[pw_len] = 0x01;
2857 }
2858 }
2859 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2860 {
2861 for (u32 i = 0; i < pws_cnt; i++)
2862 {
2863 const u32 pw_len = device_param->pws_buf[i].pw_len;
2864
2865 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2866
2867 ptr[pw_len] = 0x80;
2868 }
2869 }
2870 }
2871
2872 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);
2873 }
2874 else if (data.attack_kern == ATTACK_KERN_BF)
2875 {
2876 const u64 off = device_param->words_off;
2877
2878 device_param->kernel_params_mp_l_buf64[3] = off;
2879
2880 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2881 }
2882 }
2883
2884 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2885 {
2886 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2887
2888 device_param->kernel_params_buf32[25] = 0;
2889 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2890 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2891
2892 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2893 {
2894 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true);
2895 }
2896 else
2897 {
2898 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true);
2899 }
2900
2901 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2902
2903 return exec_ms_prev;
2904 }
2905
2906 static void autotune (hc_device_param_t *device_param)
2907 {
2908 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2909
2910 const u32 kernel_accel_min = device_param->kernel_accel_min;
2911 const u32 kernel_accel_max = device_param->kernel_accel_max;
2912
2913 const u32 kernel_loops_min = device_param->kernel_loops_min;
2914 const u32 kernel_loops_max = device_param->kernel_loops_max;
2915
2916 u32 kernel_accel = kernel_accel_min;
2917 u32 kernel_loops = kernel_loops_min;
2918
2919 // in this case the user specified a fixed -u and -n on the commandline
2920 // no way to tune anything
2921 // but we need to run a few caching rounds
2922
2923 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2924 {
2925 try_run (device_param, kernel_accel, kernel_loops);
2926 try_run (device_param, kernel_accel, kernel_loops);
2927 try_run (device_param, kernel_accel, kernel_loops);
2928 try_run (device_param, kernel_accel, kernel_loops);
2929
2930 device_param->kernel_accel = kernel_accel;
2931 device_param->kernel_loops = kernel_loops;
2932
2933 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2934
2935 device_param->kernel_power = kernel_power;
2936
2937 return;
2938 }
2939
2940 // from here it's clear we are allowed to autotune
2941 // so let's init some fake words
2942
2943 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2944
2945 if (data.attack_kern == ATTACK_KERN_BF)
2946 {
2947 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2948 }
2949 else
2950 {
2951 for (u32 i = 0; i < kernel_power_max; i++)
2952 {
2953 device_param->pws_buf[i].i[0] = i;
2954 device_param->pws_buf[i].i[1] = 0x01234567;
2955 device_param->pws_buf[i].pw_len = 7 + (i & 7);
2956 }
2957
2958 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);
2959 }
2960
2961 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2962 {
2963 if (data.kernel_rules_cnt > 1)
2964 {
2965 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);
2966 }
2967 }
2968 else
2969 {
2970 run_kernel_amp (device_param, kernel_power_max);
2971 }
2972
2973 #define VERIFIER_CNT 1
2974
2975 // first find out highest kernel-loops that stays below target_ms
2976
2977 if (kernel_loops_min < kernel_loops_max)
2978 {
2979 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2980 {
2981 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2982
2983 for (int i = 0; i < VERIFIER_CNT; i++)
2984 {
2985 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2986
2987 exec_ms = MIN (exec_ms, exec_ms_v);
2988 }
2989
2990 if (exec_ms < target_ms) break;
2991 }
2992 }
2993
2994 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2995
2996 #define STEPS_CNT 10
2997
2998 if (kernel_accel_min < kernel_accel_max)
2999 {
3000 for (int i = 0; i < STEPS_CNT; i++)
3001 {
3002 const u32 kernel_accel_try = 1 << i;
3003
3004 if (kernel_accel_try < kernel_accel_min) continue;
3005 if (kernel_accel_try > kernel_accel_max) break;
3006
3007 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3008
3009 for (int i = 0; i < VERIFIER_CNT; i++)
3010 {
3011 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3012
3013 exec_ms = MIN (exec_ms, exec_ms_v);
3014 }
3015
3016 if (exec_ms > target_ms) break;
3017
3018 kernel_accel = kernel_accel_try;
3019 }
3020 }
3021
3022 // at this point we want to know the actual runtime for the following reason:
3023 // we need a reference for the balancing loop following up, and this
3024 // the balancing loop can have an effect that the creates a new opportunity, for example:
3025 // if the target is 95 ms and the current runtime is 48ms the above loop
3026 // stopped the execution because the previous exec_ms was > 95ms
3027 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3028 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3029
3030 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3031
3032 for (int i = 0; i < VERIFIER_CNT; i++)
3033 {
3034 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3035
3036 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3037 }
3038
3039 u32 diff = kernel_loops - kernel_accel;
3040
3041 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3042 {
3043 u32 kernel_accel_orig = kernel_accel;
3044 u32 kernel_loops_orig = kernel_loops;
3045
3046 for (u32 f = 1; f < 1024; f++)
3047 {
3048 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3049 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3050
3051 if (kernel_accel_try > kernel_accel_max) break;
3052 if (kernel_loops_try < kernel_loops_min) break;
3053
3054 u32 diff_new = kernel_loops_try - kernel_accel_try;
3055
3056 if (diff_new > diff) break;
3057
3058 diff_new = diff;
3059
3060 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3061
3062 for (int i = 0; i < VERIFIER_CNT; i++)
3063 {
3064 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3065
3066 exec_ms = MIN (exec_ms, exec_ms_v);
3067 }
3068
3069 if (exec_ms < exec_ms_pre_final)
3070 {
3071 exec_ms_pre_final = exec_ms;
3072
3073 kernel_accel = kernel_accel_try;
3074 kernel_loops = kernel_loops_try;
3075 }
3076 }
3077 }
3078
3079 const double exec_left = target_ms / exec_ms_pre_final;
3080
3081 const double accel_left = kernel_accel_max / kernel_accel;
3082
3083 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3084
3085 if (exec_accel_min >= 1.0)
3086 {
3087 // this is safe to not overflow kernel_accel_max because of accel_left
3088
3089 kernel_accel = (double) kernel_accel * exec_accel_min;
3090 }
3091
3092 // reset them fake words
3093
3094 /*
3095 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3096
3097 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);
3098 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);
3099 */
3100
3101 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3102
3103 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3104 {
3105 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3106 }
3107
3108 // reset timer
3109
3110 device_param->exec_pos = 0;
3111
3112 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3113
3114 // store
3115
3116 device_param->kernel_accel = kernel_accel;
3117 device_param->kernel_loops = kernel_loops;
3118
3119 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3120
3121 device_param->kernel_power = kernel_power;
3122
3123 #ifdef DEBUG
3124
3125 if (data.quiet == 0)
3126 {
3127 clear_prompt ();
3128
3129 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3130 "Device #%u: autotuned kernel-loops to %u\n",
3131 device_param->device_id + 1, kernel_accel,
3132 device_param->device_id + 1, kernel_loops);
3133
3134 fprintf (stdout, "%s", PROMPT);
3135
3136 fflush (stdout);
3137 }
3138
3139 #endif
3140 }
3141
3142 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3143 {
3144 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3145
3146 // init speed timer
3147
3148 uint speed_pos = device_param->speed_pos;
3149
3150 #ifdef _POSIX
3151 if (device_param->timer_speed.tv_sec == 0)
3152 {
3153 hc_timer_set (&device_param->timer_speed);
3154 }
3155 #endif
3156
3157 #ifdef _WIN
3158 if (device_param->timer_speed.QuadPart == 0)
3159 {
3160 hc_timer_set (&device_param->timer_speed);
3161 }
3162 #endif
3163
3164 // find higest password length, this is for optimization stuff
3165
3166 uint highest_pw_len = 0;
3167
3168 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3169 {
3170 }
3171 else if (data.attack_kern == ATTACK_KERN_COMBI)
3172 {
3173 }
3174 else if (data.attack_kern == ATTACK_KERN_BF)
3175 {
3176 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3177 + device_param->kernel_params_mp_l_buf32[5];
3178 }
3179
3180 // iteration type
3181
3182 uint innerloop_step = 0;
3183 uint innerloop_cnt = 0;
3184
3185 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3186 else innerloop_step = 1;
3187
3188 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3189 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3190 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3191
3192 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3193
3194 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3195 {
3196 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3197
3198 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3199
3200 if (data.devices_status == STATUS_CRACKED) break;
3201 if (data.devices_status == STATUS_ABORTED) break;
3202 if (data.devices_status == STATUS_QUIT) break;
3203 if (data.devices_status == STATUS_BYPASS) break;
3204
3205 salt_t *salt_buf = &data.salts_buf[salt_pos];
3206
3207 device_param->kernel_params_buf32[24] = salt_pos;
3208 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3209 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3210
3211 FILE *combs_fp = device_param->combs_fp;
3212
3213 if (data.attack_mode == ATTACK_MODE_COMBI)
3214 {
3215 rewind (combs_fp);
3216 }
3217
3218 // innerloops
3219
3220 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3221 {
3222 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3223
3224 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3225
3226 if (data.devices_status == STATUS_CRACKED) break;
3227 if (data.devices_status == STATUS_ABORTED) break;
3228 if (data.devices_status == STATUS_QUIT) break;
3229 if (data.devices_status == STATUS_BYPASS) break;
3230
3231 uint innerloop_left = innerloop_cnt - innerloop_pos;
3232
3233 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3234
3235 device_param->innerloop_pos = innerloop_pos;
3236 device_param->innerloop_left = innerloop_left;
3237
3238 device_param->kernel_params_buf32[27] = innerloop_left;
3239
3240 // i think we can get rid of this
3241 if (innerloop_left == 0)
3242 {
3243 puts ("bug, how should this happen????\n");
3244
3245 continue;
3246 }
3247
3248 if (data.salts_shown[salt_pos] == 1)
3249 {
3250 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3251
3252 continue;
3253 }
3254
3255 // initialize amplifiers
3256
3257 if (data.attack_mode == ATTACK_MODE_COMBI)
3258 {
3259 uint i = 0;
3260
3261 while (i < innerloop_left)
3262 {
3263 if (feof (combs_fp)) break;
3264
3265 int line_len = fgetl (combs_fp, line_buf);
3266
3267 if (line_len >= PW_MAX1) continue;
3268
3269 line_len = convert_from_hex (line_buf, line_len);
3270
3271 char *line_buf_new = line_buf;
3272
3273 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3274 {
3275 char rule_buf_out[BLOCK_SIZE] = { 0 };
3276
3277 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3278
3279 if (rule_len_out < 0)
3280 {
3281 data.words_progress_rejected[salt_pos] += pws_cnt;
3282
3283 continue;
3284 }
3285
3286 line_len = rule_len_out;
3287
3288 line_buf_new = rule_buf_out;
3289 }
3290
3291 line_len = MIN (line_len, PW_DICTMAX);
3292
3293 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3294
3295 memcpy (ptr, line_buf_new, line_len);
3296
3297 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3298
3299 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3300 {
3301 uppercase (ptr, line_len);
3302 }
3303
3304 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3305 {
3306 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3307 {
3308 ptr[line_len] = 0x80;
3309 }
3310
3311 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3312 {
3313 ptr[line_len] = 0x01;
3314 }
3315 }
3316
3317 device_param->combs_buf[i].pw_len = line_len;
3318
3319 i++;
3320 }
3321
3322 for (uint j = i; j < innerloop_left; j++)
3323 {
3324 device_param->combs_buf[j].i[0] = 0;
3325 device_param->combs_buf[j].i[1] = 0;
3326 device_param->combs_buf[j].i[2] = 0;
3327 device_param->combs_buf[j].i[3] = 0;
3328 device_param->combs_buf[j].i[4] = 0;
3329 device_param->combs_buf[j].i[5] = 0;
3330 device_param->combs_buf[j].i[6] = 0;
3331 device_param->combs_buf[j].i[7] = 0;
3332
3333 device_param->combs_buf[j].pw_len = 0;
3334 }
3335
3336 innerloop_left = i;
3337 }
3338 else if (data.attack_mode == ATTACK_MODE_BF)
3339 {
3340 u64 off = innerloop_pos;
3341
3342 device_param->kernel_params_mp_r_buf64[3] = off;
3343
3344 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3345 }
3346 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3347 {
3348 u64 off = innerloop_pos;
3349
3350 device_param->kernel_params_mp_buf64[3] = off;
3351
3352 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3353 }
3354 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3355 {
3356 u64 off = innerloop_pos;
3357
3358 device_param->kernel_params_mp_buf64[3] = off;
3359
3360 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3361 }
3362
3363 // copy amplifiers
3364
3365 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3366 {
3367 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);
3368 }
3369 else if (data.attack_mode == ATTACK_MODE_COMBI)
3370 {
3371 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);
3372 }
3373 else if (data.attack_mode == ATTACK_MODE_BF)
3374 {
3375 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);
3376 }
3377 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3378 {
3379 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);
3380 }
3381 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3382 {
3383 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);
3384 }
3385
3386 if (data.benchmark == 1)
3387 {
3388 hc_timer_set (&device_param->timer_speed);
3389 }
3390
3391 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3392
3393 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3394
3395 if (data.devices_status == STATUS_CRACKED) break;
3396 if (data.devices_status == STATUS_ABORTED) break;
3397 if (data.devices_status == STATUS_QUIT) break;
3398
3399 /**
3400 * result
3401 */
3402
3403 check_cracked (device_param, salt_pos);
3404
3405 /**
3406 * progress
3407 */
3408
3409 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3410
3411 hc_thread_mutex_lock (mux_counter);
3412
3413 data.words_progress_done[salt_pos] += perf_sum_all;
3414
3415 hc_thread_mutex_unlock (mux_counter);
3416
3417 /**
3418 * speed
3419 */
3420
3421 double speed_ms;
3422
3423 hc_timer_get (device_param->timer_speed, speed_ms);
3424
3425 hc_timer_set (&device_param->timer_speed);
3426
3427 // current speed
3428
3429 //hc_thread_mutex_lock (mux_display);
3430
3431 device_param->speed_cnt[speed_pos] = perf_sum_all;
3432
3433 device_param->speed_ms[speed_pos] = speed_ms;
3434
3435 //hc_thread_mutex_unlock (mux_display);
3436
3437 speed_pos++;
3438
3439 if (speed_pos == SPEED_CACHE)
3440 {
3441 speed_pos = 0;
3442 }
3443
3444 /**
3445 * benchmark
3446 */
3447
3448 if (data.benchmark == 1) break;
3449 }
3450 }
3451
3452 device_param->speed_pos = speed_pos;
3453
3454 myfree (line_buf);
3455 }
3456
3457 static void load_segment (wl_data_t *wl_data, FILE *fd)
3458 {
3459 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3460
3461 wl_data->pos = 0;
3462
3463 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3464
3465 wl_data->buf[wl_data->cnt] = 0;
3466
3467 if (wl_data->cnt == 0) return;
3468
3469 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3470
3471 while (!feof (fd))
3472 {
3473 if (wl_data->cnt == wl_data->avail)
3474 {
3475 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3476
3477 wl_data->avail += wl_data->incr;
3478 }
3479
3480 const int c = fgetc (fd);
3481
3482 if (c == EOF) break;
3483
3484 wl_data->buf[wl_data->cnt] = (char) c;
3485
3486 wl_data->cnt++;
3487
3488 if (c == '\n') break;
3489 }
3490
3491 // ensure stream ends with a newline
3492
3493 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3494 {
3495 wl_data->cnt++;
3496
3497 wl_data->buf[wl_data->cnt - 1] = '\n';
3498 }
3499
3500 return;
3501 }
3502
3503 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3504 {
3505 char *ptr = buf;
3506
3507 for (u32 i = 0; i < sz; i++, ptr++)
3508 {
3509 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3510
3511 if (i == 7)
3512 {
3513 *off = i;
3514 *len = i;
3515
3516 return;
3517 }
3518
3519 if (*ptr != '\n') continue;
3520
3521 *off = i + 1;
3522
3523 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3524
3525 *len = i;
3526
3527 return;
3528 }
3529
3530 *off = sz;
3531 *len = sz;
3532 }
3533
3534 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3535 {
3536 char *ptr = buf;
3537
3538 for (u32 i = 0; i < sz; i++, ptr++)
3539 {
3540 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3541
3542 if (*ptr != '\n') continue;
3543
3544 *off = i + 1;
3545
3546 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3547
3548 *len = i;
3549
3550 return;
3551 }
3552
3553 *off = sz;
3554 *len = sz;
3555 }
3556
3557 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3558 {
3559 char *ptr = buf;
3560
3561 for (u32 i = 0; i < sz; i++, ptr++)
3562 {
3563 if (*ptr != '\n') continue;
3564
3565 *off = i + 1;
3566
3567 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3568
3569 *len = i;
3570
3571 return;
3572 }
3573
3574 *off = sz;
3575 *len = sz;
3576 }
3577
3578 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3579 {
3580 while (wl_data->pos < wl_data->cnt)
3581 {
3582 uint off;
3583 uint len;
3584
3585 char *ptr = wl_data->buf + wl_data->pos;
3586
3587 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3588
3589 wl_data->pos += off;
3590
3591 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3592 {
3593 char rule_buf_out[BLOCK_SIZE] = { 0 };
3594
3595 int rule_len_out = -1;
3596
3597 if (len < BLOCK_SIZE)
3598 {
3599 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3600 }
3601
3602 if (rule_len_out < 0)
3603 {
3604 continue;
3605 }
3606
3607 if (rule_len_out > PW_MAX)
3608 {
3609 continue;
3610 }
3611 }
3612 else
3613 {
3614 if (len > PW_MAX)
3615 {
3616 continue;
3617 }
3618 }
3619
3620 *out_buf = ptr;
3621 *out_len = len;
3622
3623 return;
3624 }
3625
3626 if (feof (fd))
3627 {
3628 fprintf (stderr, "BUG feof()!!\n");
3629
3630 return;
3631 }
3632
3633 load_segment (wl_data, fd);
3634
3635 get_next_word (wl_data, fd, out_buf, out_len);
3636 }
3637
3638 #ifdef _POSIX
3639 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3640 #endif
3641
3642 #ifdef _WIN
3643 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3644 #endif
3645 {
3646 hc_signal (NULL);
3647
3648 dictstat_t d;
3649
3650 d.cnt = 0;
3651
3652 #ifdef _POSIX
3653 fstat (fileno (fd), &d.stat);
3654 #endif
3655
3656 #ifdef _WIN
3657 _fstat64 (fileno (fd), &d.stat);
3658 #endif
3659
3660 d.stat.st_mode = 0;
3661 d.stat.st_nlink = 0;
3662 d.stat.st_uid = 0;
3663 d.stat.st_gid = 0;
3664 d.stat.st_rdev = 0;
3665 d.stat.st_atime = 0;
3666
3667 #ifdef _POSIX
3668 d.stat.st_blksize = 0;
3669 d.stat.st_blocks = 0;
3670 #endif
3671
3672 if (d.stat.st_size == 0) return 0;
3673
3674 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3675
3676 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3677 {
3678 if (d_cache)
3679 {
3680 u64 cnt = d_cache->cnt;
3681
3682 u64 keyspace = cnt;
3683
3684 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3685 {
3686 keyspace *= data.kernel_rules_cnt;
3687 }
3688 else if (data.attack_kern == ATTACK_KERN_COMBI)
3689 {
3690 keyspace *= data.combs_cnt;
3691 }
3692
3693 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);
3694 if (data.quiet == 0) log_info ("");
3695
3696 hc_signal (sigHandler_default);
3697
3698 return (keyspace);
3699 }
3700 }
3701
3702 time_t now = 0;
3703 time_t prev = 0;
3704
3705 u64 comp = 0;
3706 u64 cnt = 0;
3707 u64 cnt2 = 0;
3708
3709 while (!feof (fd))
3710 {
3711 load_segment (wl_data, fd);
3712
3713 comp += wl_data->cnt;
3714
3715 u32 i = 0;
3716
3717 while (i < wl_data->cnt)
3718 {
3719 u32 len;
3720 u32 off;
3721
3722 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3723
3724 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3725 {
3726 char rule_buf_out[BLOCK_SIZE] = { 0 };
3727
3728 int rule_len_out = -1;
3729
3730 if (len < BLOCK_SIZE)
3731 {
3732 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3733 }
3734
3735 if (rule_len_out < 0)
3736 {
3737 len = PW_MAX1;
3738 }
3739 else
3740 {
3741 len = rule_len_out;
3742 }
3743 }
3744
3745 if (len < PW_MAX1)
3746 {
3747 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3748 {
3749 cnt += data.kernel_rules_cnt;
3750 }
3751 else if (data.attack_kern == ATTACK_KERN_COMBI)
3752 {
3753 cnt += data.combs_cnt;
3754 }
3755
3756 d.cnt++;
3757 }
3758
3759 i += off;
3760
3761 cnt2++;
3762 }
3763
3764 time (&now);
3765
3766 if ((now - prev) == 0) continue;
3767
3768 float percent = (float) comp / (float) d.stat.st_size;
3769
3770 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);
3771
3772 time (&prev);
3773 }
3774
3775 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);
3776 if (data.quiet == 0) log_info ("");
3777
3778 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3779
3780 hc_signal (sigHandler_default);
3781
3782 return (cnt);
3783 }
3784
3785 static void *thread_monitor (void *p)
3786 {
3787 uint runtime_check = 0;
3788 uint remove_check = 0;
3789 uint status_check = 0;
3790 uint restore_check = 0;
3791
3792 uint restore_left = data.restore_timer;
3793 uint remove_left = data.remove_timer;
3794 uint status_left = data.status_timer;
3795
3796 #ifdef HAVE_HWMON
3797 uint hwmon_check = 0;
3798
3799 int slowdown_warnings = 0;
3800
3801 // these variables are mainly used for fan control
3802
3803 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3804
3805 // temperature controller "loopback" values
3806
3807 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3808 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3809
3810 int temp_threshold = 1; // degrees celcius
3811
3812 int fan_speed_min = 15; // in percentage
3813 int fan_speed_max = 100;
3814
3815 time_t last_temp_check_time;
3816 #endif // HAVE_HWMON
3817
3818 uint sleep_time = 1;
3819
3820 if (data.runtime)
3821 {
3822 runtime_check = 1;
3823 }
3824
3825 if (data.restore_timer)
3826 {
3827 restore_check = 1;
3828 }
3829
3830 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3831 {
3832 remove_check = 1;
3833 }
3834
3835 if (data.status == 1)
3836 {
3837 status_check = 1;
3838 }
3839
3840 #ifdef HAVE_HWMON
3841 if (data.gpu_temp_disable == 0)
3842 {
3843 time (&last_temp_check_time);
3844
3845 hwmon_check = 1;
3846 }
3847 #endif
3848
3849 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3850 {
3851 #ifdef HAVE_HWMON
3852 if (hwmon_check == 0)
3853 #endif
3854 return (p);
3855 }
3856
3857 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3858 {
3859 hc_sleep (sleep_time);
3860
3861 if (data.devices_status != STATUS_RUNNING) continue;
3862
3863 #ifdef HAVE_HWMON
3864
3865 if (hwmon_check == 1)
3866 {
3867 hc_thread_mutex_lock (mux_adl);
3868
3869 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3870 {
3871 hc_device_param_t *device_param = &data.devices_param[device_id];
3872
3873 if (device_param->skipped) continue;
3874
3875 if (device_param->device_vendor_id == VENDOR_ID_NV)
3876 {
3877 if (data.hm_nvapi)
3878 {
3879 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
3880 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
3881
3882 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
3883 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
3884
3885 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
3886
3887 perfPolicies_status.info_value = perfPolicies_info.info_value;
3888
3889 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
3890
3891 if (perfPolicies_status.throttle & 2)
3892 {
3893 if (slowdown_warnings < 3)
3894 {
3895 if (data.quiet == 0) clear_prompt ();
3896
3897 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
3898
3899 if (slowdown_warnings == 2)
3900 {
3901 log_info ("");
3902 }
3903
3904 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3905 if (data.quiet == 0) fflush (stdout);
3906
3907 slowdown_warnings++;
3908 }
3909 }
3910 else
3911 {
3912 slowdown_warnings = 0;
3913 }
3914 }
3915 }
3916 }
3917
3918 hc_thread_mutex_unlock (mux_adl);
3919 }
3920
3921 if (hwmon_check == 1)
3922 {
3923 hc_thread_mutex_lock (mux_adl);
3924
3925 time_t temp_check_time;
3926
3927 time (&temp_check_time);
3928
3929 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3930
3931 if (Ta == 0) Ta = 1;
3932
3933 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3934 {
3935 hc_device_param_t *device_param = &data.devices_param[device_id];
3936
3937 if (device_param->skipped) continue;
3938
3939 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3940
3941 const int temperature = hm_get_temperature_with_device_id (device_id);
3942
3943 if (temperature > (int) data.gpu_temp_abort)
3944 {
3945 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3946
3947 if (data.devices_status != STATUS_QUIT) myabort ();
3948
3949 break;
3950 }
3951
3952 const int gpu_temp_retain = data.gpu_temp_retain;
3953
3954 if (gpu_temp_retain)
3955 {
3956 if (data.hm_device[device_id].fan_set_supported == 1)
3957 {
3958 int temp_cur = temperature;
3959
3960 int temp_diff_new = gpu_temp_retain - temp_cur;
3961
3962 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3963
3964 // calculate Ta value (time difference in seconds between the last check and this check)
3965
3966 last_temp_check_time = temp_check_time;
3967
3968 float Kp = 1.8;
3969 float Ki = 0.005;
3970 float Kd = 6;
3971
3972 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3973
3974 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);
3975
3976 if (abs (fan_diff_required) >= temp_threshold)
3977 {
3978 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3979
3980 int fan_speed_level = fan_speed_cur;
3981
3982 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3983
3984 int fan_speed_new = fan_speed_level - fan_diff_required;
3985
3986 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3987 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3988
3989 if (fan_speed_new != fan_speed_cur)
3990 {
3991 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3992 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3993
3994 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3995 {
3996 if (device_param->device_vendor_id == VENDOR_ID_AMD)
3997 {
3998 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
3999 }
4000 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4001 {
4002
4003 }
4004
4005 fan_speed_chgd[device_id] = 1;
4006 }
4007
4008 temp_diff_old[device_id] = temp_diff_new;
4009 }
4010 }
4011 }
4012 }
4013 }
4014
4015 hc_thread_mutex_unlock (mux_adl);
4016 }
4017 #endif // HAVE_HWMON
4018
4019 if (restore_check == 1)
4020 {
4021 restore_left--;
4022
4023 if (restore_left == 0)
4024 {
4025 if (data.restore_disable == 0) cycle_restore ();
4026
4027 restore_left = data.restore_timer;
4028 }
4029 }
4030
4031 if ((runtime_check == 1) && (data.runtime_start > 0))
4032 {
4033 time_t runtime_cur;
4034
4035 time (&runtime_cur);
4036
4037 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4038
4039 if (runtime_left <= 0)
4040 {
4041 if (data.benchmark == 0)
4042 {
4043 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4044 }
4045
4046 if (data.devices_status != STATUS_QUIT) myabort ();
4047 }
4048 }
4049
4050 if (remove_check == 1)
4051 {
4052 remove_left--;
4053
4054 if (remove_left == 0)
4055 {
4056 if (data.digests_saved != data.digests_done)
4057 {
4058 data.digests_saved = data.digests_done;
4059
4060 save_hash ();
4061 }
4062
4063 remove_left = data.remove_timer;
4064 }
4065 }
4066
4067 if (status_check == 1)
4068 {
4069 status_left--;
4070
4071 if (status_left == 0)
4072 {
4073 //hc_thread_mutex_lock (mux_display);
4074
4075 if (data.quiet == 0) clear_prompt ();
4076
4077 if (data.quiet == 0) log_info ("");
4078
4079 status_display ();
4080
4081 if (data.quiet == 0) log_info ("");
4082
4083 //hc_thread_mutex_unlock (mux_display);
4084
4085 status_left = data.status_timer;
4086 }
4087 }
4088 }
4089
4090 #ifdef HAVE_HWMON
4091 myfree (fan_speed_chgd);
4092
4093 myfree (temp_diff_old);
4094 myfree (temp_diff_sum);
4095 #endif
4096
4097 p = NULL;
4098
4099 return (p);
4100 }
4101
4102 static void *thread_outfile_remove (void *p)
4103 {
4104 // some hash-dependent constants
4105 char *outfile_dir = data.outfile_check_directory;
4106 uint dgst_size = data.dgst_size;
4107 uint isSalted = data.isSalted;
4108 uint esalt_size = data.esalt_size;
4109 uint hash_mode = data.hash_mode;
4110
4111 uint outfile_check_timer = data.outfile_check_timer;
4112
4113 char separator = data.separator;
4114
4115 // some hash-dependent functions
4116 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4117 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4118
4119 // buffers
4120 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4121
4122 hash_buf.digest = mymalloc (dgst_size);
4123
4124 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4125
4126 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4127
4128 uint digest_buf[64] = { 0 };
4129
4130 outfile_data_t *out_info = NULL;
4131
4132 char **out_files = NULL;
4133
4134 time_t folder_mtime = 0;
4135
4136 int out_cnt = 0;
4137
4138 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4139
4140 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4141 {
4142 hc_sleep (1);
4143
4144 if (data.devices_status != STATUS_RUNNING) continue;
4145
4146 check_left--;
4147
4148 if (check_left == 0)
4149 {
4150 struct stat outfile_check_stat;
4151
4152 if (stat (outfile_dir, &outfile_check_stat) == 0)
4153 {
4154 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4155
4156 if (is_dir == 1)
4157 {
4158 if (outfile_check_stat.st_mtime > folder_mtime)
4159 {
4160 char **out_files_new = scan_directory (outfile_dir);
4161
4162 int out_cnt_new = count_dictionaries (out_files_new);
4163
4164 outfile_data_t *out_info_new = NULL;
4165
4166 if (out_cnt_new > 0)
4167 {
4168 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4169
4170 for (int i = 0; i < out_cnt_new; i++)
4171 {
4172 out_info_new[i].file_name = out_files_new[i];
4173
4174 // check if there are files that we have seen/checked before (and not changed)
4175
4176 for (int j = 0; j < out_cnt; j++)
4177 {
4178 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4179 {
4180 struct stat outfile_stat;
4181
4182 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4183 {
4184 if (outfile_stat.st_ctime == out_info[j].ctime)
4185 {
4186 out_info_new[i].ctime = out_info[j].ctime;
4187 out_info_new[i].seek = out_info[j].seek;
4188 }
4189 }
4190 }
4191 }
4192 }
4193 }
4194
4195 local_free (out_info);
4196 local_free (out_files);
4197
4198 out_files = out_files_new;
4199 out_cnt = out_cnt_new;
4200 out_info = out_info_new;
4201
4202 folder_mtime = outfile_check_stat.st_mtime;
4203 }
4204
4205 for (int j = 0; j < out_cnt; j++)
4206 {
4207 FILE *fp = fopen (out_info[j].file_name, "rb");
4208
4209 if (fp != NULL)
4210 {
4211 //hc_thread_mutex_lock (mux_display);
4212
4213 #ifdef _POSIX
4214 struct stat outfile_stat;
4215
4216 fstat (fileno (fp), &outfile_stat);
4217 #endif
4218
4219 #ifdef _WIN
4220 struct stat64 outfile_stat;
4221
4222 _fstat64 (fileno (fp), &outfile_stat);
4223 #endif
4224
4225 if (outfile_stat.st_ctime > out_info[j].ctime)
4226 {
4227 out_info[j].ctime = outfile_stat.st_ctime;
4228 out_info[j].seek = 0;
4229 }
4230
4231 fseek (fp, out_info[j].seek, SEEK_SET);
4232
4233 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4234
4235 while (!feof (fp))
4236 {
4237 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4238
4239 if (ptr == NULL) break;
4240
4241 int line_len = strlen (line_buf);
4242
4243 if (line_len <= 0) continue;
4244
4245 int iter = MAX_CUT_TRIES;
4246
4247 for (uint i = line_len - 1; i && iter; i--, line_len--)
4248 {
4249 if (line_buf[i] != separator) continue;
4250
4251 int parser_status = PARSER_OK;
4252
4253 if ((hash_mode != 2500) && (hash_mode != 6800))
4254 {
4255 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4256 }
4257
4258 uint found = 0;
4259
4260 if (parser_status == PARSER_OK)
4261 {
4262 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4263 {
4264 if (data.salts_shown[salt_pos] == 1) continue;
4265
4266 salt_t *salt_buf = &data.salts_buf[salt_pos];
4267
4268 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4269 {
4270 uint idx = salt_buf->digests_offset + digest_pos;
4271
4272 if (data.digests_shown[idx] == 1) continue;
4273
4274 uint cracked = 0;
4275
4276 if (hash_mode == 6800)
4277 {
4278 if (i == salt_buf->salt_len)
4279 {
4280 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4281 }
4282 }
4283 else if (hash_mode == 2500)
4284 {
4285 // BSSID : MAC1 : MAC2 (:plain)
4286 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4287 {
4288 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4289
4290 if (!cracked) continue;
4291
4292 // now compare MAC1 and MAC2 too, since we have this additional info
4293 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4294 char *mac2_pos = mac1_pos + 12 + 1;
4295
4296 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4297 wpa_t *wpa = &wpas[salt_pos];
4298
4299 // compare hex string(s) vs binary MAC address(es)
4300
4301 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4302 {
4303 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4304 {
4305 cracked = 0;
4306
4307 break;
4308 }
4309 }
4310
4311 // early skip ;)
4312 if (!cracked) continue;
4313
4314 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4315 {
4316 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4317 {
4318 cracked = 0;
4319
4320 break;
4321 }
4322 }
4323 }
4324 }
4325 else
4326 {
4327 char *digests_buf_ptr = (char *) data.digests_buf;
4328
4329 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4330
4331 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4332 }
4333
4334 if (cracked == 1)
4335 {
4336 found = 1;
4337
4338 data.digests_shown[idx] = 1;
4339
4340 data.digests_done++;
4341
4342 salt_buf->digests_done++;
4343
4344 if (salt_buf->digests_done == salt_buf->digests_cnt)
4345 {
4346 data.salts_shown[salt_pos] = 1;
4347
4348 data.salts_done++;
4349
4350 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4351 }
4352 }
4353 }
4354
4355 if (data.devices_status == STATUS_CRACKED) break;
4356 }
4357 }
4358
4359 if (found) break;
4360
4361 if (data.devices_status == STATUS_CRACKED) break;
4362
4363 iter--;
4364 }
4365
4366 if (data.devices_status == STATUS_CRACKED) break;
4367 }
4368
4369 myfree (line_buf);
4370
4371 out_info[j].seek = ftell (fp);
4372
4373 //hc_thread_mutex_unlock (mux_display);
4374
4375 fclose (fp);
4376 }
4377 }
4378 }
4379 }
4380
4381 check_left = outfile_check_timer;
4382 }
4383 }
4384
4385 if (esalt_size) local_free (hash_buf.esalt);
4386
4387 if (isSalted) local_free (hash_buf.salt);
4388
4389 local_free (hash_buf.digest);
4390
4391 local_free (out_info);
4392
4393 local_free (out_files);
4394
4395 p = NULL;
4396
4397 return (p);
4398 }
4399
4400 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4401 {
4402 //if (device_param->pws_cnt < device_param->kernel_power)
4403 //{
4404 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4405
4406 u8 *ptr = (u8 *) pw->i;
4407
4408 memcpy (ptr, pw_buf, pw_len);
4409
4410 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4411
4412 pw->pw_len = pw_len;
4413
4414 device_param->pws_cnt++;
4415 //}
4416 //else
4417 //{
4418 // fprintf (stderr, "BUG pw_add()!!\n");
4419 //
4420 // return;
4421 //}
4422 }
4423
4424 static void set_kernel_power_final (const u64 kernel_power_final)
4425 {
4426 if (data.quiet == 0)
4427 {
4428 clear_prompt ();
4429
4430 //log_info ("");
4431
4432 log_info ("INFO: approaching final keyspace, workload adjusted");
4433 log_info ("");
4434
4435 fprintf (stdout, "%s", PROMPT);
4436
4437 fflush (stdout);
4438 }
4439
4440 data.kernel_power_final = kernel_power_final;
4441 }
4442
4443 static u32 get_power (hc_device_param_t *device_param)
4444 {
4445 const u64 kernel_power_final = data.kernel_power_final;
4446
4447 if (kernel_power_final)
4448 {
4449 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4450
4451 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4452
4453 // work should be at least the hardware power available without any accelerator
4454
4455 const u64 work = MAX (words_left_device, device_param->hardware_power);
4456
4457 return work;
4458 }
4459
4460 return device_param->kernel_power;
4461 }
4462
4463 static uint get_work (hc_device_param_t *device_param, const u64 max)
4464 {
4465 hc_thread_mutex_lock (mux_dispatcher);
4466
4467 const u64 words_cur = data.words_cur;
4468 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4469
4470 device_param->words_off = words_cur;
4471
4472 const u64 kernel_power_all = data.kernel_power_all;
4473
4474 const u64 words_left = words_base - words_cur;
4475
4476 if (words_left < kernel_power_all)
4477 {
4478 if (data.kernel_power_final == 0)
4479 {
4480 set_kernel_power_final (words_left);
4481 }
4482 }
4483
4484 const u32 kernel_power = get_power (device_param);
4485
4486 uint work = MIN (words_left, kernel_power);
4487
4488 work = MIN (work, max);
4489
4490 data.words_cur += work;
4491
4492 hc_thread_mutex_unlock (mux_dispatcher);
4493
4494 return work;
4495 }
4496
4497 static void *thread_autotune (void *p)
4498 {
4499 hc_device_param_t *device_param = (hc_device_param_t *) p;
4500
4501 if (device_param->skipped) return NULL;
4502
4503 autotune (device_param);
4504
4505 return NULL;
4506 }
4507
4508 static void *thread_calc_stdin (void *p)
4509 {
4510 hc_device_param_t *device_param = (hc_device_param_t *) p;
4511
4512 if (device_param->skipped) return NULL;
4513
4514 char *buf = (char *) mymalloc (HCBUFSIZ);
4515
4516 const uint attack_kern = data.attack_kern;
4517
4518 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4519 {
4520 hc_thread_mutex_lock (mux_dispatcher);
4521
4522 if (feof (stdin) != 0)
4523 {
4524 hc_thread_mutex_unlock (mux_dispatcher);
4525
4526 break;
4527 }
4528
4529 uint words_cur = 0;
4530
4531 while (words_cur < device_param->kernel_power)
4532 {
4533 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4534
4535 if (line_buf == NULL) break;
4536
4537 uint line_len = in_superchop (line_buf);
4538
4539 line_len = convert_from_hex (line_buf, line_len);
4540
4541 // post-process rule engine
4542
4543 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4544 {
4545 char rule_buf_out[BLOCK_SIZE] = { 0 };
4546
4547 int rule_len_out = -1;
4548
4549 if (line_len < BLOCK_SIZE)
4550 {
4551 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4552 }
4553
4554 if (rule_len_out < 0) continue;
4555
4556 line_buf = rule_buf_out;
4557 line_len = rule_len_out;
4558 }
4559
4560 if (line_len > PW_MAX)
4561 {
4562 continue;
4563 }
4564
4565 // hmm that's always the case, or?
4566
4567 if (attack_kern == ATTACK_KERN_STRAIGHT)
4568 {
4569 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4570 {
4571 hc_thread_mutex_lock (mux_counter);
4572
4573 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4574 {
4575 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4576 }
4577
4578 hc_thread_mutex_unlock (mux_counter);
4579
4580 continue;
4581 }
4582 }
4583
4584 pw_add (device_param, (u8 *) line_buf, line_len);
4585
4586 words_cur++;
4587
4588 if (data.devices_status == STATUS_CRACKED) break;
4589 if (data.devices_status == STATUS_ABORTED) break;
4590 if (data.devices_status == STATUS_QUIT) break;
4591 if (data.devices_status == STATUS_BYPASS) break;
4592 }
4593
4594 hc_thread_mutex_unlock (mux_dispatcher);
4595
4596 if (data.devices_status == STATUS_CRACKED) break;
4597 if (data.devices_status == STATUS_ABORTED) break;
4598 if (data.devices_status == STATUS_QUIT) break;
4599 if (data.devices_status == STATUS_BYPASS) break;
4600
4601 // flush
4602
4603 const uint pws_cnt = device_param->pws_cnt;
4604
4605 if (pws_cnt)
4606 {
4607 run_copy (device_param, pws_cnt);
4608
4609 run_cracker (device_param, pws_cnt);
4610
4611 device_param->pws_cnt = 0;
4612
4613 /*
4614 still required?
4615 if (attack_kern == ATTACK_KERN_STRAIGHT)
4616 {
4617 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4618 }
4619 else if (attack_kern == ATTACK_KERN_COMBI)
4620 {
4621 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4622 }
4623 */
4624 }
4625 }
4626
4627 device_param->kernel_accel = 0;
4628 device_param->kernel_loops = 0;
4629
4630 myfree (buf);
4631
4632 return NULL;
4633 }
4634
4635 static void *thread_calc (void *p)
4636 {
4637 hc_device_param_t *device_param = (hc_device_param_t *) p;
4638
4639 if (device_param->skipped) return NULL;
4640
4641 const uint attack_mode = data.attack_mode;
4642 const uint attack_kern = data.attack_kern;
4643
4644 if (attack_mode == ATTACK_MODE_BF)
4645 {
4646 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4647 {
4648 const uint work = get_work (device_param, -1);
4649
4650 if (work == 0) break;
4651
4652 const u64 words_off = device_param->words_off;
4653 const u64 words_fin = words_off + work;
4654
4655 const uint pws_cnt = work;
4656
4657 device_param->pws_cnt = pws_cnt;
4658
4659 if (pws_cnt)
4660 {
4661 run_copy (device_param, pws_cnt);
4662
4663 run_cracker (device_param, pws_cnt);
4664
4665 device_param->pws_cnt = 0;
4666
4667 /*
4668 still required?
4669 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4670 */
4671 }
4672
4673 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4674
4675 if (data.devices_status == STATUS_CRACKED) break;
4676 if (data.devices_status == STATUS_ABORTED) break;
4677 if (data.devices_status == STATUS_QUIT) break;
4678 if (data.devices_status == STATUS_BYPASS) break;
4679
4680 if (data.benchmark == 1) break;
4681
4682 device_param->words_done = words_fin;
4683 }
4684 }
4685 else
4686 {
4687 const uint segment_size = data.segment_size;
4688
4689 char *dictfile = data.dictfile;
4690
4691 if (attack_mode == ATTACK_MODE_COMBI)
4692 {
4693 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4694 {
4695 dictfile = data.dictfile2;
4696 }
4697 }
4698
4699 FILE *fd = fopen (dictfile, "rb");
4700
4701 if (fd == NULL)
4702 {
4703 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4704
4705 return NULL;
4706 }
4707
4708 if (attack_mode == ATTACK_MODE_COMBI)
4709 {
4710 const uint combs_mode = data.combs_mode;
4711
4712 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4713 {
4714 const char *dictfilec = data.dictfile2;
4715
4716 FILE *combs_fp = fopen (dictfilec, "rb");
4717
4718 if (combs_fp == NULL)
4719 {
4720 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4721
4722 fclose (fd);
4723
4724 return NULL;
4725 }
4726
4727 device_param->combs_fp = combs_fp;
4728 }
4729 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4730 {
4731 const char *dictfilec = data.dictfile;
4732
4733 FILE *combs_fp = fopen (dictfilec, "rb");
4734
4735 if (combs_fp == NULL)
4736 {
4737 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4738
4739 fclose (fd);
4740
4741 return NULL;
4742 }
4743
4744 device_param->combs_fp = combs_fp;
4745 }
4746 }
4747
4748 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4749
4750 wl_data->buf = (char *) mymalloc (segment_size);
4751 wl_data->avail = segment_size;
4752 wl_data->incr = segment_size;
4753 wl_data->cnt = 0;
4754 wl_data->pos = 0;
4755
4756 u64 words_cur = 0;
4757
4758 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4759 {
4760 u64 words_off = 0;
4761 u64 words_fin = 0;
4762
4763 u64 max = -1;
4764
4765 while (max)
4766 {
4767 const uint work = get_work (device_param, max);
4768
4769 if (work == 0) break;
4770
4771 max = 0;
4772
4773 words_off = device_param->words_off;
4774 words_fin = words_off + work;
4775
4776 char *line_buf;
4777 uint line_len;
4778
4779 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4780
4781 for ( ; words_cur < words_fin; words_cur++)
4782 {
4783 get_next_word (wl_data, fd, &line_buf, &line_len);
4784
4785 line_len = convert_from_hex (line_buf, line_len);
4786
4787 // post-process rule engine
4788
4789 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4790 {
4791 char rule_buf_out[BLOCK_SIZE] = { 0 };
4792
4793 int rule_len_out = -1;
4794
4795 if (line_len < BLOCK_SIZE)
4796 {
4797 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4798 }
4799
4800 if (rule_len_out < 0) continue;
4801
4802 line_buf = rule_buf_out;
4803 line_len = rule_len_out;
4804 }
4805
4806 if (attack_kern == ATTACK_KERN_STRAIGHT)
4807 {
4808 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4809 {
4810 max++;
4811
4812 hc_thread_mutex_lock (mux_counter);
4813
4814 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4815 {
4816 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4817 }
4818
4819 hc_thread_mutex_unlock (mux_counter);
4820
4821 continue;
4822 }
4823 }
4824 else if (attack_kern == ATTACK_KERN_COMBI)
4825 {
4826 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4827 // since we still need to combine the plains
4828
4829 if (line_len > data.pw_max)
4830 {
4831 max++;
4832
4833 hc_thread_mutex_lock (mux_counter);
4834
4835 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4836 {
4837 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4838 }
4839
4840 hc_thread_mutex_unlock (mux_counter);
4841
4842 continue;
4843 }
4844 }
4845
4846 pw_add (device_param, (u8 *) line_buf, line_len);
4847
4848 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4849
4850 if (data.devices_status == STATUS_CRACKED) break;
4851 if (data.devices_status == STATUS_ABORTED) break;
4852 if (data.devices_status == STATUS_QUIT) break;
4853 if (data.devices_status == STATUS_BYPASS) break;
4854 }
4855
4856 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4857
4858 if (data.devices_status == STATUS_CRACKED) break;
4859 if (data.devices_status == STATUS_ABORTED) break;
4860 if (data.devices_status == STATUS_QUIT) break;
4861 if (data.devices_status == STATUS_BYPASS) break;
4862 }
4863
4864 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4865
4866 if (data.devices_status == STATUS_CRACKED) break;
4867 if (data.devices_status == STATUS_ABORTED) break;
4868 if (data.devices_status == STATUS_QUIT) break;
4869 if (data.devices_status == STATUS_BYPASS) break;
4870
4871 //
4872 // flush
4873 //
4874
4875 const uint pws_cnt = device_param->pws_cnt;
4876
4877 if (pws_cnt)
4878 {
4879 run_copy (device_param, pws_cnt);
4880
4881 run_cracker (device_param, pws_cnt);
4882
4883 device_param->pws_cnt = 0;
4884
4885 /*
4886 still required?
4887 if (attack_kern == ATTACK_KERN_STRAIGHT)
4888 {
4889 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4890 }
4891 else if (attack_kern == ATTACK_KERN_COMBI)
4892 {
4893 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4894 }
4895 */
4896 }
4897
4898 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4899
4900 if (data.devices_status == STATUS_CRACKED) break;
4901 if (data.devices_status == STATUS_ABORTED) break;
4902 if (data.devices_status == STATUS_QUIT) break;
4903 if (data.devices_status == STATUS_BYPASS) break;
4904
4905 if (words_fin == 0) break;
4906
4907 device_param->words_done = words_fin;
4908 }
4909
4910 if (attack_mode == ATTACK_MODE_COMBI)
4911 {
4912 fclose (device_param->combs_fp);
4913 }
4914
4915 free (wl_data->buf);
4916 free (wl_data);
4917
4918 fclose (fd);
4919 }
4920
4921 device_param->kernel_accel = 0;
4922 device_param->kernel_loops = 0;
4923
4924 return NULL;
4925 }
4926
4927 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4928 {
4929 if (!device_param)
4930 {
4931 log_error ("ERROR: %s : Invalid argument", __func__);
4932
4933 exit (-1);
4934 }
4935
4936 salt_t *salt_buf = &data.salts_buf[salt_pos];
4937
4938 device_param->kernel_params_buf32[24] = salt_pos;
4939 device_param->kernel_params_buf32[27] = 1;
4940 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4941 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4942 device_param->kernel_params_buf32[30] = 0;
4943 device_param->kernel_params_buf32[31] = 1;
4944
4945 char *dictfile_old = data.dictfile;
4946
4947 const char *weak_hash_check = "weak-hash-check";
4948
4949 data.dictfile = (char *) weak_hash_check;
4950
4951 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4952
4953 data.kernel_rules_buf[0].cmds[0] = 0;
4954
4955 /**
4956 * run the kernel
4957 */
4958
4959 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4960 {
4961 run_kernel (KERN_RUN_1, device_param, 1, false);
4962 }
4963 else
4964 {
4965 run_kernel (KERN_RUN_1, device_param, 1, false);
4966
4967 uint loop_step = 16;
4968
4969 const uint iter = salt_buf->salt_iter;
4970
4971 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4972 {
4973 uint loop_left = iter - loop_pos;
4974
4975 loop_left = MIN (loop_left, loop_step);
4976
4977 device_param->kernel_params_buf32[25] = loop_pos;
4978 device_param->kernel_params_buf32[26] = loop_left;
4979
4980 run_kernel (KERN_RUN_2, device_param, 1, false);
4981 }
4982
4983 run_kernel (KERN_RUN_3, device_param, 1, false);
4984 }
4985
4986 /**
4987 * result
4988 */
4989
4990 check_cracked (device_param, salt_pos);
4991
4992 /**
4993 * cleanup
4994 */
4995
4996 device_param->kernel_params_buf32[24] = 0;
4997 device_param->kernel_params_buf32[25] = 0;
4998 device_param->kernel_params_buf32[26] = 0;
4999 device_param->kernel_params_buf32[27] = 0;
5000 device_param->kernel_params_buf32[28] = 0;
5001 device_param->kernel_params_buf32[29] = 0;
5002 device_param->kernel_params_buf32[30] = 0;
5003 device_param->kernel_params_buf32[31] = 0;
5004
5005 data.dictfile = dictfile_old;
5006
5007 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5008 }
5009
5010 // hlfmt hashcat
5011
5012 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5013 {
5014 if (data.username == 0)
5015 {
5016 *hashbuf_pos = line_buf;
5017 *hashbuf_len = line_len;
5018 }
5019 else
5020 {
5021 char *pos = line_buf;
5022 int len = line_len;
5023
5024 for (int i = 0; i < line_len; i++, pos++, len--)
5025 {
5026 if (line_buf[i] == data.separator)
5027 {
5028 pos++;
5029
5030 len--;
5031
5032 break;
5033 }
5034 }
5035
5036 *hashbuf_pos = pos;
5037 *hashbuf_len = len;
5038 }
5039 }
5040
5041 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5042 {
5043 char *pos = NULL;
5044 int len = 0;
5045
5046 int sep_cnt = 0;
5047
5048 for (int i = 0; i < line_len; i++)
5049 {
5050 if (line_buf[i] == data.separator)
5051 {
5052 sep_cnt++;
5053
5054 continue;
5055 }
5056
5057 if (sep_cnt == 0)
5058 {
5059 if (pos == NULL) pos = line_buf + i;
5060
5061 len++;
5062 }
5063 }
5064
5065 *userbuf_pos = pos;
5066 *userbuf_len = len;
5067 }
5068
5069 // hlfmt pwdump
5070
5071 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5072 {
5073 int sep_cnt = 0;
5074
5075 int sep2_len = 0;
5076 int sep3_len = 0;
5077
5078 for (int i = 0; i < line_len; i++)
5079 {
5080 if (line_buf[i] == ':')
5081 {
5082 sep_cnt++;
5083
5084 continue;
5085 }
5086
5087 if (sep_cnt == 2) sep2_len++;
5088 if (sep_cnt == 3) sep3_len++;
5089 }
5090
5091 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5092
5093 return 0;
5094 }
5095
5096 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5097 {
5098 char *pos = NULL;
5099 int len = 0;
5100
5101 int sep_cnt = 0;
5102
5103 for (int i = 0; i < line_len; i++)
5104 {
5105 if (line_buf[i] == ':')
5106 {
5107 sep_cnt++;
5108
5109 continue;
5110 }
5111
5112 if (data.hash_mode == 1000)
5113 {
5114 if (sep_cnt == 3)
5115 {
5116 if (pos == NULL) pos = line_buf + i;
5117
5118 len++;
5119 }
5120 }
5121 else if (data.hash_mode == 3000)
5122 {
5123 if (sep_cnt == 2)
5124 {
5125 if (pos == NULL) pos = line_buf + i;
5126
5127 len++;
5128 }
5129 }
5130 }
5131
5132 *hashbuf_pos = pos;
5133 *hashbuf_len = len;
5134 }
5135
5136 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5137 {
5138 char *pos = NULL;
5139 int len = 0;
5140
5141 int sep_cnt = 0;
5142
5143 for (int i = 0; i < line_len; i++)
5144 {
5145 if (line_buf[i] == ':')
5146 {
5147 sep_cnt++;
5148
5149 continue;
5150 }
5151
5152 if (sep_cnt == 0)
5153 {
5154 if (pos == NULL) pos = line_buf + i;
5155
5156 len++;
5157 }
5158 }
5159
5160 *userbuf_pos = pos;
5161 *userbuf_len = len;
5162 }
5163
5164 // hlfmt passwd
5165
5166 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5167 {
5168 int sep_cnt = 0;
5169
5170 char sep5_first = 0;
5171 char sep6_first = 0;
5172
5173 for (int i = 0; i < line_len; i++)
5174 {
5175 if (line_buf[i] == ':')
5176 {
5177 sep_cnt++;
5178
5179 continue;
5180 }
5181
5182 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5183 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5184 }
5185
5186 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5187
5188 return 0;
5189 }
5190
5191 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5192 {
5193 char *pos = NULL;
5194 int len = 0;
5195
5196 int sep_cnt = 0;
5197
5198 for (int i = 0; i < line_len; i++)
5199 {
5200 if (line_buf[i] == ':')
5201 {
5202 sep_cnt++;
5203
5204 continue;
5205 }
5206
5207 if (sep_cnt == 1)
5208 {
5209 if (pos == NULL) pos = line_buf + i;
5210
5211 len++;
5212 }
5213 }
5214
5215 *hashbuf_pos = pos;
5216 *hashbuf_len = len;
5217 }
5218
5219 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5220 {
5221 char *pos = NULL;
5222 int len = 0;
5223
5224 int sep_cnt = 0;
5225
5226 for (int i = 0; i < line_len; i++)
5227 {
5228 if (line_buf[i] == ':')
5229 {
5230 sep_cnt++;
5231
5232 continue;
5233 }
5234
5235 if (sep_cnt == 0)
5236 {
5237 if (pos == NULL) pos = line_buf + i;
5238
5239 len++;
5240 }
5241 }
5242
5243 *userbuf_pos = pos;
5244 *userbuf_len = len;
5245 }
5246
5247 // hlfmt shadow
5248
5249 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5250 {
5251 int sep_cnt = 0;
5252
5253 for (int i = 0; i < line_len; i++)
5254 {
5255 if (line_buf[i] == ':') sep_cnt++;
5256 }
5257
5258 if (sep_cnt == 8) return 1;
5259
5260 return 0;
5261 }
5262
5263 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5264 {
5265 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5266 }
5267
5268 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5269 {
5270 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5271 }
5272
5273 // hlfmt main
5274
5275 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5276 {
5277 switch (hashfile_format)
5278 {
5279 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5280 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5281 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5282 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5283 }
5284 }
5285
5286 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5287 {
5288 switch (hashfile_format)
5289 {
5290 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5291 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5292 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5293 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5294 }
5295 }
5296
5297 char *strhlfmt (const uint hashfile_format)
5298 {
5299 switch (hashfile_format)
5300 {
5301 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5302 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5303 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5304 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5305 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5306 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5307 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5308 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5309 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5310 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5311 }
5312
5313 return ((char *) "Unknown");
5314 }
5315
5316 static uint hlfmt_detect (FILE *fp, uint max_check)
5317 {
5318 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5319
5320 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5321 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5322
5323 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5324
5325 uint num_check = 0;
5326
5327 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5328
5329 while (!feof (fp))
5330 {
5331 int line_len = fgetl (fp, line_buf);
5332
5333 if (line_len == 0) continue;
5334
5335 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5336 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5337 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5338
5339 if (num_check == max_check) break;
5340
5341 num_check++;
5342 }
5343
5344 myfree (line_buf);
5345
5346 uint hashlist_format = HLFMT_HASHCAT;
5347
5348 for (int i = 1; i < HLFMTS_CNT; i++)
5349 {
5350 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5351
5352 hashlist_format = i;
5353 }
5354
5355 free (formats_cnt);
5356
5357 return hashlist_format;
5358 }
5359
5360 /**
5361 * some further helper function
5362 */
5363
5364 // wrapper around mymalloc for ADL
5365
5366 #if defined(HAVE_HWMON)
5367 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5368 {
5369 return mymalloc (iSize);
5370 }
5371 #endif
5372
5373 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)
5374 {
5375 u64 collisions = 0;
5376
5377 const uint dgst_pos0 = data.dgst_pos0;
5378 const uint dgst_pos1 = data.dgst_pos1;
5379 const uint dgst_pos2 = data.dgst_pos2;
5380 const uint dgst_pos3 = data.dgst_pos3;
5381
5382 memset (bitmap_a, 0, bitmap_size);
5383 memset (bitmap_b, 0, bitmap_size);
5384 memset (bitmap_c, 0, bitmap_size);
5385 memset (bitmap_d, 0, bitmap_size);
5386
5387 for (uint i = 0; i < digests_cnt; i++)
5388 {
5389 uint *digest_ptr = (uint *) digests_buf_ptr;
5390
5391 digests_buf_ptr += dgst_size;
5392
5393 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5394 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5395 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5396 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5397
5398 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5399 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5400 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5401 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5402
5403 if (bitmap_a[idx0] & val0) collisions++;
5404 if (bitmap_b[idx1] & val1) collisions++;
5405 if (bitmap_c[idx2] & val2) collisions++;
5406 if (bitmap_d[idx3] & val3) collisions++;
5407
5408 bitmap_a[idx0] |= val0;
5409 bitmap_b[idx1] |= val1;
5410 bitmap_c[idx2] |= val2;
5411 bitmap_d[idx3] |= val3;
5412
5413 if (collisions >= collisions_max) return 0x7fffffff;
5414 }
5415
5416 return collisions;
5417 }
5418
5419 /**
5420 * main
5421 */
5422
5423 #ifdef _WIN
5424 void SetConsoleWindowSize (const int x)
5425 {
5426 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5427
5428 if (h == INVALID_HANDLE_VALUE) return;
5429
5430 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5431
5432 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5433
5434 SMALL_RECT *sr = &bufferInfo.srWindow;
5435
5436 sr->Right = MAX (sr->Right, x - 1);
5437
5438 COORD co;
5439
5440 co.X = sr->Right + 1;
5441 co.Y = 9999;
5442
5443 if (!SetConsoleScreenBufferSize (h, co)) return;
5444
5445 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5446 }
5447 #endif
5448
5449 int main (int argc, char **argv)
5450 {
5451 #ifdef _WIN
5452 SetConsoleWindowSize (132);
5453 #endif
5454
5455 /**
5456 * To help users a bit
5457 */
5458
5459 char *compute = getenv ("COMPUTE");
5460
5461 if (compute)
5462 {
5463 static char display[100];
5464
5465 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5466
5467 putenv (display);
5468 }
5469 else
5470 {
5471 if (getenv ("DISPLAY") == NULL)
5472 putenv ((char *) "DISPLAY=:0");
5473 }
5474
5475 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5476 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5477
5478 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5479 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5480
5481 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5482 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5483
5484 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5485 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5486
5487 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5488 putenv ((char *) "POCL_KERNEL_CACHE=0");
5489
5490 umask (077);
5491
5492 /**
5493 * Real init
5494 */
5495
5496 memset (&data, 0, sizeof (hc_global_data_t));
5497
5498 time_t proc_start;
5499
5500 time (&proc_start);
5501
5502 data.proc_start = proc_start;
5503
5504 int myargc = argc;
5505 char **myargv = argv;
5506
5507 hc_thread_mutex_init (mux_dispatcher);
5508 hc_thread_mutex_init (mux_counter);
5509 hc_thread_mutex_init (mux_display);
5510 hc_thread_mutex_init (mux_adl);
5511
5512 /**
5513 * commandline parameters
5514 */
5515
5516 uint usage = USAGE;
5517 uint version = VERSION;
5518 uint quiet = QUIET;
5519 uint benchmark = BENCHMARK;
5520 uint show = SHOW;
5521 uint left = LEFT;
5522 uint username = USERNAME;
5523 uint remove = REMOVE;
5524 uint remove_timer = REMOVE_TIMER;
5525 u64 skip = SKIP;
5526 u64 limit = LIMIT;
5527 uint keyspace = KEYSPACE;
5528 uint potfile_disable = POTFILE_DISABLE;
5529 char *potfile_path = NULL;
5530 uint debug_mode = DEBUG_MODE;
5531 char *debug_file = NULL;
5532 char *induction_dir = NULL;
5533 char *outfile_check_dir = NULL;
5534 uint force = FORCE;
5535 uint runtime = RUNTIME;
5536 uint hash_mode = HASH_MODE;
5537 uint attack_mode = ATTACK_MODE;
5538 uint markov_disable = MARKOV_DISABLE;
5539 uint markov_classic = MARKOV_CLASSIC;
5540 uint markov_threshold = MARKOV_THRESHOLD;
5541 char *markov_hcstat = NULL;
5542 char *outfile = NULL;
5543 uint outfile_format = OUTFILE_FORMAT;
5544 uint outfile_autohex = OUTFILE_AUTOHEX;
5545 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5546 uint restore = RESTORE;
5547 uint restore_timer = RESTORE_TIMER;
5548 uint restore_disable = RESTORE_DISABLE;
5549 uint status = STATUS;
5550 uint status_timer = STATUS_TIMER;
5551 uint machine_readable = MACHINE_READABLE;
5552 uint loopback = LOOPBACK;
5553 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5554 char *session = NULL;
5555 uint hex_charset = HEX_CHARSET;
5556 uint hex_salt = HEX_SALT;
5557 uint hex_wordlist = HEX_WORDLIST;
5558 uint rp_gen = RP_GEN;
5559 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5560 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5561 uint rp_gen_seed = RP_GEN_SEED;
5562 char *rule_buf_l = (char *) RULE_BUF_L;
5563 char *rule_buf_r = (char *) RULE_BUF_R;
5564 uint increment = INCREMENT;
5565 uint increment_min = INCREMENT_MIN;
5566 uint increment_max = INCREMENT_MAX;
5567 char *cpu_affinity = NULL;
5568 OCL_PTR *ocl = NULL;
5569 char *opencl_devices = NULL;
5570 char *opencl_platforms = NULL;
5571 char *opencl_device_types = NULL;
5572 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5573 char *truecrypt_keyfiles = NULL;
5574 char *veracrypt_keyfiles = NULL;
5575 uint veracrypt_pim = 0;
5576 uint workload_profile = WORKLOAD_PROFILE;
5577 uint kernel_accel = KERNEL_ACCEL;
5578 uint kernel_loops = KERNEL_LOOPS;
5579 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5580 #ifdef HAVE_HWMON
5581 uint gpu_temp_abort = GPU_TEMP_ABORT;
5582 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5583 uint powertune_enable = POWERTUNE_ENABLE;
5584 #endif
5585 uint logfile_disable = LOGFILE_DISABLE;
5586 uint segment_size = SEGMENT_SIZE;
5587 uint scrypt_tmto = SCRYPT_TMTO;
5588 char separator = SEPARATOR;
5589 uint bitmap_min = BITMAP_MIN;
5590 uint bitmap_max = BITMAP_MAX;
5591 char *custom_charset_1 = NULL;
5592 char *custom_charset_2 = NULL;
5593 char *custom_charset_3 = NULL;
5594 char *custom_charset_4 = NULL;
5595
5596 #define IDX_HELP 'h'
5597 #define IDX_VERSION 'V'
5598 #define IDX_VERSION_LOWER 'v'
5599 #define IDX_QUIET 0xff02
5600 #define IDX_SHOW 0xff03
5601 #define IDX_LEFT 0xff04
5602 #define IDX_REMOVE 0xff05
5603 #define IDX_REMOVE_TIMER 0xff37
5604 #define IDX_SKIP 's'
5605 #define IDX_LIMIT 'l'
5606 #define IDX_KEYSPACE 0xff35
5607 #define IDX_POTFILE_DISABLE 0xff06
5608 #define IDX_POTFILE_PATH 0xffe0
5609 #define IDX_DEBUG_MODE 0xff43
5610 #define IDX_DEBUG_FILE 0xff44
5611 #define IDX_INDUCTION_DIR 0xff46
5612 #define IDX_OUTFILE_CHECK_DIR 0xff47
5613 #define IDX_USERNAME 0xff07
5614 #define IDX_FORCE 0xff08
5615 #define IDX_RUNTIME 0xff09
5616 #define IDX_BENCHMARK 'b'
5617 #define IDX_HASH_MODE 'm'
5618 #define IDX_ATTACK_MODE 'a'
5619 #define IDX_RP_FILE 'r'
5620 #define IDX_RP_GEN 'g'
5621 #define IDX_RP_GEN_FUNC_MIN 0xff10
5622 #define IDX_RP_GEN_FUNC_MAX 0xff11
5623 #define IDX_RP_GEN_SEED 0xff34
5624 #define IDX_RULE_BUF_L 'j'
5625 #define IDX_RULE_BUF_R 'k'
5626 #define IDX_INCREMENT 'i'
5627 #define IDX_INCREMENT_MIN 0xff12
5628 #define IDX_INCREMENT_MAX 0xff13
5629 #define IDX_OUTFILE 'o'
5630 #define IDX_OUTFILE_FORMAT 0xff14
5631 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5632 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5633 #define IDX_RESTORE 0xff15
5634 #define IDX_RESTORE_DISABLE 0xff27
5635 #define IDX_STATUS 0xff17
5636 #define IDX_STATUS_TIMER 0xff18
5637 #define IDX_MACHINE_READABLE 0xff50
5638 #define IDX_LOOPBACK 0xff38
5639 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5640 #define IDX_SESSION 0xff19
5641 #define IDX_HEX_CHARSET 0xff20
5642 #define IDX_HEX_SALT 0xff21
5643 #define IDX_HEX_WORDLIST 0xff40
5644 #define IDX_MARKOV_DISABLE 0xff22
5645 #define IDX_MARKOV_CLASSIC 0xff23
5646 #define IDX_MARKOV_THRESHOLD 't'
5647 #define IDX_MARKOV_HCSTAT 0xff24
5648 #define IDX_CPU_AFFINITY 0xff25
5649 #define IDX_OPENCL_DEVICES 'd'
5650 #define IDX_OPENCL_PLATFORMS 0xff72
5651 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5652 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5653 #define IDX_WORKLOAD_PROFILE 'w'
5654 #define IDX_KERNEL_ACCEL 'n'
5655 #define IDX_KERNEL_LOOPS 'u'
5656 #define IDX_GPU_TEMP_DISABLE 0xff29
5657 #define IDX_GPU_TEMP_ABORT 0xff30
5658 #define IDX_GPU_TEMP_RETAIN 0xff31
5659 #define IDX_POWERTUNE_ENABLE 0xff41
5660 #define IDX_LOGFILE_DISABLE 0xff51
5661 #define IDX_TRUECRYPT_KEYFILES 0xff52
5662 #define IDX_VERACRYPT_KEYFILES 0xff53
5663 #define IDX_VERACRYPT_PIM 0xff54
5664 #define IDX_SCRYPT_TMTO 0xff61
5665 #define IDX_SEGMENT_SIZE 'c'
5666 #define IDX_SEPARATOR 'p'
5667 #define IDX_BITMAP_MIN 0xff70
5668 #define IDX_BITMAP_MAX 0xff71
5669 #define IDX_CUSTOM_CHARSET_1 '1'
5670 #define IDX_CUSTOM_CHARSET_2 '2'
5671 #define IDX_CUSTOM_CHARSET_3 '3'
5672 #define IDX_CUSTOM_CHARSET_4 '4'
5673
5674 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5675
5676 struct option long_options[] =
5677 {
5678 {"help", no_argument, 0, IDX_HELP},
5679 {"version", no_argument, 0, IDX_VERSION},
5680 {"quiet", no_argument, 0, IDX_QUIET},
5681 {"show", no_argument, 0, IDX_SHOW},
5682 {"left", no_argument, 0, IDX_LEFT},
5683 {"username", no_argument, 0, IDX_USERNAME},
5684 {"remove", no_argument, 0, IDX_REMOVE},
5685 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5686 {"skip", required_argument, 0, IDX_SKIP},
5687 {"limit", required_argument, 0, IDX_LIMIT},
5688 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5689 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5690 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5691 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5692 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5693 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5694 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5695 {"force", no_argument, 0, IDX_FORCE},
5696 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5697 {"restore", no_argument, 0, IDX_RESTORE},
5698 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5699 {"status", no_argument, 0, IDX_STATUS},
5700 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5701 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5702 {"loopback", no_argument, 0, IDX_LOOPBACK},
5703 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5704 {"session", required_argument, 0, IDX_SESSION},
5705 {"runtime", required_argument, 0, IDX_RUNTIME},
5706 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5707 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5708 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5709 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5710 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5711 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5712 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5713 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5714 {"rules-file", required_argument, 0, IDX_RP_FILE},
5715 {"outfile", required_argument, 0, IDX_OUTFILE},
5716 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5717 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5718 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5719 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5720 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5721 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5722 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5723 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5724 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5725 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5726 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5727 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5728 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5729 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5730 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5731 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5732 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5733 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5734 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5735 #ifdef HAVE_HWMON
5736 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5737 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5738 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5739 #endif // HAVE_HWMON
5740 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5741 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5742 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5743 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5744 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5745 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5746 {"seperator", required_argument, 0, IDX_SEPARATOR},
5747 {"separator", required_argument, 0, IDX_SEPARATOR},
5748 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5749 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5750 {"increment", no_argument, 0, IDX_INCREMENT},
5751 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5752 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5753 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5754 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5755 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5756 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5757 {0, 0, 0, 0}
5758 };
5759
5760 uint rp_files_cnt = 0;
5761
5762 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5763
5764 int option_index = 0;
5765 int c = -1;
5766
5767 optind = 1;
5768 optopt = 0;
5769
5770 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5771 {
5772 switch (c)
5773 {
5774 case IDX_HELP: usage = 1; break;
5775 case IDX_VERSION:
5776 case IDX_VERSION_LOWER: version = 1; break;
5777 case IDX_RESTORE: restore = 1; break;
5778 case IDX_SESSION: session = optarg; break;
5779 case IDX_SHOW: show = 1; break;
5780 case IDX_LEFT: left = 1; break;
5781 case '?': return (-1);
5782 }
5783 }
5784
5785 if (optopt != 0)
5786 {
5787 log_error ("ERROR: Invalid argument specified");
5788
5789 return (-1);
5790 }
5791
5792 /**
5793 * exit functions
5794 */
5795
5796 if (version)
5797 {
5798 log_info ("%s", VERSION_TAG);
5799
5800 return (0);
5801 }
5802
5803 if (usage)
5804 {
5805 usage_big_print (PROGNAME);
5806
5807 return (0);
5808 }
5809
5810 /**
5811 * session needs to be set, always!
5812 */
5813
5814 if (session == NULL) session = (char *) PROGNAME;
5815
5816 /**
5817 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5818 */
5819
5820 char *exec_path = get_exec_path ();
5821
5822 #ifdef LINUX
5823
5824 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5825 char *resolved_exec_path = realpath (exec_path, NULL);
5826
5827 char *install_dir = get_install_dir (resolved_exec_path);
5828 char *profile_dir = NULL;
5829 char *session_dir = NULL;
5830 char *shared_dir = NULL;
5831
5832 if (strcmp (install_dir, resolved_install_folder) == 0)
5833 {
5834 struct passwd *pw = getpwuid (getuid ());
5835
5836 const char *homedir = pw->pw_dir;
5837
5838 profile_dir = get_profile_dir (homedir);
5839 session_dir = get_session_dir (profile_dir);
5840 shared_dir = strdup (SHARED_FOLDER);
5841
5842 mkdir (profile_dir, 0700);
5843 mkdir (session_dir, 0700);
5844 }
5845 else
5846 {
5847 profile_dir = install_dir;
5848 session_dir = install_dir;
5849 shared_dir = install_dir;
5850 }
5851
5852 myfree (resolved_install_folder);
5853 myfree (resolved_exec_path);
5854
5855 #else
5856
5857 char *install_dir = get_install_dir (exec_path);
5858 char *profile_dir = install_dir;
5859 char *session_dir = install_dir;
5860 char *shared_dir = install_dir;
5861
5862 #endif
5863
5864 data.install_dir = install_dir;
5865 data.profile_dir = profile_dir;
5866 data.session_dir = session_dir;
5867 data.shared_dir = shared_dir;
5868
5869 myfree (exec_path);
5870
5871 /**
5872 * kernel cache, we need to make sure folder exist
5873 */
5874
5875 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5876
5877 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5878
5879 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5880
5881 mkdir (kernels_folder, 0700);
5882
5883 myfree (kernels_folder);
5884
5885 /**
5886 * session
5887 */
5888
5889 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5890
5891 data.session = session;
5892
5893 char *eff_restore_file = (char *) mymalloc (session_size);
5894 char *new_restore_file = (char *) mymalloc (session_size);
5895
5896 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5897 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5898
5899 data.eff_restore_file = eff_restore_file;
5900 data.new_restore_file = new_restore_file;
5901
5902 if (((show == 1) || (left == 1)) && (restore == 1))
5903 {
5904 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5905 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5906
5907 return (-1);
5908 }
5909
5910 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5911 if ((show == 1) || (left == 1))
5912 {
5913 restore_disable = 1;
5914
5915 restore = 0;
5916 }
5917
5918 data.restore_disable = restore_disable;
5919
5920 restore_data_t *rd = init_restore (argc, argv);
5921
5922 data.rd = rd;
5923
5924 /**
5925 * restore file
5926 */
5927
5928 if (restore == 1)
5929 {
5930 read_restore (eff_restore_file, rd);
5931
5932 if (rd->version_bin < RESTORE_MIN)
5933 {
5934 log_error ("ERROR: Incompatible restore-file version");
5935
5936 return (-1);
5937 }
5938
5939 myargc = rd->argc;
5940 myargv = rd->argv;
5941
5942 #ifdef _POSIX
5943 rd->pid = getpid ();
5944 #elif _WIN
5945 rd->pid = GetCurrentProcessId ();
5946 #endif
5947 }
5948
5949 uint hash_mode_chgd = 0;
5950 uint runtime_chgd = 0;
5951 uint kernel_loops_chgd = 0;
5952 uint kernel_accel_chgd = 0;
5953 uint attack_mode_chgd = 0;
5954 uint outfile_format_chgd = 0;
5955 uint rp_gen_seed_chgd = 0;
5956 uint remove_timer_chgd = 0;
5957 uint increment_min_chgd = 0;
5958 uint increment_max_chgd = 0;
5959 uint workload_profile_chgd = 0;
5960 uint opencl_vector_width_chgd = 0;
5961
5962 optind = 1;
5963 optopt = 0;
5964 option_index = 0;
5965
5966 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5967 {
5968 switch (c)
5969 {
5970 //case IDX_HELP: usage = 1; break;
5971 //case IDX_VERSION: version = 1; break;
5972 //case IDX_RESTORE: restore = 1; break;
5973 case IDX_QUIET: quiet = 1; break;
5974 //case IDX_SHOW: show = 1; break;
5975 case IDX_SHOW: break;
5976 //case IDX_LEFT: left = 1; break;
5977 case IDX_LEFT: break;
5978 case IDX_USERNAME: username = 1; break;
5979 case IDX_REMOVE: remove = 1; break;
5980 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5981 remove_timer_chgd = 1; break;
5982 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5983 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5984 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5985 case IDX_DEBUG_FILE: debug_file = optarg; break;
5986 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5987 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5988 case IDX_FORCE: force = 1; break;
5989 case IDX_SKIP: skip = atoll (optarg); break;
5990 case IDX_LIMIT: limit = atoll (optarg); break;
5991 case IDX_KEYSPACE: keyspace = 1; break;
5992 case IDX_BENCHMARK: benchmark = 1; break;
5993 case IDX_RESTORE: break;
5994 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5995 case IDX_STATUS: status = 1; break;
5996 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5997 case IDX_MACHINE_READABLE: machine_readable = 1; break;
5998 case IDX_LOOPBACK: loopback = 1; break;
5999 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6000 //case IDX_SESSION: session = optarg; break;
6001 case IDX_SESSION: break;
6002 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6003 hash_mode_chgd = 1; break;
6004 case IDX_RUNTIME: runtime = atoi (optarg);
6005 runtime_chgd = 1; break;
6006 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6007 attack_mode_chgd = 1; break;
6008 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6009 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6010 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6011 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6012 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6013 rp_gen_seed_chgd = 1; break;
6014 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6015 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6016 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6017 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6018 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6019 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6020 case IDX_OUTFILE: outfile = optarg; break;
6021 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6022 outfile_format_chgd = 1; break;
6023 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6024 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6025 case IDX_HEX_CHARSET: hex_charset = 1; break;
6026 case IDX_HEX_SALT: hex_salt = 1; break;
6027 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6028 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6029 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6030 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6031 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6032 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6033 opencl_vector_width_chgd = 1; break;
6034 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6035 workload_profile_chgd = 1; break;
6036 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6037 kernel_accel_chgd = 1; break;
6038 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6039 kernel_loops_chgd = 1; break;
6040 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6041 #ifdef HAVE_HWMON
6042 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6043 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6044 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6045 #endif // HAVE_HWMON
6046 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6047 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6048 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6049 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6050 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6051 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6052 case IDX_SEPARATOR: separator = optarg[0]; break;
6053 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6054 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6055 case IDX_INCREMENT: increment = 1; break;
6056 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6057 increment_min_chgd = 1; break;
6058 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6059 increment_max_chgd = 1; break;
6060 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6061 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6062 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6063 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6064
6065 default:
6066 log_error ("ERROR: Invalid argument specified");
6067 return (-1);
6068 }
6069 }
6070
6071 if (optopt != 0)
6072 {
6073 log_error ("ERROR: Invalid argument specified");
6074
6075 return (-1);
6076 }
6077
6078 /**
6079 * Inform user things getting started,
6080 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6081 * - we do not need to check algorithm_pos
6082 */
6083
6084 if (quiet == 0)
6085 {
6086 if (benchmark == 1)
6087 {
6088 if (machine_readable == 0)
6089 {
6090 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6091 log_info ("");
6092 }
6093 else
6094 {
6095 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6096 }
6097 }
6098 else if (restore == 1)
6099 {
6100 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6101 log_info ("");
6102 }
6103 else
6104 {
6105 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6106 log_info ("");
6107 }
6108 }
6109
6110 /**
6111 * sanity check
6112 */
6113
6114 if (attack_mode > 7)
6115 {
6116 log_error ("ERROR: Invalid attack-mode specified");
6117
6118 return (-1);
6119 }
6120
6121 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6122 {
6123 log_error ("ERROR: Invalid runtime specified");
6124
6125 return (-1);
6126 }
6127
6128 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6129 {
6130 log_error ("ERROR: Invalid hash-type specified");
6131
6132 return (-1);
6133 }
6134
6135 // renamed hash modes
6136
6137 if (hash_mode_chgd)
6138 {
6139 int n = -1;
6140
6141 switch (hash_mode)
6142 {
6143 case 123: n = 124;
6144 break;
6145 }
6146
6147 if (n >= 0)
6148 {
6149 log_error ("Old -m specified, use -m %d instead", n);
6150
6151 return (-1);
6152 }
6153 }
6154
6155 if (username == 1)
6156 {
6157 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6158 {
6159 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6160
6161 return (-1);
6162 }
6163 }
6164
6165 if (outfile_format > 16)
6166 {
6167 log_error ("ERROR: Invalid outfile-format specified");
6168
6169 return (-1);
6170 }
6171
6172 if (left == 1)
6173 {
6174 if (outfile_format_chgd == 1)
6175 {
6176 if (outfile_format > 1)
6177 {
6178 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6179
6180 return (-1);
6181 }
6182 }
6183 else
6184 {
6185 outfile_format = OUTFILE_FMT_HASH;
6186 }
6187 }
6188
6189 if (show == 1)
6190 {
6191 if (outfile_format_chgd == 1)
6192 {
6193 if ((outfile_format > 7) && (outfile_format < 16))
6194 {
6195 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6196
6197 return (-1);
6198 }
6199 }
6200 }
6201
6202 if (increment_min < INCREMENT_MIN)
6203 {
6204 log_error ("ERROR: Invalid increment-min specified");
6205
6206 return (-1);
6207 }
6208
6209 if (increment_max > INCREMENT_MAX)
6210 {
6211 log_error ("ERROR: Invalid increment-max specified");
6212
6213 return (-1);
6214 }
6215
6216 if (increment_min > increment_max)
6217 {
6218 log_error ("ERROR: Invalid increment-min specified");
6219
6220 return (-1);
6221 }
6222
6223 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6224 {
6225 log_error ("ERROR: increment is not allowed in attack-mode 0");
6226
6227 return (-1);
6228 }
6229
6230 if ((increment == 0) && (increment_min_chgd == 1))
6231 {
6232 log_error ("ERROR: increment-min is only supported together with increment switch");
6233
6234 return (-1);
6235 }
6236
6237 if ((increment == 0) && (increment_max_chgd == 1))
6238 {
6239 log_error ("ERROR: increment-max is only supported together with increment switch");
6240
6241 return (-1);
6242 }
6243
6244 if (rp_files_cnt && rp_gen)
6245 {
6246 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6247
6248 return (-1);
6249 }
6250
6251 if (rp_files_cnt || rp_gen)
6252 {
6253 if (attack_mode != ATTACK_MODE_STRAIGHT)
6254 {
6255 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6256
6257 return (-1);
6258 }
6259 }
6260
6261 if (rp_gen_func_min > rp_gen_func_max)
6262 {
6263 log_error ("ERROR: Invalid rp-gen-func-min specified");
6264
6265 return (-1);
6266 }
6267
6268 if (kernel_accel_chgd == 1)
6269 {
6270 if (force == 0)
6271 {
6272 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6273 log_info ("Please consider using the option -w instead");
6274 log_info ("You can use --force to override this but do not post error reports if you do so");
6275 log_info ("");
6276
6277 return (-1);
6278 }
6279
6280 if (kernel_accel < 1)
6281 {
6282 log_error ("ERROR: Invalid kernel-accel specified");
6283
6284 return (-1);
6285 }
6286
6287 if (kernel_accel > 1024)
6288 {
6289 log_error ("ERROR: Invalid kernel-accel specified");
6290
6291 return (-1);
6292 }
6293 }
6294
6295 if (kernel_loops_chgd == 1)
6296 {
6297 if (force == 0)
6298 {
6299 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6300 log_info ("Please consider using the option -w instead");
6301 log_info ("You can use --force to override this but do not post error reports if you do so");
6302 log_info ("");
6303
6304 return (-1);
6305 }
6306
6307 if (kernel_loops < 1)
6308 {
6309 log_error ("ERROR: Invalid kernel-loops specified");
6310
6311 return (-1);
6312 }
6313
6314 if (kernel_loops > 1024)
6315 {
6316 log_error ("ERROR: Invalid kernel-loops specified");
6317
6318 return (-1);
6319 }
6320 }
6321
6322 if ((workload_profile < 1) || (workload_profile > 4))
6323 {
6324 log_error ("ERROR: workload-profile %i not available", workload_profile);
6325
6326 return (-1);
6327 }
6328
6329 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6330 {
6331 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6332
6333 return (-1);
6334 }
6335
6336 if (show == 1 || left == 1)
6337 {
6338 attack_mode = ATTACK_MODE_NONE;
6339
6340 if (remove == 1)
6341 {
6342 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6343
6344 return (-1);
6345 }
6346
6347 if (potfile_disable == 1)
6348 {
6349 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6350
6351 return (-1);
6352 }
6353 }
6354
6355 uint attack_kern = ATTACK_KERN_NONE;
6356
6357 switch (attack_mode)
6358 {
6359 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6360 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6361 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6362 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6363 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6364 }
6365
6366 if (benchmark == 0)
6367 {
6368 if (keyspace == 1)
6369 {
6370 int num_additional_params = 1;
6371
6372 if (attack_kern == ATTACK_KERN_COMBI)
6373 {
6374 num_additional_params = 2;
6375 }
6376
6377 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6378
6379 if (keyspace_wordlist_specified == 0) optind--;
6380 }
6381
6382 if (attack_kern == ATTACK_KERN_NONE)
6383 {
6384 if ((optind + 1) != myargc)
6385 {
6386 usage_mini_print (myargv[0]);
6387
6388 return (-1);
6389 }
6390 }
6391 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6392 {
6393 if ((optind + 1) > myargc)
6394 {
6395 usage_mini_print (myargv[0]);
6396
6397 return (-1);
6398 }
6399 }
6400 else if (attack_kern == ATTACK_KERN_COMBI)
6401 {
6402 if ((optind + 3) != myargc)
6403 {
6404 usage_mini_print (myargv[0]);
6405
6406 return (-1);
6407 }
6408 }
6409 else if (attack_kern == ATTACK_KERN_BF)
6410 {
6411 if ((optind + 1) > myargc)
6412 {
6413 usage_mini_print (myargv[0]);
6414
6415 return (-1);
6416 }
6417 }
6418 else
6419 {
6420 usage_mini_print (myargv[0]);
6421
6422 return (-1);
6423 }
6424 }
6425 else
6426 {
6427 if (myargv[optind] != 0)
6428 {
6429 log_error ("ERROR: Invalid argument for benchmark mode specified");
6430
6431 return (-1);
6432 }
6433
6434 if (attack_mode_chgd == 1)
6435 {
6436 if (attack_mode != ATTACK_MODE_BF)
6437 {
6438 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6439
6440 return (-1);
6441 }
6442 }
6443 }
6444
6445 if (skip != 0 && limit != 0)
6446 {
6447 limit += skip;
6448 }
6449
6450 if (keyspace == 1)
6451 {
6452 if (show == 1)
6453 {
6454 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6455
6456 return (-1);
6457 }
6458 else if (left == 1)
6459 {
6460 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6461
6462 return (-1);
6463 }
6464
6465 potfile_disable = 1;
6466
6467 restore_disable = 1;
6468
6469 restore = 0;
6470
6471 weak_hash_threshold = 0;
6472
6473 quiet = 1;
6474 }
6475
6476 if (remove_timer_chgd == 1)
6477 {
6478 if (remove == 0)
6479 {
6480 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6481
6482 return (-1);
6483 }
6484
6485 if (remove_timer < 1)
6486 {
6487 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6488
6489 return (-1);
6490 }
6491 }
6492
6493 if (loopback == 1)
6494 {
6495 if (attack_mode == ATTACK_MODE_STRAIGHT)
6496 {
6497 if ((rp_files_cnt == 0) && (rp_gen == 0))
6498 {
6499 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6500
6501 return (-1);
6502 }
6503 }
6504 else
6505 {
6506 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6507
6508 return (-1);
6509 }
6510 }
6511
6512 if (debug_mode > 0)
6513 {
6514 if (attack_mode != ATTACK_MODE_STRAIGHT)
6515 {
6516 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6517
6518 return (-1);
6519 }
6520
6521 if ((rp_files_cnt == 0) && (rp_gen == 0))
6522 {
6523 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6524
6525 return (-1);
6526 }
6527 }
6528
6529 if (debug_mode > 4)
6530 {
6531 log_error ("ERROR: Invalid debug-mode specified");
6532
6533 return (-1);
6534 }
6535
6536 if (debug_file != NULL)
6537 {
6538 if (debug_mode < 1)
6539 {
6540 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6541
6542 return (-1);
6543 }
6544 }
6545
6546 if (induction_dir != NULL)
6547 {
6548 if (attack_mode == ATTACK_MODE_BF)
6549 {
6550 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6551
6552 return (-1);
6553 }
6554 }
6555
6556 if (attack_mode != ATTACK_MODE_STRAIGHT)
6557 {
6558 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6559 {
6560 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6561
6562 return (-1);
6563 }
6564
6565 weak_hash_threshold = 0;
6566 }
6567
6568 /**
6569 * induction directory
6570 */
6571
6572 char *induction_directory = NULL;
6573
6574 if (attack_mode != ATTACK_MODE_BF)
6575 {
6576 if (induction_dir == NULL)
6577 {
6578 induction_directory = (char *) mymalloc (session_size);
6579
6580 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6581
6582 // create induction folder if it does not already exist
6583
6584 if (keyspace == 0)
6585 {
6586 if (rmdir (induction_directory) == -1)
6587 {
6588 if (errno == ENOENT)
6589 {
6590 // good, we can ignore
6591 }
6592 else if (errno == ENOTEMPTY)
6593 {
6594 char *induction_directory_mv = (char *) mymalloc (session_size);
6595
6596 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6597
6598 if (rename (induction_directory, induction_directory_mv) != 0)
6599 {
6600 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6601
6602 return (-1);
6603 }
6604 }
6605 else
6606 {
6607 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6608
6609 return (-1);
6610 }
6611 }
6612
6613 if (mkdir (induction_directory, 0700) == -1)
6614 {
6615 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6616
6617 return (-1);
6618 }
6619 }
6620 }
6621 else
6622 {
6623 induction_directory = induction_dir;
6624 }
6625 }
6626
6627 data.induction_directory = induction_directory;
6628
6629 /**
6630 * loopback
6631 */
6632
6633 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6634
6635 char *loopback_file = (char *) mymalloc (loopback_size);
6636
6637 /**
6638 * tuning db
6639 */
6640
6641 char tuning_db_file[256] = { 0 };
6642
6643 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6644
6645 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6646
6647 /**
6648 * outfile-check directory
6649 */
6650
6651 char *outfile_check_directory = NULL;
6652
6653 if (outfile_check_dir == NULL)
6654 {
6655 outfile_check_directory = (char *) mymalloc (session_size);
6656
6657 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6658 }
6659 else
6660 {
6661 outfile_check_directory = outfile_check_dir;
6662 }
6663
6664 data.outfile_check_directory = outfile_check_directory;
6665
6666 if (keyspace == 0)
6667 {
6668 struct stat outfile_check_stat;
6669
6670 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6671 {
6672 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6673
6674 if (is_dir == 0)
6675 {
6676 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6677
6678 return (-1);
6679 }
6680 }
6681 else if (outfile_check_dir == NULL)
6682 {
6683 if (mkdir (outfile_check_directory, 0700) == -1)
6684 {
6685 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6686
6687 return (-1);
6688 }
6689 }
6690 }
6691
6692 /**
6693 * special other stuff
6694 */
6695
6696 if (hash_mode == 9710)
6697 {
6698 outfile_format = 5;
6699 outfile_format_chgd = 1;
6700 }
6701
6702 if (hash_mode == 9810)
6703 {
6704 outfile_format = 5;
6705 outfile_format_chgd = 1;
6706 }
6707
6708 if (hash_mode == 10410)
6709 {
6710 outfile_format = 5;
6711 outfile_format_chgd = 1;
6712 }
6713
6714 /**
6715 * store stuff
6716 */
6717
6718 data.hash_mode = hash_mode;
6719 data.restore = restore;
6720 data.restore_timer = restore_timer;
6721 data.restore_disable = restore_disable;
6722 data.status = status;
6723 data.status_timer = status_timer;
6724 data.machine_readable = machine_readable;
6725 data.loopback = loopback;
6726 data.runtime = runtime;
6727 data.remove = remove;
6728 data.remove_timer = remove_timer;
6729 data.debug_mode = debug_mode;
6730 data.debug_file = debug_file;
6731 data.username = username;
6732 data.quiet = quiet;
6733 data.outfile = outfile;
6734 data.outfile_format = outfile_format;
6735 data.outfile_autohex = outfile_autohex;
6736 data.hex_charset = hex_charset;
6737 data.hex_salt = hex_salt;
6738 data.hex_wordlist = hex_wordlist;
6739 data.separator = separator;
6740 data.rp_files = rp_files;
6741 data.rp_files_cnt = rp_files_cnt;
6742 data.rp_gen = rp_gen;
6743 data.rp_gen_seed = rp_gen_seed;
6744 data.force = force;
6745 data.benchmark = benchmark;
6746 data.skip = skip;
6747 data.limit = limit;
6748 #ifdef HAVE_HWMON
6749 data.powertune_enable = powertune_enable;
6750 #endif
6751 data.logfile_disable = logfile_disable;
6752 data.truecrypt_keyfiles = truecrypt_keyfiles;
6753 data.veracrypt_keyfiles = veracrypt_keyfiles;
6754 data.veracrypt_pim = veracrypt_pim;
6755 data.scrypt_tmto = scrypt_tmto;
6756 data.workload_profile = workload_profile;
6757
6758 /**
6759 * cpu affinity
6760 */
6761
6762 if (cpu_affinity)
6763 {
6764 set_cpu_affinity (cpu_affinity);
6765 }
6766
6767 if (rp_gen_seed_chgd == 0)
6768 {
6769 srand (proc_start);
6770 }
6771 else
6772 {
6773 srand (rp_gen_seed);
6774 }
6775
6776 /**
6777 * logfile init
6778 */
6779
6780 if (logfile_disable == 0)
6781 {
6782 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6783
6784 char *logfile = (char *) mymalloc (logfile_size);
6785
6786 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6787
6788 data.logfile = logfile;
6789
6790 char *topid = logfile_generate_topid ();
6791
6792 data.topid = topid;
6793 }
6794
6795 // logfile_append() checks for logfile_disable internally to make it easier from here
6796
6797 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6798 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6799 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6800 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6801 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6802 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6803 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6804 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6805 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6806 #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));
6807
6808 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6809 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6810 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6811 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6812 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6813 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6814 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6815 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6816
6817 logfile_top_msg ("START");
6818
6819 logfile_top_uint (attack_mode);
6820 logfile_top_uint (attack_kern);
6821 logfile_top_uint (benchmark);
6822 logfile_top_uint (bitmap_min);
6823 logfile_top_uint (bitmap_max);
6824 logfile_top_uint (debug_mode);
6825 logfile_top_uint (force);
6826 logfile_top_uint (kernel_accel);
6827 logfile_top_uint (kernel_loops);
6828 logfile_top_uint (gpu_temp_disable);
6829 #ifdef HAVE_HWMON
6830 logfile_top_uint (gpu_temp_abort);
6831 logfile_top_uint (gpu_temp_retain);
6832 #endif
6833 logfile_top_uint (hash_mode);
6834 logfile_top_uint (hex_charset);
6835 logfile_top_uint (hex_salt);
6836 logfile_top_uint (hex_wordlist);
6837 logfile_top_uint (increment);
6838 logfile_top_uint (increment_max);
6839 logfile_top_uint (increment_min);
6840 logfile_top_uint (keyspace);
6841 logfile_top_uint (left);
6842 logfile_top_uint (logfile_disable);
6843 logfile_top_uint (loopback);
6844 logfile_top_uint (markov_classic);
6845 logfile_top_uint (markov_disable);
6846 logfile_top_uint (markov_threshold);
6847 logfile_top_uint (outfile_autohex);
6848 logfile_top_uint (outfile_check_timer);
6849 logfile_top_uint (outfile_format);
6850 logfile_top_uint (potfile_disable);
6851 logfile_top_string (potfile_path);
6852 #if defined(HAVE_HWMON)
6853 logfile_top_uint (powertune_enable);
6854 #endif
6855 logfile_top_uint (scrypt_tmto);
6856 logfile_top_uint (quiet);
6857 logfile_top_uint (remove);
6858 logfile_top_uint (remove_timer);
6859 logfile_top_uint (restore);
6860 logfile_top_uint (restore_disable);
6861 logfile_top_uint (restore_timer);
6862 logfile_top_uint (rp_gen);
6863 logfile_top_uint (rp_gen_func_max);
6864 logfile_top_uint (rp_gen_func_min);
6865 logfile_top_uint (rp_gen_seed);
6866 logfile_top_uint (runtime);
6867 logfile_top_uint (segment_size);
6868 logfile_top_uint (show);
6869 logfile_top_uint (status);
6870 logfile_top_uint (machine_readable);
6871 logfile_top_uint (status_timer);
6872 logfile_top_uint (usage);
6873 logfile_top_uint (username);
6874 logfile_top_uint (version);
6875 logfile_top_uint (weak_hash_threshold);
6876 logfile_top_uint (workload_profile);
6877 logfile_top_uint64 (limit);
6878 logfile_top_uint64 (skip);
6879 logfile_top_char (separator);
6880 logfile_top_string (cpu_affinity);
6881 logfile_top_string (custom_charset_1);
6882 logfile_top_string (custom_charset_2);
6883 logfile_top_string (custom_charset_3);
6884 logfile_top_string (custom_charset_4);
6885 logfile_top_string (debug_file);
6886 logfile_top_string (opencl_devices);
6887 logfile_top_string (opencl_platforms);
6888 logfile_top_string (opencl_device_types);
6889 logfile_top_uint (opencl_vector_width);
6890 logfile_top_string (induction_dir);
6891 logfile_top_string (markov_hcstat);
6892 logfile_top_string (outfile);
6893 logfile_top_string (outfile_check_dir);
6894 logfile_top_string (rule_buf_l);
6895 logfile_top_string (rule_buf_r);
6896 logfile_top_string (session);
6897 logfile_top_string (truecrypt_keyfiles);
6898 logfile_top_string (veracrypt_keyfiles);
6899 logfile_top_uint (veracrypt_pim);
6900
6901 /**
6902 * Init OpenCL library loader
6903 */
6904
6905 if (keyspace == 0)
6906 {
6907 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6908
6909 ocl_init (ocl);
6910
6911 data.ocl = ocl;
6912 }
6913
6914 /**
6915 * OpenCL platform selection
6916 */
6917
6918 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6919
6920 /**
6921 * OpenCL device selection
6922 */
6923
6924 u32 devices_filter = setup_devices_filter (opencl_devices);
6925
6926 /**
6927 * OpenCL device type selection
6928 */
6929
6930 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6931
6932 /**
6933 * benchmark
6934 */
6935
6936 if (benchmark == 1)
6937 {
6938 /**
6939 * disable useless stuff for benchmark
6940 */
6941
6942 status_timer = 0;
6943 restore_timer = 0;
6944 restore_disable = 1;
6945 potfile_disable = 1;
6946 weak_hash_threshold = 0;
6947 gpu_temp_disable = 1;
6948
6949 #ifdef HAVE_HWMON
6950 powertune_enable = 1;
6951 #endif
6952
6953 data.status_timer = status_timer;
6954 data.restore_timer = restore_timer;
6955 data.restore_disable = restore_disable;
6956
6957 /**
6958 * force attack mode to be bruteforce
6959 */
6960
6961 attack_mode = ATTACK_MODE_BF;
6962 attack_kern = ATTACK_KERN_BF;
6963
6964 if (workload_profile_chgd == 0)
6965 {
6966 workload_profile = 3;
6967
6968 data.workload_profile = workload_profile;
6969 }
6970 }
6971
6972 /**
6973 * config
6974 */
6975
6976 uint hash_type = 0;
6977 uint salt_type = 0;
6978 uint attack_exec = 0;
6979 uint opts_type = 0;
6980 uint kern_type = 0;
6981 uint dgst_size = 0;
6982 uint esalt_size = 0;
6983 uint opti_type = 0;
6984 uint dgst_pos0 = -1;
6985 uint dgst_pos1 = -1;
6986 uint dgst_pos2 = -1;
6987 uint dgst_pos3 = -1;
6988
6989 int (*parse_func) (char *, uint, hash_t *);
6990 int (*sort_by_digest) (const void *, const void *);
6991
6992 uint algorithm_pos = 0;
6993 uint algorithm_max = 1;
6994
6995 uint *algorithms = default_benchmark_algorithms;
6996
6997 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6998
6999 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7000 {
7001 /*
7002 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7003 * the following algos are skipped entirely
7004 */
7005
7006 if (algorithm_pos > 0)
7007 {
7008 local_free (rd);
7009
7010 rd = init_restore (argc, argv);
7011
7012 data.rd = rd;
7013 }
7014
7015 /**
7016 * update hash_mode in case of multihash benchmark
7017 */
7018
7019 if (benchmark == 1)
7020 {
7021 if (hash_mode_chgd == 0)
7022 {
7023 hash_mode = algorithms[algorithm_pos];
7024
7025 data.hash_mode = hash_mode;
7026 }
7027
7028 quiet = 1;
7029
7030 data.quiet = quiet;
7031 }
7032
7033 switch (hash_mode)
7034 {
7035 case 0: hash_type = HASH_TYPE_MD5;
7036 salt_type = SALT_TYPE_NONE;
7037 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7038 opts_type = OPTS_TYPE_PT_GENERATE_LE
7039 | OPTS_TYPE_PT_ADD80
7040 | OPTS_TYPE_PT_ADDBITS14;
7041 kern_type = KERN_TYPE_MD5;
7042 dgst_size = DGST_SIZE_4_4;
7043 parse_func = md5_parse_hash;
7044 sort_by_digest = sort_by_digest_4_4;
7045 opti_type = OPTI_TYPE_ZERO_BYTE
7046 | OPTI_TYPE_PRECOMPUTE_INIT
7047 | OPTI_TYPE_PRECOMPUTE_MERKLE
7048 | OPTI_TYPE_MEET_IN_MIDDLE
7049 | OPTI_TYPE_EARLY_SKIP
7050 | OPTI_TYPE_NOT_ITERATED
7051 | OPTI_TYPE_NOT_SALTED
7052 | OPTI_TYPE_RAW_HASH;
7053 dgst_pos0 = 0;
7054 dgst_pos1 = 3;
7055 dgst_pos2 = 2;
7056 dgst_pos3 = 1;
7057 break;
7058
7059 case 10: hash_type = HASH_TYPE_MD5;
7060 salt_type = SALT_TYPE_INTERN;
7061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7062 opts_type = OPTS_TYPE_PT_GENERATE_LE
7063 | OPTS_TYPE_ST_ADD80
7064 | OPTS_TYPE_ST_ADDBITS14;
7065 kern_type = KERN_TYPE_MD5_PWSLT;
7066 dgst_size = DGST_SIZE_4_4;
7067 parse_func = md5s_parse_hash;
7068 sort_by_digest = sort_by_digest_4_4;
7069 opti_type = OPTI_TYPE_ZERO_BYTE
7070 | OPTI_TYPE_PRECOMPUTE_INIT
7071 | OPTI_TYPE_PRECOMPUTE_MERKLE
7072 | OPTI_TYPE_MEET_IN_MIDDLE
7073 | OPTI_TYPE_EARLY_SKIP
7074 | OPTI_TYPE_NOT_ITERATED
7075 | OPTI_TYPE_APPENDED_SALT
7076 | OPTI_TYPE_RAW_HASH;
7077 dgst_pos0 = 0;
7078 dgst_pos1 = 3;
7079 dgst_pos2 = 2;
7080 dgst_pos3 = 1;
7081 break;
7082
7083 case 11: hash_type = HASH_TYPE_MD5;
7084 salt_type = SALT_TYPE_INTERN;
7085 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7086 opts_type = OPTS_TYPE_PT_GENERATE_LE
7087 | OPTS_TYPE_ST_ADD80
7088 | OPTS_TYPE_ST_ADDBITS14;
7089 kern_type = KERN_TYPE_MD5_PWSLT;
7090 dgst_size = DGST_SIZE_4_4;
7091 parse_func = joomla_parse_hash;
7092 sort_by_digest = sort_by_digest_4_4;
7093 opti_type = OPTI_TYPE_ZERO_BYTE
7094 | OPTI_TYPE_PRECOMPUTE_INIT
7095 | OPTI_TYPE_PRECOMPUTE_MERKLE
7096 | OPTI_TYPE_MEET_IN_MIDDLE
7097 | OPTI_TYPE_EARLY_SKIP
7098 | OPTI_TYPE_NOT_ITERATED
7099 | OPTI_TYPE_APPENDED_SALT
7100 | OPTI_TYPE_RAW_HASH;
7101 dgst_pos0 = 0;
7102 dgst_pos1 = 3;
7103 dgst_pos2 = 2;
7104 dgst_pos3 = 1;
7105 break;
7106
7107 case 12: hash_type = HASH_TYPE_MD5;
7108 salt_type = SALT_TYPE_INTERN;
7109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7110 opts_type = OPTS_TYPE_PT_GENERATE_LE
7111 | OPTS_TYPE_ST_ADD80
7112 | OPTS_TYPE_ST_ADDBITS14;
7113 kern_type = KERN_TYPE_MD5_PWSLT;
7114 dgst_size = DGST_SIZE_4_4;
7115 parse_func = postgresql_parse_hash;
7116 sort_by_digest = sort_by_digest_4_4;
7117 opti_type = OPTI_TYPE_ZERO_BYTE
7118 | OPTI_TYPE_PRECOMPUTE_INIT
7119 | OPTI_TYPE_PRECOMPUTE_MERKLE
7120 | OPTI_TYPE_MEET_IN_MIDDLE
7121 | OPTI_TYPE_EARLY_SKIP
7122 | OPTI_TYPE_NOT_ITERATED
7123 | OPTI_TYPE_APPENDED_SALT
7124 | OPTI_TYPE_RAW_HASH;
7125 dgst_pos0 = 0;
7126 dgst_pos1 = 3;
7127 dgst_pos2 = 2;
7128 dgst_pos3 = 1;
7129 break;
7130
7131 case 20: hash_type = HASH_TYPE_MD5;
7132 salt_type = SALT_TYPE_INTERN;
7133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7134 opts_type = OPTS_TYPE_PT_GENERATE_LE
7135 | OPTS_TYPE_PT_ADD80
7136 | OPTS_TYPE_PT_ADDBITS14;
7137 kern_type = KERN_TYPE_MD5_SLTPW;
7138 dgst_size = DGST_SIZE_4_4;
7139 parse_func = md5s_parse_hash;
7140 sort_by_digest = sort_by_digest_4_4;
7141 opti_type = OPTI_TYPE_ZERO_BYTE
7142 | OPTI_TYPE_PRECOMPUTE_INIT
7143 | OPTI_TYPE_PRECOMPUTE_MERKLE
7144 | OPTI_TYPE_EARLY_SKIP
7145 | OPTI_TYPE_NOT_ITERATED
7146 | OPTI_TYPE_PREPENDED_SALT
7147 | OPTI_TYPE_RAW_HASH;
7148 dgst_pos0 = 0;
7149 dgst_pos1 = 3;
7150 dgst_pos2 = 2;
7151 dgst_pos3 = 1;
7152 break;
7153
7154 case 21: hash_type = HASH_TYPE_MD5;
7155 salt_type = SALT_TYPE_INTERN;
7156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7157 opts_type = OPTS_TYPE_PT_GENERATE_LE
7158 | OPTS_TYPE_PT_ADD80
7159 | OPTS_TYPE_PT_ADDBITS14;
7160 kern_type = KERN_TYPE_MD5_SLTPW;
7161 dgst_size = DGST_SIZE_4_4;
7162 parse_func = osc_parse_hash;
7163 sort_by_digest = sort_by_digest_4_4;
7164 opti_type = OPTI_TYPE_ZERO_BYTE
7165 | OPTI_TYPE_PRECOMPUTE_INIT
7166 | OPTI_TYPE_PRECOMPUTE_MERKLE
7167 | OPTI_TYPE_EARLY_SKIP
7168 | OPTI_TYPE_NOT_ITERATED
7169 | OPTI_TYPE_PREPENDED_SALT
7170 | OPTI_TYPE_RAW_HASH;
7171 dgst_pos0 = 0;
7172 dgst_pos1 = 3;
7173 dgst_pos2 = 2;
7174 dgst_pos3 = 1;
7175 break;
7176
7177 case 22: hash_type = HASH_TYPE_MD5;
7178 salt_type = SALT_TYPE_EMBEDDED;
7179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7180 opts_type = OPTS_TYPE_PT_GENERATE_LE
7181 | OPTS_TYPE_PT_ADD80
7182 | OPTS_TYPE_PT_ADDBITS14;
7183 kern_type = KERN_TYPE_MD5_SLTPW;
7184 dgst_size = DGST_SIZE_4_4;
7185 parse_func = netscreen_parse_hash;
7186 sort_by_digest = sort_by_digest_4_4;
7187 opti_type = OPTI_TYPE_ZERO_BYTE
7188 | OPTI_TYPE_PRECOMPUTE_INIT
7189 | OPTI_TYPE_PRECOMPUTE_MERKLE
7190 | OPTI_TYPE_EARLY_SKIP
7191 | OPTI_TYPE_NOT_ITERATED
7192 | OPTI_TYPE_PREPENDED_SALT
7193 | OPTI_TYPE_RAW_HASH;
7194 dgst_pos0 = 0;
7195 dgst_pos1 = 3;
7196 dgst_pos2 = 2;
7197 dgst_pos3 = 1;
7198 break;
7199
7200 case 23: hash_type = HASH_TYPE_MD5;
7201 salt_type = SALT_TYPE_EMBEDDED;
7202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7203 opts_type = OPTS_TYPE_PT_GENERATE_LE
7204 | OPTS_TYPE_PT_ADD80
7205 | OPTS_TYPE_PT_ADDBITS14;
7206 kern_type = KERN_TYPE_MD5_SLTPW;
7207 dgst_size = DGST_SIZE_4_4;
7208 parse_func = skype_parse_hash;
7209 sort_by_digest = sort_by_digest_4_4;
7210 opti_type = OPTI_TYPE_ZERO_BYTE
7211 | OPTI_TYPE_PRECOMPUTE_INIT
7212 | OPTI_TYPE_PRECOMPUTE_MERKLE
7213 | OPTI_TYPE_EARLY_SKIP
7214 | OPTI_TYPE_NOT_ITERATED
7215 | OPTI_TYPE_PREPENDED_SALT
7216 | OPTI_TYPE_RAW_HASH;
7217 dgst_pos0 = 0;
7218 dgst_pos1 = 3;
7219 dgst_pos2 = 2;
7220 dgst_pos3 = 1;
7221 break;
7222
7223 case 30: hash_type = HASH_TYPE_MD5;
7224 salt_type = SALT_TYPE_INTERN;
7225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7226 opts_type = OPTS_TYPE_PT_GENERATE_LE
7227 | OPTS_TYPE_PT_UNICODE
7228 | OPTS_TYPE_ST_ADD80
7229 | OPTS_TYPE_ST_ADDBITS14;
7230 kern_type = KERN_TYPE_MD5_PWUSLT;
7231 dgst_size = DGST_SIZE_4_4;
7232 parse_func = md5s_parse_hash;
7233 sort_by_digest = sort_by_digest_4_4;
7234 opti_type = OPTI_TYPE_ZERO_BYTE
7235 | OPTI_TYPE_PRECOMPUTE_INIT
7236 | OPTI_TYPE_PRECOMPUTE_MERKLE
7237 | OPTI_TYPE_MEET_IN_MIDDLE
7238 | OPTI_TYPE_EARLY_SKIP
7239 | OPTI_TYPE_NOT_ITERATED
7240 | OPTI_TYPE_APPENDED_SALT
7241 | OPTI_TYPE_RAW_HASH;
7242 dgst_pos0 = 0;
7243 dgst_pos1 = 3;
7244 dgst_pos2 = 2;
7245 dgst_pos3 = 1;
7246 break;
7247
7248 case 40: hash_type = HASH_TYPE_MD5;
7249 salt_type = SALT_TYPE_INTERN;
7250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7251 opts_type = OPTS_TYPE_PT_GENERATE_LE
7252 | OPTS_TYPE_PT_ADD80
7253 | OPTS_TYPE_PT_ADDBITS14
7254 | OPTS_TYPE_PT_UNICODE;
7255 kern_type = KERN_TYPE_MD5_SLTPWU;
7256 dgst_size = DGST_SIZE_4_4;
7257 parse_func = md5s_parse_hash;
7258 sort_by_digest = sort_by_digest_4_4;
7259 opti_type = OPTI_TYPE_ZERO_BYTE
7260 | OPTI_TYPE_PRECOMPUTE_INIT
7261 | OPTI_TYPE_PRECOMPUTE_MERKLE
7262 | OPTI_TYPE_EARLY_SKIP
7263 | OPTI_TYPE_NOT_ITERATED
7264 | OPTI_TYPE_PREPENDED_SALT
7265 | OPTI_TYPE_RAW_HASH;
7266 dgst_pos0 = 0;
7267 dgst_pos1 = 3;
7268 dgst_pos2 = 2;
7269 dgst_pos3 = 1;
7270 break;
7271
7272 case 50: hash_type = HASH_TYPE_MD5;
7273 salt_type = SALT_TYPE_INTERN;
7274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7275 opts_type = OPTS_TYPE_PT_GENERATE_LE
7276 | OPTS_TYPE_ST_ADD80
7277 | OPTS_TYPE_ST_ADDBITS14;
7278 kern_type = KERN_TYPE_HMACMD5_PW;
7279 dgst_size = DGST_SIZE_4_4;
7280 parse_func = hmacmd5_parse_hash;
7281 sort_by_digest = sort_by_digest_4_4;
7282 opti_type = OPTI_TYPE_ZERO_BYTE
7283 | OPTI_TYPE_NOT_ITERATED;
7284 dgst_pos0 = 0;
7285 dgst_pos1 = 3;
7286 dgst_pos2 = 2;
7287 dgst_pos3 = 1;
7288 break;
7289
7290 case 60: hash_type = HASH_TYPE_MD5;
7291 salt_type = SALT_TYPE_INTERN;
7292 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7293 opts_type = OPTS_TYPE_PT_GENERATE_LE
7294 | OPTS_TYPE_PT_ADD80
7295 | OPTS_TYPE_PT_ADDBITS14;
7296 kern_type = KERN_TYPE_HMACMD5_SLT;
7297 dgst_size = DGST_SIZE_4_4;
7298 parse_func = hmacmd5_parse_hash;
7299 sort_by_digest = sort_by_digest_4_4;
7300 opti_type = OPTI_TYPE_ZERO_BYTE
7301 | OPTI_TYPE_NOT_ITERATED;
7302 dgst_pos0 = 0;
7303 dgst_pos1 = 3;
7304 dgst_pos2 = 2;
7305 dgst_pos3 = 1;
7306 break;
7307
7308 case 100: hash_type = HASH_TYPE_SHA1;
7309 salt_type = SALT_TYPE_NONE;
7310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7311 opts_type = OPTS_TYPE_PT_GENERATE_BE
7312 | OPTS_TYPE_PT_ADD80
7313 | OPTS_TYPE_PT_ADDBITS15;
7314 kern_type = KERN_TYPE_SHA1;
7315 dgst_size = DGST_SIZE_4_5;
7316 parse_func = sha1_parse_hash;
7317 sort_by_digest = sort_by_digest_4_5;
7318 opti_type = OPTI_TYPE_ZERO_BYTE
7319 | OPTI_TYPE_PRECOMPUTE_INIT
7320 | OPTI_TYPE_PRECOMPUTE_MERKLE
7321 | OPTI_TYPE_EARLY_SKIP
7322 | OPTI_TYPE_NOT_ITERATED
7323 | OPTI_TYPE_NOT_SALTED
7324 | OPTI_TYPE_RAW_HASH;
7325 dgst_pos0 = 3;
7326 dgst_pos1 = 4;
7327 dgst_pos2 = 2;
7328 dgst_pos3 = 1;
7329 break;
7330
7331 case 101: hash_type = HASH_TYPE_SHA1;
7332 salt_type = SALT_TYPE_NONE;
7333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7334 opts_type = OPTS_TYPE_PT_GENERATE_BE
7335 | OPTS_TYPE_PT_ADD80
7336 | OPTS_TYPE_PT_ADDBITS15;
7337 kern_type = KERN_TYPE_SHA1;
7338 dgst_size = DGST_SIZE_4_5;
7339 parse_func = sha1b64_parse_hash;
7340 sort_by_digest = sort_by_digest_4_5;
7341 opti_type = OPTI_TYPE_ZERO_BYTE
7342 | OPTI_TYPE_PRECOMPUTE_INIT
7343 | OPTI_TYPE_PRECOMPUTE_MERKLE
7344 | OPTI_TYPE_EARLY_SKIP
7345 | OPTI_TYPE_NOT_ITERATED
7346 | OPTI_TYPE_NOT_SALTED
7347 | OPTI_TYPE_RAW_HASH;
7348 dgst_pos0 = 3;
7349 dgst_pos1 = 4;
7350 dgst_pos2 = 2;
7351 dgst_pos3 = 1;
7352 break;
7353
7354 case 110: hash_type = HASH_TYPE_SHA1;
7355 salt_type = SALT_TYPE_INTERN;
7356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7357 opts_type = OPTS_TYPE_PT_GENERATE_BE
7358 | OPTS_TYPE_ST_ADD80
7359 | OPTS_TYPE_ST_ADDBITS15;
7360 kern_type = KERN_TYPE_SHA1_PWSLT;
7361 dgst_size = DGST_SIZE_4_5;
7362 parse_func = sha1s_parse_hash;
7363 sort_by_digest = sort_by_digest_4_5;
7364 opti_type = OPTI_TYPE_ZERO_BYTE
7365 | OPTI_TYPE_PRECOMPUTE_INIT
7366 | OPTI_TYPE_PRECOMPUTE_MERKLE
7367 | OPTI_TYPE_EARLY_SKIP
7368 | OPTI_TYPE_NOT_ITERATED
7369 | OPTI_TYPE_APPENDED_SALT
7370 | OPTI_TYPE_RAW_HASH;
7371 dgst_pos0 = 3;
7372 dgst_pos1 = 4;
7373 dgst_pos2 = 2;
7374 dgst_pos3 = 1;
7375 break;
7376
7377 case 111: hash_type = HASH_TYPE_SHA1;
7378 salt_type = SALT_TYPE_EMBEDDED;
7379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7380 opts_type = OPTS_TYPE_PT_GENERATE_BE
7381 | OPTS_TYPE_ST_ADD80
7382 | OPTS_TYPE_ST_ADDBITS15;
7383 kern_type = KERN_TYPE_SHA1_PWSLT;
7384 dgst_size = DGST_SIZE_4_5;
7385 parse_func = sha1b64s_parse_hash;
7386 sort_by_digest = sort_by_digest_4_5;
7387 opti_type = OPTI_TYPE_ZERO_BYTE
7388 | OPTI_TYPE_PRECOMPUTE_INIT
7389 | OPTI_TYPE_PRECOMPUTE_MERKLE
7390 | OPTI_TYPE_EARLY_SKIP
7391 | OPTI_TYPE_NOT_ITERATED
7392 | OPTI_TYPE_APPENDED_SALT
7393 | OPTI_TYPE_RAW_HASH;
7394 dgst_pos0 = 3;
7395 dgst_pos1 = 4;
7396 dgst_pos2 = 2;
7397 dgst_pos3 = 1;
7398 break;
7399
7400 case 112: hash_type = HASH_TYPE_SHA1;
7401 salt_type = SALT_TYPE_INTERN;
7402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7403 opts_type = OPTS_TYPE_PT_GENERATE_BE
7404 | OPTS_TYPE_ST_ADD80
7405 | OPTS_TYPE_ST_ADDBITS15
7406 | OPTS_TYPE_ST_HEX;
7407 kern_type = KERN_TYPE_SHA1_PWSLT;
7408 dgst_size = DGST_SIZE_4_5;
7409 parse_func = oracles_parse_hash;
7410 sort_by_digest = sort_by_digest_4_5;
7411 opti_type = OPTI_TYPE_ZERO_BYTE
7412 | OPTI_TYPE_PRECOMPUTE_INIT
7413 | OPTI_TYPE_PRECOMPUTE_MERKLE
7414 | OPTI_TYPE_EARLY_SKIP
7415 | OPTI_TYPE_NOT_ITERATED
7416 | OPTI_TYPE_APPENDED_SALT
7417 | OPTI_TYPE_RAW_HASH;
7418 dgst_pos0 = 3;
7419 dgst_pos1 = 4;
7420 dgst_pos2 = 2;
7421 dgst_pos3 = 1;
7422 break;
7423
7424 case 120: hash_type = HASH_TYPE_SHA1;
7425 salt_type = SALT_TYPE_INTERN;
7426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7427 opts_type = OPTS_TYPE_PT_GENERATE_BE
7428 | OPTS_TYPE_PT_ADD80
7429 | OPTS_TYPE_PT_ADDBITS15;
7430 kern_type = KERN_TYPE_SHA1_SLTPW;
7431 dgst_size = DGST_SIZE_4_5;
7432 parse_func = sha1s_parse_hash;
7433 sort_by_digest = sort_by_digest_4_5;
7434 opti_type = OPTI_TYPE_ZERO_BYTE
7435 | OPTI_TYPE_PRECOMPUTE_INIT
7436 | OPTI_TYPE_PRECOMPUTE_MERKLE
7437 | OPTI_TYPE_EARLY_SKIP
7438 | OPTI_TYPE_NOT_ITERATED
7439 | OPTI_TYPE_PREPENDED_SALT
7440 | OPTI_TYPE_RAW_HASH;
7441 dgst_pos0 = 3;
7442 dgst_pos1 = 4;
7443 dgst_pos2 = 2;
7444 dgst_pos3 = 1;
7445 break;
7446
7447 case 121: hash_type = HASH_TYPE_SHA1;
7448 salt_type = SALT_TYPE_INTERN;
7449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7450 opts_type = OPTS_TYPE_PT_GENERATE_BE
7451 | OPTS_TYPE_PT_ADD80
7452 | OPTS_TYPE_PT_ADDBITS15
7453 | OPTS_TYPE_ST_LOWER;
7454 kern_type = KERN_TYPE_SHA1_SLTPW;
7455 dgst_size = DGST_SIZE_4_5;
7456 parse_func = smf_parse_hash;
7457 sort_by_digest = sort_by_digest_4_5;
7458 opti_type = OPTI_TYPE_ZERO_BYTE
7459 | OPTI_TYPE_PRECOMPUTE_INIT
7460 | OPTI_TYPE_PRECOMPUTE_MERKLE
7461 | OPTI_TYPE_EARLY_SKIP
7462 | OPTI_TYPE_NOT_ITERATED
7463 | OPTI_TYPE_PREPENDED_SALT
7464 | OPTI_TYPE_RAW_HASH;
7465 dgst_pos0 = 3;
7466 dgst_pos1 = 4;
7467 dgst_pos2 = 2;
7468 dgst_pos3 = 1;
7469 break;
7470
7471 case 122: hash_type = HASH_TYPE_SHA1;
7472 salt_type = SALT_TYPE_EMBEDDED;
7473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7474 opts_type = OPTS_TYPE_PT_GENERATE_BE
7475 | OPTS_TYPE_PT_ADD80
7476 | OPTS_TYPE_PT_ADDBITS15
7477 | OPTS_TYPE_ST_HEX;
7478 kern_type = KERN_TYPE_SHA1_SLTPW;
7479 dgst_size = DGST_SIZE_4_5;
7480 parse_func = osx1_parse_hash;
7481 sort_by_digest = sort_by_digest_4_5;
7482 opti_type = OPTI_TYPE_ZERO_BYTE
7483 | OPTI_TYPE_PRECOMPUTE_INIT
7484 | OPTI_TYPE_PRECOMPUTE_MERKLE
7485 | OPTI_TYPE_EARLY_SKIP
7486 | OPTI_TYPE_NOT_ITERATED
7487 | OPTI_TYPE_PREPENDED_SALT
7488 | OPTI_TYPE_RAW_HASH;
7489 dgst_pos0 = 3;
7490 dgst_pos1 = 4;
7491 dgst_pos2 = 2;
7492 dgst_pos3 = 1;
7493 break;
7494
7495 case 124: hash_type = HASH_TYPE_SHA1;
7496 salt_type = SALT_TYPE_EMBEDDED;
7497 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7498 opts_type = OPTS_TYPE_PT_GENERATE_BE
7499 | OPTS_TYPE_PT_ADD80
7500 | OPTS_TYPE_PT_ADDBITS15;
7501 kern_type = KERN_TYPE_SHA1_SLTPW;
7502 dgst_size = DGST_SIZE_4_5;
7503 parse_func = djangosha1_parse_hash;
7504 sort_by_digest = sort_by_digest_4_5;
7505 opti_type = OPTI_TYPE_ZERO_BYTE
7506 | OPTI_TYPE_PRECOMPUTE_INIT
7507 | OPTI_TYPE_PRECOMPUTE_MERKLE
7508 | OPTI_TYPE_EARLY_SKIP
7509 | OPTI_TYPE_NOT_ITERATED
7510 | OPTI_TYPE_PREPENDED_SALT
7511 | OPTI_TYPE_RAW_HASH;
7512 dgst_pos0 = 3;
7513 dgst_pos1 = 4;
7514 dgst_pos2 = 2;
7515 dgst_pos3 = 1;
7516 break;
7517
7518 case 125: hash_type = HASH_TYPE_SHA1;
7519 salt_type = SALT_TYPE_EMBEDDED;
7520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7521 opts_type = OPTS_TYPE_PT_GENERATE_BE
7522 | OPTS_TYPE_PT_ADD80
7523 | OPTS_TYPE_PT_ADDBITS15
7524 | OPTS_TYPE_ST_HEX;
7525 kern_type = KERN_TYPE_SHA1_SLTPW;
7526 dgst_size = DGST_SIZE_4_5;
7527 parse_func = arubaos_parse_hash;
7528 sort_by_digest = sort_by_digest_4_5;
7529 opti_type = OPTI_TYPE_ZERO_BYTE
7530 | OPTI_TYPE_PRECOMPUTE_INIT
7531 | OPTI_TYPE_PRECOMPUTE_MERKLE
7532 | OPTI_TYPE_EARLY_SKIP
7533 | OPTI_TYPE_NOT_ITERATED
7534 | OPTI_TYPE_PREPENDED_SALT
7535 | OPTI_TYPE_RAW_HASH;
7536 dgst_pos0 = 3;
7537 dgst_pos1 = 4;
7538 dgst_pos2 = 2;
7539 dgst_pos3 = 1;
7540 break;
7541
7542 case 130: hash_type = HASH_TYPE_SHA1;
7543 salt_type = SALT_TYPE_INTERN;
7544 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7545 opts_type = OPTS_TYPE_PT_GENERATE_BE
7546 | OPTS_TYPE_PT_UNICODE
7547 | OPTS_TYPE_ST_ADD80
7548 | OPTS_TYPE_ST_ADDBITS15;
7549 kern_type = KERN_TYPE_SHA1_PWUSLT;
7550 dgst_size = DGST_SIZE_4_5;
7551 parse_func = sha1s_parse_hash;
7552 sort_by_digest = sort_by_digest_4_5;
7553 opti_type = OPTI_TYPE_ZERO_BYTE
7554 | OPTI_TYPE_PRECOMPUTE_INIT
7555 | OPTI_TYPE_PRECOMPUTE_MERKLE
7556 | OPTI_TYPE_EARLY_SKIP
7557 | OPTI_TYPE_NOT_ITERATED
7558 | OPTI_TYPE_APPENDED_SALT
7559 | OPTI_TYPE_RAW_HASH;
7560 dgst_pos0 = 3;
7561 dgst_pos1 = 4;
7562 dgst_pos2 = 2;
7563 dgst_pos3 = 1;
7564 break;
7565
7566 case 131: hash_type = HASH_TYPE_SHA1;
7567 salt_type = SALT_TYPE_EMBEDDED;
7568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7569 opts_type = OPTS_TYPE_PT_GENERATE_BE
7570 | OPTS_TYPE_PT_UNICODE
7571 | OPTS_TYPE_PT_UPPER
7572 | OPTS_TYPE_ST_ADD80
7573 | OPTS_TYPE_ST_ADDBITS15
7574 | OPTS_TYPE_ST_HEX;
7575 kern_type = KERN_TYPE_SHA1_PWUSLT;
7576 dgst_size = DGST_SIZE_4_5;
7577 parse_func = mssql2000_parse_hash;
7578 sort_by_digest = sort_by_digest_4_5;
7579 opti_type = OPTI_TYPE_ZERO_BYTE
7580 | OPTI_TYPE_PRECOMPUTE_INIT
7581 | OPTI_TYPE_PRECOMPUTE_MERKLE
7582 | OPTI_TYPE_EARLY_SKIP
7583 | OPTI_TYPE_NOT_ITERATED
7584 | OPTI_TYPE_APPENDED_SALT
7585 | OPTI_TYPE_RAW_HASH;
7586 dgst_pos0 = 3;
7587 dgst_pos1 = 4;
7588 dgst_pos2 = 2;
7589 dgst_pos3 = 1;
7590 break;
7591
7592 case 132: hash_type = HASH_TYPE_SHA1;
7593 salt_type = SALT_TYPE_EMBEDDED;
7594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7595 opts_type = OPTS_TYPE_PT_GENERATE_BE
7596 | OPTS_TYPE_PT_UNICODE
7597 | OPTS_TYPE_ST_ADD80
7598 | OPTS_TYPE_ST_ADDBITS15
7599 | OPTS_TYPE_ST_HEX;
7600 kern_type = KERN_TYPE_SHA1_PWUSLT;
7601 dgst_size = DGST_SIZE_4_5;
7602 parse_func = mssql2005_parse_hash;
7603 sort_by_digest = sort_by_digest_4_5;
7604 opti_type = OPTI_TYPE_ZERO_BYTE
7605 | OPTI_TYPE_PRECOMPUTE_INIT
7606 | OPTI_TYPE_PRECOMPUTE_MERKLE
7607 | OPTI_TYPE_EARLY_SKIP
7608 | OPTI_TYPE_NOT_ITERATED
7609 | OPTI_TYPE_APPENDED_SALT
7610 | OPTI_TYPE_RAW_HASH;
7611 dgst_pos0 = 3;
7612 dgst_pos1 = 4;
7613 dgst_pos2 = 2;
7614 dgst_pos3 = 1;
7615 break;
7616
7617 case 133: hash_type = HASH_TYPE_SHA1;
7618 salt_type = SALT_TYPE_EMBEDDED;
7619 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7620 opts_type = OPTS_TYPE_PT_GENERATE_BE
7621 | OPTS_TYPE_PT_UNICODE
7622 | OPTS_TYPE_ST_ADD80
7623 | OPTS_TYPE_ST_ADDBITS15;
7624 kern_type = KERN_TYPE_SHA1_PWUSLT;
7625 dgst_size = DGST_SIZE_4_5;
7626 parse_func = peoplesoft_parse_hash;
7627 sort_by_digest = sort_by_digest_4_5;
7628 opti_type = OPTI_TYPE_ZERO_BYTE
7629 | OPTI_TYPE_PRECOMPUTE_INIT
7630 | OPTI_TYPE_PRECOMPUTE_MERKLE
7631 | OPTI_TYPE_EARLY_SKIP
7632 | OPTI_TYPE_NOT_ITERATED
7633 | OPTI_TYPE_APPENDED_SALT
7634 | OPTI_TYPE_RAW_HASH;
7635 dgst_pos0 = 3;
7636 dgst_pos1 = 4;
7637 dgst_pos2 = 2;
7638 dgst_pos3 = 1;
7639 break;
7640
7641 case 140: hash_type = HASH_TYPE_SHA1;
7642 salt_type = SALT_TYPE_INTERN;
7643 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7644 opts_type = OPTS_TYPE_PT_GENERATE_BE
7645 | OPTS_TYPE_PT_ADD80
7646 | OPTS_TYPE_PT_ADDBITS15
7647 | OPTS_TYPE_PT_UNICODE;
7648 kern_type = KERN_TYPE_SHA1_SLTPWU;
7649 dgst_size = DGST_SIZE_4_5;
7650 parse_func = sha1s_parse_hash;
7651 sort_by_digest = sort_by_digest_4_5;
7652 opti_type = OPTI_TYPE_ZERO_BYTE
7653 | OPTI_TYPE_PRECOMPUTE_INIT
7654 | OPTI_TYPE_PRECOMPUTE_MERKLE
7655 | OPTI_TYPE_EARLY_SKIP
7656 | OPTI_TYPE_NOT_ITERATED
7657 | OPTI_TYPE_PREPENDED_SALT
7658 | OPTI_TYPE_RAW_HASH;
7659 dgst_pos0 = 3;
7660 dgst_pos1 = 4;
7661 dgst_pos2 = 2;
7662 dgst_pos3 = 1;
7663 break;
7664
7665 case 141: hash_type = HASH_TYPE_SHA1;
7666 salt_type = SALT_TYPE_EMBEDDED;
7667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7668 opts_type = OPTS_TYPE_PT_GENERATE_BE
7669 | OPTS_TYPE_PT_ADD80
7670 | OPTS_TYPE_PT_ADDBITS15
7671 | OPTS_TYPE_PT_UNICODE
7672 | OPTS_TYPE_ST_BASE64;
7673 kern_type = KERN_TYPE_SHA1_SLTPWU;
7674 dgst_size = DGST_SIZE_4_5;
7675 parse_func = episerver_parse_hash;
7676 sort_by_digest = sort_by_digest_4_5;
7677 opti_type = OPTI_TYPE_ZERO_BYTE
7678 | OPTI_TYPE_PRECOMPUTE_INIT
7679 | OPTI_TYPE_PRECOMPUTE_MERKLE
7680 | OPTI_TYPE_EARLY_SKIP
7681 | OPTI_TYPE_NOT_ITERATED
7682 | OPTI_TYPE_PREPENDED_SALT
7683 | OPTI_TYPE_RAW_HASH;
7684 dgst_pos0 = 3;
7685 dgst_pos1 = 4;
7686 dgst_pos2 = 2;
7687 dgst_pos3 = 1;
7688 break;
7689
7690 case 150: hash_type = HASH_TYPE_SHA1;
7691 salt_type = SALT_TYPE_INTERN;
7692 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7693 opts_type = OPTS_TYPE_PT_GENERATE_BE
7694 | OPTS_TYPE_ST_ADD80
7695 | OPTS_TYPE_ST_ADDBITS15;
7696 kern_type = KERN_TYPE_HMACSHA1_PW;
7697 dgst_size = DGST_SIZE_4_5;
7698 parse_func = hmacsha1_parse_hash;
7699 sort_by_digest = sort_by_digest_4_5;
7700 opti_type = OPTI_TYPE_ZERO_BYTE
7701 | OPTI_TYPE_NOT_ITERATED;
7702 dgst_pos0 = 3;
7703 dgst_pos1 = 4;
7704 dgst_pos2 = 2;
7705 dgst_pos3 = 1;
7706 break;
7707
7708 case 160: hash_type = HASH_TYPE_SHA1;
7709 salt_type = SALT_TYPE_INTERN;
7710 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7711 opts_type = OPTS_TYPE_PT_GENERATE_BE
7712 | OPTS_TYPE_PT_ADD80
7713 | OPTS_TYPE_PT_ADDBITS15;
7714 kern_type = KERN_TYPE_HMACSHA1_SLT;
7715 dgst_size = DGST_SIZE_4_5;
7716 parse_func = hmacsha1_parse_hash;
7717 sort_by_digest = sort_by_digest_4_5;
7718 opti_type = OPTI_TYPE_ZERO_BYTE
7719 | OPTI_TYPE_NOT_ITERATED;
7720 dgst_pos0 = 3;
7721 dgst_pos1 = 4;
7722 dgst_pos2 = 2;
7723 dgst_pos3 = 1;
7724 break;
7725
7726 case 190: hash_type = HASH_TYPE_SHA1;
7727 salt_type = SALT_TYPE_NONE;
7728 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7729 opts_type = OPTS_TYPE_PT_GENERATE_BE
7730 | OPTS_TYPE_PT_ADD80
7731 | OPTS_TYPE_PT_ADDBITS15;
7732 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7733 dgst_size = DGST_SIZE_4_5;
7734 parse_func = sha1linkedin_parse_hash;
7735 sort_by_digest = sort_by_digest_4_5;
7736 opti_type = OPTI_TYPE_ZERO_BYTE
7737 | OPTI_TYPE_PRECOMPUTE_INIT
7738 | OPTI_TYPE_EARLY_SKIP
7739 | OPTI_TYPE_NOT_ITERATED
7740 | OPTI_TYPE_NOT_SALTED;
7741 dgst_pos0 = 0;
7742 dgst_pos1 = 4;
7743 dgst_pos2 = 3;
7744 dgst_pos3 = 2;
7745 break;
7746
7747 case 200: hash_type = HASH_TYPE_MYSQL;
7748 salt_type = SALT_TYPE_NONE;
7749 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7750 opts_type = 0;
7751 kern_type = KERN_TYPE_MYSQL;
7752 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7753 parse_func = mysql323_parse_hash;
7754 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7755 opti_type = OPTI_TYPE_ZERO_BYTE;
7756 dgst_pos0 = 0;
7757 dgst_pos1 = 1;
7758 dgst_pos2 = 2;
7759 dgst_pos3 = 3;
7760 break;
7761
7762 case 300: hash_type = HASH_TYPE_SHA1;
7763 salt_type = SALT_TYPE_NONE;
7764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7765 opts_type = OPTS_TYPE_PT_GENERATE_BE
7766 | OPTS_TYPE_PT_ADD80
7767 | OPTS_TYPE_PT_ADDBITS15;
7768 kern_type = KERN_TYPE_MYSQL41;
7769 dgst_size = DGST_SIZE_4_5;
7770 parse_func = sha1_parse_hash;
7771 sort_by_digest = sort_by_digest_4_5;
7772 opti_type = OPTI_TYPE_ZERO_BYTE
7773 | OPTI_TYPE_PRECOMPUTE_INIT
7774 | OPTI_TYPE_PRECOMPUTE_MERKLE
7775 | OPTI_TYPE_EARLY_SKIP
7776 | OPTI_TYPE_NOT_ITERATED
7777 | OPTI_TYPE_NOT_SALTED;
7778 dgst_pos0 = 3;
7779 dgst_pos1 = 4;
7780 dgst_pos2 = 2;
7781 dgst_pos3 = 1;
7782 break;
7783
7784 case 400: hash_type = HASH_TYPE_MD5;
7785 salt_type = SALT_TYPE_EMBEDDED;
7786 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7787 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7788 kern_type = KERN_TYPE_PHPASS;
7789 dgst_size = DGST_SIZE_4_4;
7790 parse_func = phpass_parse_hash;
7791 sort_by_digest = sort_by_digest_4_4;
7792 opti_type = OPTI_TYPE_ZERO_BYTE
7793 | OPTI_TYPE_SLOW_HASH_SIMD;
7794 dgst_pos0 = 0;
7795 dgst_pos1 = 1;
7796 dgst_pos2 = 2;
7797 dgst_pos3 = 3;
7798 break;
7799
7800 case 500: hash_type = HASH_TYPE_MD5;
7801 salt_type = SALT_TYPE_EMBEDDED;
7802 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7803 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7804 kern_type = KERN_TYPE_MD5CRYPT;
7805 dgst_size = DGST_SIZE_4_4;
7806 parse_func = md5crypt_parse_hash;
7807 sort_by_digest = sort_by_digest_4_4;
7808 opti_type = OPTI_TYPE_ZERO_BYTE;
7809 dgst_pos0 = 0;
7810 dgst_pos1 = 1;
7811 dgst_pos2 = 2;
7812 dgst_pos3 = 3;
7813 break;
7814
7815 case 501: hash_type = HASH_TYPE_MD5;
7816 salt_type = SALT_TYPE_EMBEDDED;
7817 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7818 opts_type = OPTS_TYPE_PT_GENERATE_LE
7819 | OPTS_TYPE_HASH_COPY;
7820 kern_type = KERN_TYPE_MD5CRYPT;
7821 dgst_size = DGST_SIZE_4_4;
7822 parse_func = juniper_parse_hash;
7823 sort_by_digest = sort_by_digest_4_4;
7824 opti_type = OPTI_TYPE_ZERO_BYTE;
7825 dgst_pos0 = 0;
7826 dgst_pos1 = 1;
7827 dgst_pos2 = 2;
7828 dgst_pos3 = 3;
7829 break;
7830
7831 case 900: hash_type = HASH_TYPE_MD4;
7832 salt_type = SALT_TYPE_NONE;
7833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7834 opts_type = OPTS_TYPE_PT_GENERATE_LE
7835 | OPTS_TYPE_PT_ADD80
7836 | OPTS_TYPE_PT_ADDBITS14;
7837 kern_type = KERN_TYPE_MD4;
7838 dgst_size = DGST_SIZE_4_4;
7839 parse_func = md4_parse_hash;
7840 sort_by_digest = sort_by_digest_4_4;
7841 opti_type = OPTI_TYPE_ZERO_BYTE
7842 | OPTI_TYPE_PRECOMPUTE_INIT
7843 | OPTI_TYPE_PRECOMPUTE_MERKLE
7844 | OPTI_TYPE_MEET_IN_MIDDLE
7845 | OPTI_TYPE_EARLY_SKIP
7846 | OPTI_TYPE_NOT_ITERATED
7847 | OPTI_TYPE_NOT_SALTED
7848 | OPTI_TYPE_RAW_HASH;
7849 dgst_pos0 = 0;
7850 dgst_pos1 = 3;
7851 dgst_pos2 = 2;
7852 dgst_pos3 = 1;
7853 break;
7854
7855 case 1000: hash_type = HASH_TYPE_MD4;
7856 salt_type = SALT_TYPE_NONE;
7857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7858 opts_type = OPTS_TYPE_PT_GENERATE_LE
7859 | OPTS_TYPE_PT_ADD80
7860 | OPTS_TYPE_PT_ADDBITS14
7861 | OPTS_TYPE_PT_UNICODE;
7862 kern_type = KERN_TYPE_MD4_PWU;
7863 dgst_size = DGST_SIZE_4_4;
7864 parse_func = md4_parse_hash;
7865 sort_by_digest = sort_by_digest_4_4;
7866 opti_type = OPTI_TYPE_ZERO_BYTE
7867 | OPTI_TYPE_PRECOMPUTE_INIT
7868 | OPTI_TYPE_PRECOMPUTE_MERKLE
7869 | OPTI_TYPE_MEET_IN_MIDDLE
7870 | OPTI_TYPE_EARLY_SKIP
7871 | OPTI_TYPE_NOT_ITERATED
7872 | OPTI_TYPE_NOT_SALTED
7873 | OPTI_TYPE_RAW_HASH;
7874 dgst_pos0 = 0;
7875 dgst_pos1 = 3;
7876 dgst_pos2 = 2;
7877 dgst_pos3 = 1;
7878 break;
7879
7880 case 1100: hash_type = HASH_TYPE_MD4;
7881 salt_type = SALT_TYPE_INTERN;
7882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7883 opts_type = OPTS_TYPE_PT_GENERATE_LE
7884 | OPTS_TYPE_PT_ADD80
7885 | OPTS_TYPE_PT_ADDBITS14
7886 | OPTS_TYPE_PT_UNICODE
7887 | OPTS_TYPE_ST_ADD80
7888 | OPTS_TYPE_ST_UNICODE
7889 | OPTS_TYPE_ST_LOWER;
7890 kern_type = KERN_TYPE_MD44_PWUSLT;
7891 dgst_size = DGST_SIZE_4_4;
7892 parse_func = dcc_parse_hash;
7893 sort_by_digest = sort_by_digest_4_4;
7894 opti_type = OPTI_TYPE_ZERO_BYTE
7895 | OPTI_TYPE_PRECOMPUTE_INIT
7896 | OPTI_TYPE_PRECOMPUTE_MERKLE
7897 | OPTI_TYPE_EARLY_SKIP
7898 | OPTI_TYPE_NOT_ITERATED;
7899 dgst_pos0 = 0;
7900 dgst_pos1 = 3;
7901 dgst_pos2 = 2;
7902 dgst_pos3 = 1;
7903 break;
7904
7905 case 1400: hash_type = HASH_TYPE_SHA256;
7906 salt_type = SALT_TYPE_NONE;
7907 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7908 opts_type = OPTS_TYPE_PT_GENERATE_BE
7909 | OPTS_TYPE_PT_ADD80
7910 | OPTS_TYPE_PT_ADDBITS15;
7911 kern_type = KERN_TYPE_SHA256;
7912 dgst_size = DGST_SIZE_4_8;
7913 parse_func = sha256_parse_hash;
7914 sort_by_digest = sort_by_digest_4_8;
7915 opti_type = OPTI_TYPE_ZERO_BYTE
7916 | OPTI_TYPE_PRECOMPUTE_INIT
7917 | OPTI_TYPE_PRECOMPUTE_MERKLE
7918 | OPTI_TYPE_EARLY_SKIP
7919 | OPTI_TYPE_NOT_ITERATED
7920 | OPTI_TYPE_NOT_SALTED
7921 | OPTI_TYPE_RAW_HASH;
7922 dgst_pos0 = 3;
7923 dgst_pos1 = 7;
7924 dgst_pos2 = 2;
7925 dgst_pos3 = 6;
7926 break;
7927
7928 case 1410: hash_type = HASH_TYPE_SHA256;
7929 salt_type = SALT_TYPE_INTERN;
7930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7931 opts_type = OPTS_TYPE_PT_GENERATE_BE
7932 | OPTS_TYPE_ST_ADD80
7933 | OPTS_TYPE_ST_ADDBITS15;
7934 kern_type = KERN_TYPE_SHA256_PWSLT;
7935 dgst_size = DGST_SIZE_4_8;
7936 parse_func = sha256s_parse_hash;
7937 sort_by_digest = sort_by_digest_4_8;
7938 opti_type = OPTI_TYPE_ZERO_BYTE
7939 | OPTI_TYPE_PRECOMPUTE_INIT
7940 | OPTI_TYPE_PRECOMPUTE_MERKLE
7941 | OPTI_TYPE_EARLY_SKIP
7942 | OPTI_TYPE_NOT_ITERATED
7943 | OPTI_TYPE_APPENDED_SALT
7944 | OPTI_TYPE_RAW_HASH;
7945 dgst_pos0 = 3;
7946 dgst_pos1 = 7;
7947 dgst_pos2 = 2;
7948 dgst_pos3 = 6;
7949 break;
7950
7951 case 1420: hash_type = HASH_TYPE_SHA256;
7952 salt_type = SALT_TYPE_INTERN;
7953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7954 opts_type = OPTS_TYPE_PT_GENERATE_BE
7955 | OPTS_TYPE_PT_ADD80
7956 | OPTS_TYPE_PT_ADDBITS15;
7957 kern_type = KERN_TYPE_SHA256_SLTPW;
7958 dgst_size = DGST_SIZE_4_8;
7959 parse_func = sha256s_parse_hash;
7960 sort_by_digest = sort_by_digest_4_8;
7961 opti_type = OPTI_TYPE_ZERO_BYTE
7962 | OPTI_TYPE_PRECOMPUTE_INIT
7963 | OPTI_TYPE_PRECOMPUTE_MERKLE
7964 | OPTI_TYPE_EARLY_SKIP
7965 | OPTI_TYPE_NOT_ITERATED
7966 | OPTI_TYPE_PREPENDED_SALT
7967 | OPTI_TYPE_RAW_HASH;
7968 dgst_pos0 = 3;
7969 dgst_pos1 = 7;
7970 dgst_pos2 = 2;
7971 dgst_pos3 = 6;
7972 break;
7973
7974 case 1421: hash_type = HASH_TYPE_SHA256;
7975 salt_type = SALT_TYPE_EMBEDDED;
7976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7977 opts_type = OPTS_TYPE_PT_GENERATE_BE
7978 | OPTS_TYPE_PT_ADD80
7979 | OPTS_TYPE_PT_ADDBITS15;
7980 kern_type = KERN_TYPE_SHA256_SLTPW;
7981 dgst_size = DGST_SIZE_4_8;
7982 parse_func = hmailserver_parse_hash;
7983 sort_by_digest = sort_by_digest_4_8;
7984 opti_type = OPTI_TYPE_ZERO_BYTE
7985 | OPTI_TYPE_PRECOMPUTE_INIT
7986 | OPTI_TYPE_PRECOMPUTE_MERKLE
7987 | OPTI_TYPE_EARLY_SKIP
7988 | OPTI_TYPE_NOT_ITERATED
7989 | OPTI_TYPE_PREPENDED_SALT
7990 | OPTI_TYPE_RAW_HASH;
7991 dgst_pos0 = 3;
7992 dgst_pos1 = 7;
7993 dgst_pos2 = 2;
7994 dgst_pos3 = 6;
7995 break;
7996
7997 case 1430: hash_type = HASH_TYPE_SHA256;
7998 salt_type = SALT_TYPE_INTERN;
7999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8000 opts_type = OPTS_TYPE_PT_GENERATE_BE
8001 | OPTS_TYPE_PT_UNICODE
8002 | OPTS_TYPE_ST_ADD80
8003 | OPTS_TYPE_ST_ADDBITS15;
8004 kern_type = KERN_TYPE_SHA256_PWUSLT;
8005 dgst_size = DGST_SIZE_4_8;
8006 parse_func = sha256s_parse_hash;
8007 sort_by_digest = sort_by_digest_4_8;
8008 opti_type = OPTI_TYPE_ZERO_BYTE
8009 | OPTI_TYPE_PRECOMPUTE_INIT
8010 | OPTI_TYPE_PRECOMPUTE_MERKLE
8011 | OPTI_TYPE_EARLY_SKIP
8012 | OPTI_TYPE_NOT_ITERATED
8013 | OPTI_TYPE_APPENDED_SALT
8014 | OPTI_TYPE_RAW_HASH;
8015 dgst_pos0 = 3;
8016 dgst_pos1 = 7;
8017 dgst_pos2 = 2;
8018 dgst_pos3 = 6;
8019 break;
8020
8021 case 1440: hash_type = HASH_TYPE_SHA256;
8022 salt_type = SALT_TYPE_INTERN;
8023 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8024 opts_type = OPTS_TYPE_PT_GENERATE_BE
8025 | OPTS_TYPE_PT_ADD80
8026 | OPTS_TYPE_PT_ADDBITS15
8027 | OPTS_TYPE_PT_UNICODE;
8028 kern_type = KERN_TYPE_SHA256_SLTPWU;
8029 dgst_size = DGST_SIZE_4_8;
8030 parse_func = sha256s_parse_hash;
8031 sort_by_digest = sort_by_digest_4_8;
8032 opti_type = OPTI_TYPE_ZERO_BYTE
8033 | OPTI_TYPE_PRECOMPUTE_INIT
8034 | OPTI_TYPE_PRECOMPUTE_MERKLE
8035 | OPTI_TYPE_EARLY_SKIP
8036 | OPTI_TYPE_NOT_ITERATED
8037 | OPTI_TYPE_PREPENDED_SALT
8038 | OPTI_TYPE_RAW_HASH;
8039 dgst_pos0 = 3;
8040 dgst_pos1 = 7;
8041 dgst_pos2 = 2;
8042 dgst_pos3 = 6;
8043 break;
8044
8045 case 1441: hash_type = HASH_TYPE_SHA256;
8046 salt_type = SALT_TYPE_EMBEDDED;
8047 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8048 opts_type = OPTS_TYPE_PT_GENERATE_BE
8049 | OPTS_TYPE_PT_ADD80
8050 | OPTS_TYPE_PT_ADDBITS15
8051 | OPTS_TYPE_PT_UNICODE
8052 | OPTS_TYPE_ST_BASE64;
8053 kern_type = KERN_TYPE_SHA256_SLTPWU;
8054 dgst_size = DGST_SIZE_4_8;
8055 parse_func = episerver4_parse_hash;
8056 sort_by_digest = sort_by_digest_4_8;
8057 opti_type = OPTI_TYPE_ZERO_BYTE
8058 | OPTI_TYPE_PRECOMPUTE_INIT
8059 | OPTI_TYPE_PRECOMPUTE_MERKLE
8060 | OPTI_TYPE_EARLY_SKIP
8061 | OPTI_TYPE_NOT_ITERATED
8062 | OPTI_TYPE_PREPENDED_SALT
8063 | OPTI_TYPE_RAW_HASH;
8064 dgst_pos0 = 3;
8065 dgst_pos1 = 7;
8066 dgst_pos2 = 2;
8067 dgst_pos3 = 6;
8068 break;
8069
8070 case 1450: hash_type = HASH_TYPE_SHA256;
8071 salt_type = SALT_TYPE_INTERN;
8072 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8073 opts_type = OPTS_TYPE_PT_GENERATE_BE
8074 | OPTS_TYPE_ST_ADD80;
8075 kern_type = KERN_TYPE_HMACSHA256_PW;
8076 dgst_size = DGST_SIZE_4_8;
8077 parse_func = hmacsha256_parse_hash;
8078 sort_by_digest = sort_by_digest_4_8;
8079 opti_type = OPTI_TYPE_ZERO_BYTE
8080 | OPTI_TYPE_NOT_ITERATED;
8081 dgst_pos0 = 3;
8082 dgst_pos1 = 7;
8083 dgst_pos2 = 2;
8084 dgst_pos3 = 6;
8085 break;
8086
8087 case 1460: hash_type = HASH_TYPE_SHA256;
8088 salt_type = SALT_TYPE_INTERN;
8089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8090 opts_type = OPTS_TYPE_PT_GENERATE_BE
8091 | OPTS_TYPE_PT_ADD80
8092 | OPTS_TYPE_PT_ADDBITS15;
8093 kern_type = KERN_TYPE_HMACSHA256_SLT;
8094 dgst_size = DGST_SIZE_4_8;
8095 parse_func = hmacsha256_parse_hash;
8096 sort_by_digest = sort_by_digest_4_8;
8097 opti_type = OPTI_TYPE_ZERO_BYTE
8098 | OPTI_TYPE_NOT_ITERATED;
8099 dgst_pos0 = 3;
8100 dgst_pos1 = 7;
8101 dgst_pos2 = 2;
8102 dgst_pos3 = 6;
8103 break;
8104
8105 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8106 salt_type = SALT_TYPE_EMBEDDED;
8107 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8108 opts_type = OPTS_TYPE_PT_GENERATE_LE
8109 | OPTS_TYPE_PT_BITSLICE;
8110 kern_type = KERN_TYPE_DESCRYPT;
8111 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8112 parse_func = descrypt_parse_hash;
8113 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8114 opti_type = OPTI_TYPE_ZERO_BYTE
8115 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8116 dgst_pos0 = 0;
8117 dgst_pos1 = 1;
8118 dgst_pos2 = 2;
8119 dgst_pos3 = 3;
8120 break;
8121
8122 case 1600: hash_type = HASH_TYPE_MD5;
8123 salt_type = SALT_TYPE_EMBEDDED;
8124 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8125 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8126 kern_type = KERN_TYPE_APR1CRYPT;
8127 dgst_size = DGST_SIZE_4_4;
8128 parse_func = md5apr1_parse_hash;
8129 sort_by_digest = sort_by_digest_4_4;
8130 opti_type = OPTI_TYPE_ZERO_BYTE;
8131 dgst_pos0 = 0;
8132 dgst_pos1 = 1;
8133 dgst_pos2 = 2;
8134 dgst_pos3 = 3;
8135 break;
8136
8137 case 1700: hash_type = HASH_TYPE_SHA512;
8138 salt_type = SALT_TYPE_NONE;
8139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8140 opts_type = OPTS_TYPE_PT_GENERATE_BE
8141 | OPTS_TYPE_PT_ADD80
8142 | OPTS_TYPE_PT_ADDBITS15;
8143 kern_type = KERN_TYPE_SHA512;
8144 dgst_size = DGST_SIZE_8_8;
8145 parse_func = sha512_parse_hash;
8146 sort_by_digest = sort_by_digest_8_8;
8147 opti_type = OPTI_TYPE_ZERO_BYTE
8148 | OPTI_TYPE_PRECOMPUTE_INIT
8149 | OPTI_TYPE_PRECOMPUTE_MERKLE
8150 | OPTI_TYPE_EARLY_SKIP
8151 | OPTI_TYPE_NOT_ITERATED
8152 | OPTI_TYPE_NOT_SALTED
8153 | OPTI_TYPE_USES_BITS_64
8154 | OPTI_TYPE_RAW_HASH;
8155 dgst_pos0 = 14;
8156 dgst_pos1 = 15;
8157 dgst_pos2 = 6;
8158 dgst_pos3 = 7;
8159 break;
8160
8161 case 1710: hash_type = HASH_TYPE_SHA512;
8162 salt_type = SALT_TYPE_INTERN;
8163 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8164 opts_type = OPTS_TYPE_PT_GENERATE_BE
8165 | OPTS_TYPE_ST_ADD80
8166 | OPTS_TYPE_ST_ADDBITS15;
8167 kern_type = KERN_TYPE_SHA512_PWSLT;
8168 dgst_size = DGST_SIZE_8_8;
8169 parse_func = sha512s_parse_hash;
8170 sort_by_digest = sort_by_digest_8_8;
8171 opti_type = OPTI_TYPE_ZERO_BYTE
8172 | OPTI_TYPE_PRECOMPUTE_INIT
8173 | OPTI_TYPE_PRECOMPUTE_MERKLE
8174 | OPTI_TYPE_EARLY_SKIP
8175 | OPTI_TYPE_NOT_ITERATED
8176 | OPTI_TYPE_APPENDED_SALT
8177 | OPTI_TYPE_USES_BITS_64
8178 | OPTI_TYPE_RAW_HASH;
8179 dgst_pos0 = 14;
8180 dgst_pos1 = 15;
8181 dgst_pos2 = 6;
8182 dgst_pos3 = 7;
8183 break;
8184
8185 case 1711: hash_type = HASH_TYPE_SHA512;
8186 salt_type = SALT_TYPE_EMBEDDED;
8187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8188 opts_type = OPTS_TYPE_PT_GENERATE_BE
8189 | OPTS_TYPE_ST_ADD80
8190 | OPTS_TYPE_ST_ADDBITS15;
8191 kern_type = KERN_TYPE_SHA512_PWSLT;
8192 dgst_size = DGST_SIZE_8_8;
8193 parse_func = sha512b64s_parse_hash;
8194 sort_by_digest = sort_by_digest_8_8;
8195 opti_type = OPTI_TYPE_ZERO_BYTE
8196 | OPTI_TYPE_PRECOMPUTE_INIT
8197 | OPTI_TYPE_PRECOMPUTE_MERKLE
8198 | OPTI_TYPE_EARLY_SKIP
8199 | OPTI_TYPE_NOT_ITERATED
8200 | OPTI_TYPE_APPENDED_SALT
8201 | OPTI_TYPE_USES_BITS_64
8202 | OPTI_TYPE_RAW_HASH;
8203 dgst_pos0 = 14;
8204 dgst_pos1 = 15;
8205 dgst_pos2 = 6;
8206 dgst_pos3 = 7;
8207 break;
8208
8209 case 1720: hash_type = HASH_TYPE_SHA512;
8210 salt_type = SALT_TYPE_INTERN;
8211 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8212 opts_type = OPTS_TYPE_PT_GENERATE_BE
8213 | OPTS_TYPE_PT_ADD80
8214 | OPTS_TYPE_PT_ADDBITS15;
8215 kern_type = KERN_TYPE_SHA512_SLTPW;
8216 dgst_size = DGST_SIZE_8_8;
8217 parse_func = sha512s_parse_hash;
8218 sort_by_digest = sort_by_digest_8_8;
8219 opti_type = OPTI_TYPE_ZERO_BYTE
8220 | OPTI_TYPE_PRECOMPUTE_INIT
8221 | OPTI_TYPE_PRECOMPUTE_MERKLE
8222 | OPTI_TYPE_EARLY_SKIP
8223 | OPTI_TYPE_NOT_ITERATED
8224 | OPTI_TYPE_PREPENDED_SALT
8225 | OPTI_TYPE_USES_BITS_64
8226 | OPTI_TYPE_RAW_HASH;
8227 dgst_pos0 = 14;
8228 dgst_pos1 = 15;
8229 dgst_pos2 = 6;
8230 dgst_pos3 = 7;
8231 break;
8232
8233 case 1722: hash_type = HASH_TYPE_SHA512;
8234 salt_type = SALT_TYPE_EMBEDDED;
8235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8236 opts_type = OPTS_TYPE_PT_GENERATE_BE
8237 | OPTS_TYPE_PT_ADD80
8238 | OPTS_TYPE_PT_ADDBITS15
8239 | OPTS_TYPE_ST_HEX;
8240 kern_type = KERN_TYPE_SHA512_SLTPW;
8241 dgst_size = DGST_SIZE_8_8;
8242 parse_func = osx512_parse_hash;
8243 sort_by_digest = sort_by_digest_8_8;
8244 opti_type = OPTI_TYPE_ZERO_BYTE
8245 | OPTI_TYPE_PRECOMPUTE_INIT
8246 | OPTI_TYPE_PRECOMPUTE_MERKLE
8247 | OPTI_TYPE_EARLY_SKIP
8248 | OPTI_TYPE_NOT_ITERATED
8249 | OPTI_TYPE_PREPENDED_SALT
8250 | OPTI_TYPE_USES_BITS_64
8251 | OPTI_TYPE_RAW_HASH;
8252 dgst_pos0 = 14;
8253 dgst_pos1 = 15;
8254 dgst_pos2 = 6;
8255 dgst_pos3 = 7;
8256 break;
8257
8258 case 1730: hash_type = HASH_TYPE_SHA512;
8259 salt_type = SALT_TYPE_INTERN;
8260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8261 opts_type = OPTS_TYPE_PT_GENERATE_BE
8262 | OPTS_TYPE_PT_UNICODE
8263 | OPTS_TYPE_ST_ADD80
8264 | OPTS_TYPE_ST_ADDBITS15;
8265 kern_type = KERN_TYPE_SHA512_PWSLTU;
8266 dgst_size = DGST_SIZE_8_8;
8267 parse_func = sha512s_parse_hash;
8268 sort_by_digest = sort_by_digest_8_8;
8269 opti_type = OPTI_TYPE_ZERO_BYTE
8270 | OPTI_TYPE_PRECOMPUTE_INIT
8271 | OPTI_TYPE_PRECOMPUTE_MERKLE
8272 | OPTI_TYPE_EARLY_SKIP
8273 | OPTI_TYPE_NOT_ITERATED
8274 | OPTI_TYPE_APPENDED_SALT
8275 | OPTI_TYPE_USES_BITS_64
8276 | OPTI_TYPE_RAW_HASH;
8277 dgst_pos0 = 14;
8278 dgst_pos1 = 15;
8279 dgst_pos2 = 6;
8280 dgst_pos3 = 7;
8281 break;
8282
8283 case 1731: hash_type = HASH_TYPE_SHA512;
8284 salt_type = SALT_TYPE_EMBEDDED;
8285 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8286 opts_type = OPTS_TYPE_PT_GENERATE_BE
8287 | OPTS_TYPE_PT_UNICODE
8288 | OPTS_TYPE_ST_ADD80
8289 | OPTS_TYPE_ST_ADDBITS15
8290 | OPTS_TYPE_ST_HEX;
8291 kern_type = KERN_TYPE_SHA512_PWSLTU;
8292 dgst_size = DGST_SIZE_8_8;
8293 parse_func = mssql2012_parse_hash;
8294 sort_by_digest = sort_by_digest_8_8;
8295 opti_type = OPTI_TYPE_ZERO_BYTE
8296 | OPTI_TYPE_PRECOMPUTE_INIT
8297 | OPTI_TYPE_PRECOMPUTE_MERKLE
8298 | OPTI_TYPE_EARLY_SKIP
8299 | OPTI_TYPE_NOT_ITERATED
8300 | OPTI_TYPE_APPENDED_SALT
8301 | OPTI_TYPE_USES_BITS_64
8302 | OPTI_TYPE_RAW_HASH;
8303 dgst_pos0 = 14;
8304 dgst_pos1 = 15;
8305 dgst_pos2 = 6;
8306 dgst_pos3 = 7;
8307 break;
8308
8309 case 1740: hash_type = HASH_TYPE_SHA512;
8310 salt_type = SALT_TYPE_INTERN;
8311 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8312 opts_type = OPTS_TYPE_PT_GENERATE_BE
8313 | OPTS_TYPE_PT_ADD80
8314 | OPTS_TYPE_PT_ADDBITS15
8315 | OPTS_TYPE_PT_UNICODE;
8316 kern_type = KERN_TYPE_SHA512_SLTPWU;
8317 dgst_size = DGST_SIZE_8_8;
8318 parse_func = sha512s_parse_hash;
8319 sort_by_digest = sort_by_digest_8_8;
8320 opti_type = OPTI_TYPE_ZERO_BYTE
8321 | OPTI_TYPE_PRECOMPUTE_INIT
8322 | OPTI_TYPE_PRECOMPUTE_MERKLE
8323 | OPTI_TYPE_EARLY_SKIP
8324 | OPTI_TYPE_NOT_ITERATED
8325 | OPTI_TYPE_PREPENDED_SALT
8326 | OPTI_TYPE_USES_BITS_64
8327 | OPTI_TYPE_RAW_HASH;
8328 dgst_pos0 = 14;
8329 dgst_pos1 = 15;
8330 dgst_pos2 = 6;
8331 dgst_pos3 = 7;
8332 break;
8333
8334 case 1750: hash_type = HASH_TYPE_SHA512;
8335 salt_type = SALT_TYPE_INTERN;
8336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8337 opts_type = OPTS_TYPE_PT_GENERATE_BE
8338 | OPTS_TYPE_ST_ADD80;
8339 kern_type = KERN_TYPE_HMACSHA512_PW;
8340 dgst_size = DGST_SIZE_8_8;
8341 parse_func = hmacsha512_parse_hash;
8342 sort_by_digest = sort_by_digest_8_8;
8343 opti_type = OPTI_TYPE_ZERO_BYTE
8344 | OPTI_TYPE_USES_BITS_64
8345 | OPTI_TYPE_NOT_ITERATED;
8346 dgst_pos0 = 14;
8347 dgst_pos1 = 15;
8348 dgst_pos2 = 6;
8349 dgst_pos3 = 7;
8350 break;
8351
8352 case 1760: hash_type = HASH_TYPE_SHA512;
8353 salt_type = SALT_TYPE_INTERN;
8354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8355 opts_type = OPTS_TYPE_PT_GENERATE_BE
8356 | OPTS_TYPE_PT_ADD80
8357 | OPTS_TYPE_PT_ADDBITS15;
8358 kern_type = KERN_TYPE_HMACSHA512_SLT;
8359 dgst_size = DGST_SIZE_8_8;
8360 parse_func = hmacsha512_parse_hash;
8361 sort_by_digest = sort_by_digest_8_8;
8362 opti_type = OPTI_TYPE_ZERO_BYTE
8363 | OPTI_TYPE_USES_BITS_64
8364 | OPTI_TYPE_NOT_ITERATED;
8365 dgst_pos0 = 14;
8366 dgst_pos1 = 15;
8367 dgst_pos2 = 6;
8368 dgst_pos3 = 7;
8369 break;
8370
8371 case 1800: hash_type = HASH_TYPE_SHA512;
8372 salt_type = SALT_TYPE_EMBEDDED;
8373 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8374 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8375 kern_type = KERN_TYPE_SHA512CRYPT;
8376 dgst_size = DGST_SIZE_8_8;
8377 parse_func = sha512crypt_parse_hash;
8378 sort_by_digest = sort_by_digest_8_8;
8379 opti_type = OPTI_TYPE_ZERO_BYTE
8380 | OPTI_TYPE_USES_BITS_64;
8381 dgst_pos0 = 0;
8382 dgst_pos1 = 1;
8383 dgst_pos2 = 2;
8384 dgst_pos3 = 3;
8385 break;
8386
8387 case 2100: hash_type = HASH_TYPE_DCC2;
8388 salt_type = SALT_TYPE_EMBEDDED;
8389 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8390 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8391 | OPTS_TYPE_ST_LOWER
8392 | OPTS_TYPE_ST_UNICODE;
8393 kern_type = KERN_TYPE_DCC2;
8394 dgst_size = DGST_SIZE_4_4;
8395 parse_func = dcc2_parse_hash;
8396 sort_by_digest = sort_by_digest_4_4;
8397 opti_type = OPTI_TYPE_ZERO_BYTE
8398 | OPTI_TYPE_SLOW_HASH_SIMD;
8399 dgst_pos0 = 0;
8400 dgst_pos1 = 1;
8401 dgst_pos2 = 2;
8402 dgst_pos3 = 3;
8403 break;
8404
8405 case 2400: hash_type = HASH_TYPE_MD5;
8406 salt_type = SALT_TYPE_NONE;
8407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8408 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8409 kern_type = KERN_TYPE_MD5PIX;
8410 dgst_size = DGST_SIZE_4_4;
8411 parse_func = md5pix_parse_hash;
8412 sort_by_digest = sort_by_digest_4_4;
8413 opti_type = OPTI_TYPE_ZERO_BYTE
8414 | OPTI_TYPE_PRECOMPUTE_INIT
8415 | OPTI_TYPE_PRECOMPUTE_MERKLE
8416 | OPTI_TYPE_EARLY_SKIP
8417 | OPTI_TYPE_NOT_ITERATED
8418 | OPTI_TYPE_NOT_SALTED;
8419 dgst_pos0 = 0;
8420 dgst_pos1 = 3;
8421 dgst_pos2 = 2;
8422 dgst_pos3 = 1;
8423 break;
8424
8425 case 2410: hash_type = HASH_TYPE_MD5;
8426 salt_type = SALT_TYPE_INTERN;
8427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8428 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8429 kern_type = KERN_TYPE_MD5ASA;
8430 dgst_size = DGST_SIZE_4_4;
8431 parse_func = md5asa_parse_hash;
8432 sort_by_digest = sort_by_digest_4_4;
8433 opti_type = OPTI_TYPE_ZERO_BYTE
8434 | OPTI_TYPE_PRECOMPUTE_INIT
8435 | OPTI_TYPE_PRECOMPUTE_MERKLE
8436 | OPTI_TYPE_EARLY_SKIP
8437 | OPTI_TYPE_NOT_ITERATED;
8438 dgst_pos0 = 0;
8439 dgst_pos1 = 3;
8440 dgst_pos2 = 2;
8441 dgst_pos3 = 1;
8442 break;
8443
8444 case 2500: hash_type = HASH_TYPE_WPA;
8445 salt_type = SALT_TYPE_EMBEDDED;
8446 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8447 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8448 kern_type = KERN_TYPE_WPA;
8449 dgst_size = DGST_SIZE_4_4;
8450 parse_func = wpa_parse_hash;
8451 sort_by_digest = sort_by_digest_4_4;
8452 opti_type = OPTI_TYPE_ZERO_BYTE
8453 | OPTI_TYPE_SLOW_HASH_SIMD;
8454 dgst_pos0 = 0;
8455 dgst_pos1 = 1;
8456 dgst_pos2 = 2;
8457 dgst_pos3 = 3;
8458 break;
8459
8460 case 2600: hash_type = HASH_TYPE_MD5;
8461 salt_type = SALT_TYPE_VIRTUAL;
8462 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8463 opts_type = OPTS_TYPE_PT_GENERATE_LE
8464 | OPTS_TYPE_PT_ADD80
8465 | OPTS_TYPE_PT_ADDBITS14
8466 | OPTS_TYPE_ST_ADD80;
8467 kern_type = KERN_TYPE_MD55_PWSLT1;
8468 dgst_size = DGST_SIZE_4_4;
8469 parse_func = md5md5_parse_hash;
8470 sort_by_digest = sort_by_digest_4_4;
8471 opti_type = OPTI_TYPE_ZERO_BYTE
8472 | OPTI_TYPE_PRECOMPUTE_INIT
8473 | OPTI_TYPE_PRECOMPUTE_MERKLE
8474 | OPTI_TYPE_EARLY_SKIP;
8475 dgst_pos0 = 0;
8476 dgst_pos1 = 3;
8477 dgst_pos2 = 2;
8478 dgst_pos3 = 1;
8479 break;
8480
8481 case 2611: hash_type = HASH_TYPE_MD5;
8482 salt_type = SALT_TYPE_INTERN;
8483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8484 opts_type = OPTS_TYPE_PT_GENERATE_LE
8485 | OPTS_TYPE_PT_ADD80
8486 | OPTS_TYPE_PT_ADDBITS14
8487 | OPTS_TYPE_ST_ADD80;
8488 kern_type = KERN_TYPE_MD55_PWSLT1;
8489 dgst_size = DGST_SIZE_4_4;
8490 parse_func = vb3_parse_hash;
8491 sort_by_digest = sort_by_digest_4_4;
8492 opti_type = OPTI_TYPE_ZERO_BYTE
8493 | OPTI_TYPE_PRECOMPUTE_INIT
8494 | OPTI_TYPE_PRECOMPUTE_MERKLE
8495 | OPTI_TYPE_EARLY_SKIP;
8496 dgst_pos0 = 0;
8497 dgst_pos1 = 3;
8498 dgst_pos2 = 2;
8499 dgst_pos3 = 1;
8500 break;
8501
8502 case 2612: hash_type = HASH_TYPE_MD5;
8503 salt_type = SALT_TYPE_EMBEDDED;
8504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8505 opts_type = OPTS_TYPE_PT_GENERATE_LE
8506 | OPTS_TYPE_PT_ADD80
8507 | OPTS_TYPE_PT_ADDBITS14
8508 | OPTS_TYPE_ST_ADD80
8509 | OPTS_TYPE_ST_HEX;
8510 kern_type = KERN_TYPE_MD55_PWSLT1;
8511 dgst_size = DGST_SIZE_4_4;
8512 parse_func = phps_parse_hash;
8513 sort_by_digest = sort_by_digest_4_4;
8514 opti_type = OPTI_TYPE_ZERO_BYTE
8515 | OPTI_TYPE_PRECOMPUTE_INIT
8516 | OPTI_TYPE_PRECOMPUTE_MERKLE
8517 | OPTI_TYPE_EARLY_SKIP;
8518 dgst_pos0 = 0;
8519 dgst_pos1 = 3;
8520 dgst_pos2 = 2;
8521 dgst_pos3 = 1;
8522 break;
8523
8524 case 2711: hash_type = HASH_TYPE_MD5;
8525 salt_type = SALT_TYPE_INTERN;
8526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8527 opts_type = OPTS_TYPE_PT_GENERATE_LE
8528 | OPTS_TYPE_PT_ADD80
8529 | OPTS_TYPE_PT_ADDBITS14
8530 | OPTS_TYPE_ST_ADD80;
8531 kern_type = KERN_TYPE_MD55_PWSLT2;
8532 dgst_size = DGST_SIZE_4_4;
8533 parse_func = vb30_parse_hash;
8534 sort_by_digest = sort_by_digest_4_4;
8535 opti_type = OPTI_TYPE_ZERO_BYTE
8536 | OPTI_TYPE_PRECOMPUTE_INIT
8537 | OPTI_TYPE_EARLY_SKIP;
8538 dgst_pos0 = 0;
8539 dgst_pos1 = 3;
8540 dgst_pos2 = 2;
8541 dgst_pos3 = 1;
8542 break;
8543
8544 case 2811: hash_type = HASH_TYPE_MD5;
8545 salt_type = SALT_TYPE_INTERN;
8546 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8547 opts_type = OPTS_TYPE_PT_GENERATE_LE
8548 | OPTS_TYPE_PT_ADD80
8549 | OPTS_TYPE_PT_ADDBITS14;
8550 kern_type = KERN_TYPE_MD55_SLTPW;
8551 dgst_size = DGST_SIZE_4_4;
8552 parse_func = ipb2_parse_hash;
8553 sort_by_digest = sort_by_digest_4_4;
8554 opti_type = OPTI_TYPE_ZERO_BYTE
8555 | OPTI_TYPE_PRECOMPUTE_INIT
8556 | OPTI_TYPE_EARLY_SKIP;
8557 dgst_pos0 = 0;
8558 dgst_pos1 = 3;
8559 dgst_pos2 = 2;
8560 dgst_pos3 = 1;
8561 break;
8562
8563 case 3000: hash_type = HASH_TYPE_LM;
8564 salt_type = SALT_TYPE_NONE;
8565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8566 opts_type = OPTS_TYPE_PT_GENERATE_LE
8567 | OPTS_TYPE_PT_UPPER
8568 | OPTS_TYPE_PT_BITSLICE;
8569 kern_type = KERN_TYPE_LM;
8570 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8571 parse_func = lm_parse_hash;
8572 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8573 opti_type = OPTI_TYPE_ZERO_BYTE
8574 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8575 dgst_pos0 = 0;
8576 dgst_pos1 = 1;
8577 dgst_pos2 = 2;
8578 dgst_pos3 = 3;
8579 break;
8580
8581 case 3100: hash_type = HASH_TYPE_ORACLEH;
8582 salt_type = SALT_TYPE_INTERN;
8583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8584 opts_type = OPTS_TYPE_PT_GENERATE_LE
8585 | OPTS_TYPE_PT_UPPER
8586 | OPTS_TYPE_ST_UPPER;
8587 kern_type = KERN_TYPE_ORACLEH;
8588 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8589 parse_func = oracleh_parse_hash;
8590 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8591 opti_type = OPTI_TYPE_ZERO_BYTE;
8592 dgst_pos0 = 0;
8593 dgst_pos1 = 1;
8594 dgst_pos2 = 2;
8595 dgst_pos3 = 3;
8596 break;
8597
8598 case 3200: hash_type = HASH_TYPE_BCRYPT;
8599 salt_type = SALT_TYPE_EMBEDDED;
8600 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8601 opts_type = OPTS_TYPE_PT_GENERATE_LE
8602 | OPTS_TYPE_ST_GENERATE_LE;
8603 kern_type = KERN_TYPE_BCRYPT;
8604 dgst_size = DGST_SIZE_4_6;
8605 parse_func = bcrypt_parse_hash;
8606 sort_by_digest = sort_by_digest_4_6;
8607 opti_type = OPTI_TYPE_ZERO_BYTE;
8608 dgst_pos0 = 0;
8609 dgst_pos1 = 1;
8610 dgst_pos2 = 2;
8611 dgst_pos3 = 3;
8612 break;
8613
8614 case 3710: hash_type = HASH_TYPE_MD5;
8615 salt_type = SALT_TYPE_INTERN;
8616 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8617 opts_type = OPTS_TYPE_PT_GENERATE_LE
8618 | OPTS_TYPE_PT_ADD80
8619 | OPTS_TYPE_PT_ADDBITS14;
8620 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8621 dgst_size = DGST_SIZE_4_4;
8622 parse_func = md5s_parse_hash;
8623 sort_by_digest = sort_by_digest_4_4;
8624 opti_type = OPTI_TYPE_ZERO_BYTE
8625 | OPTI_TYPE_PRECOMPUTE_INIT
8626 | OPTI_TYPE_PRECOMPUTE_MERKLE
8627 | OPTI_TYPE_EARLY_SKIP;
8628 dgst_pos0 = 0;
8629 dgst_pos1 = 3;
8630 dgst_pos2 = 2;
8631 dgst_pos3 = 1;
8632 break;
8633
8634 case 3711: hash_type = HASH_TYPE_MD5;
8635 salt_type = SALT_TYPE_EMBEDDED;
8636 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8637 opts_type = OPTS_TYPE_PT_GENERATE_LE
8638 | OPTS_TYPE_PT_ADD80
8639 | OPTS_TYPE_PT_ADDBITS14;
8640 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8641 dgst_size = DGST_SIZE_4_4;
8642 parse_func = mediawiki_b_parse_hash;
8643 sort_by_digest = sort_by_digest_4_4;
8644 opti_type = OPTI_TYPE_ZERO_BYTE
8645 | OPTI_TYPE_PRECOMPUTE_INIT
8646 | OPTI_TYPE_PRECOMPUTE_MERKLE
8647 | OPTI_TYPE_EARLY_SKIP;
8648 dgst_pos0 = 0;
8649 dgst_pos1 = 3;
8650 dgst_pos2 = 2;
8651 dgst_pos3 = 1;
8652 break;
8653
8654 case 3800: hash_type = HASH_TYPE_MD5;
8655 salt_type = SALT_TYPE_INTERN;
8656 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8657 opts_type = OPTS_TYPE_PT_GENERATE_LE
8658 | OPTS_TYPE_ST_ADDBITS14;
8659 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8660 dgst_size = DGST_SIZE_4_4;
8661 parse_func = md5s_parse_hash;
8662 sort_by_digest = sort_by_digest_4_4;
8663 opti_type = OPTI_TYPE_ZERO_BYTE
8664 | OPTI_TYPE_PRECOMPUTE_INIT
8665 | OPTI_TYPE_PRECOMPUTE_MERKLE
8666 | OPTI_TYPE_EARLY_SKIP
8667 | OPTI_TYPE_NOT_ITERATED
8668 | OPTI_TYPE_RAW_HASH;
8669 dgst_pos0 = 0;
8670 dgst_pos1 = 3;
8671 dgst_pos2 = 2;
8672 dgst_pos3 = 1;
8673 break;
8674
8675 case 4300: hash_type = HASH_TYPE_MD5;
8676 salt_type = SALT_TYPE_VIRTUAL;
8677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8678 opts_type = OPTS_TYPE_PT_GENERATE_LE
8679 | OPTS_TYPE_PT_ADD80
8680 | OPTS_TYPE_PT_ADDBITS14
8681 | OPTS_TYPE_ST_ADD80;
8682 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8683 dgst_size = DGST_SIZE_4_4;
8684 parse_func = md5md5_parse_hash;
8685 sort_by_digest = sort_by_digest_4_4;
8686 opti_type = OPTI_TYPE_ZERO_BYTE
8687 | OPTI_TYPE_PRECOMPUTE_INIT
8688 | OPTI_TYPE_PRECOMPUTE_MERKLE
8689 | OPTI_TYPE_EARLY_SKIP;
8690 dgst_pos0 = 0;
8691 dgst_pos1 = 3;
8692 dgst_pos2 = 2;
8693 dgst_pos3 = 1;
8694 break;
8695
8696
8697 case 4400: hash_type = HASH_TYPE_MD5;
8698 salt_type = SALT_TYPE_NONE;
8699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8700 opts_type = OPTS_TYPE_PT_GENERATE_BE
8701 | OPTS_TYPE_PT_ADD80
8702 | OPTS_TYPE_PT_ADDBITS15;
8703 kern_type = KERN_TYPE_MD5_SHA1;
8704 dgst_size = DGST_SIZE_4_4;
8705 parse_func = md5_parse_hash;
8706 sort_by_digest = sort_by_digest_4_4;
8707 opti_type = OPTI_TYPE_ZERO_BYTE
8708 | OPTI_TYPE_PRECOMPUTE_INIT
8709 | OPTI_TYPE_PRECOMPUTE_MERKLE
8710 | OPTI_TYPE_EARLY_SKIP
8711 | OPTI_TYPE_NOT_ITERATED
8712 | OPTI_TYPE_NOT_SALTED
8713 | OPTI_TYPE_RAW_HASH;
8714 dgst_pos0 = 0;
8715 dgst_pos1 = 3;
8716 dgst_pos2 = 2;
8717 dgst_pos3 = 1;
8718 break;
8719
8720 case 4500: hash_type = HASH_TYPE_SHA1;
8721 salt_type = SALT_TYPE_NONE;
8722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8723 opts_type = OPTS_TYPE_PT_GENERATE_BE
8724 | OPTS_TYPE_PT_ADD80
8725 | OPTS_TYPE_PT_ADDBITS15;
8726 kern_type = KERN_TYPE_SHA11;
8727 dgst_size = DGST_SIZE_4_5;
8728 parse_func = sha1_parse_hash;
8729 sort_by_digest = sort_by_digest_4_5;
8730 opti_type = OPTI_TYPE_ZERO_BYTE
8731 | OPTI_TYPE_PRECOMPUTE_INIT
8732 | OPTI_TYPE_PRECOMPUTE_MERKLE
8733 | OPTI_TYPE_EARLY_SKIP
8734 | OPTI_TYPE_NOT_SALTED;
8735 dgst_pos0 = 3;
8736 dgst_pos1 = 4;
8737 dgst_pos2 = 2;
8738 dgst_pos3 = 1;
8739 break;
8740
8741 case 4700: hash_type = HASH_TYPE_SHA1;
8742 salt_type = SALT_TYPE_NONE;
8743 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8744 opts_type = OPTS_TYPE_PT_GENERATE_LE
8745 | OPTS_TYPE_PT_ADD80
8746 | OPTS_TYPE_PT_ADDBITS14;
8747 kern_type = KERN_TYPE_SHA1_MD5;
8748 dgst_size = DGST_SIZE_4_5;
8749 parse_func = sha1_parse_hash;
8750 sort_by_digest = sort_by_digest_4_5;
8751 opti_type = OPTI_TYPE_ZERO_BYTE
8752 | OPTI_TYPE_PRECOMPUTE_INIT
8753 | OPTI_TYPE_PRECOMPUTE_MERKLE
8754 | OPTI_TYPE_EARLY_SKIP
8755 | OPTI_TYPE_NOT_ITERATED
8756 | OPTI_TYPE_NOT_SALTED
8757 | OPTI_TYPE_RAW_HASH;
8758 dgst_pos0 = 3;
8759 dgst_pos1 = 4;
8760 dgst_pos2 = 2;
8761 dgst_pos3 = 1;
8762 break;
8763
8764 case 4800: hash_type = HASH_TYPE_MD5;
8765 salt_type = SALT_TYPE_EMBEDDED;
8766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8767 opts_type = OPTS_TYPE_PT_GENERATE_LE
8768 | OPTS_TYPE_PT_ADDBITS14;
8769 kern_type = KERN_TYPE_MD5_CHAP;
8770 dgst_size = DGST_SIZE_4_4;
8771 parse_func = chap_parse_hash;
8772 sort_by_digest = sort_by_digest_4_4;
8773 opti_type = OPTI_TYPE_ZERO_BYTE
8774 | OPTI_TYPE_PRECOMPUTE_INIT
8775 | OPTI_TYPE_PRECOMPUTE_MERKLE
8776 | OPTI_TYPE_MEET_IN_MIDDLE
8777 | OPTI_TYPE_EARLY_SKIP
8778 | OPTI_TYPE_NOT_ITERATED
8779 | OPTI_TYPE_RAW_HASH;
8780 dgst_pos0 = 0;
8781 dgst_pos1 = 3;
8782 dgst_pos2 = 2;
8783 dgst_pos3 = 1;
8784 break;
8785
8786 case 4900: hash_type = HASH_TYPE_SHA1;
8787 salt_type = SALT_TYPE_INTERN;
8788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8789 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8790 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8791 dgst_size = DGST_SIZE_4_5;
8792 parse_func = sha1s_parse_hash;
8793 sort_by_digest = sort_by_digest_4_5;
8794 opti_type = OPTI_TYPE_ZERO_BYTE
8795 | OPTI_TYPE_PRECOMPUTE_INIT
8796 | OPTI_TYPE_PRECOMPUTE_MERKLE
8797 | OPTI_TYPE_EARLY_SKIP;
8798 dgst_pos0 = 3;
8799 dgst_pos1 = 4;
8800 dgst_pos2 = 2;
8801 dgst_pos3 = 1;
8802 break;
8803
8804 case 5000: hash_type = HASH_TYPE_KECCAK;
8805 salt_type = SALT_TYPE_EMBEDDED;
8806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8807 opts_type = OPTS_TYPE_PT_GENERATE_LE
8808 | OPTS_TYPE_PT_ADD01;
8809 kern_type = KERN_TYPE_KECCAK;
8810 dgst_size = DGST_SIZE_8_25;
8811 parse_func = keccak_parse_hash;
8812 sort_by_digest = sort_by_digest_8_25;
8813 opti_type = OPTI_TYPE_ZERO_BYTE
8814 | OPTI_TYPE_USES_BITS_64
8815 | OPTI_TYPE_RAW_HASH;
8816 dgst_pos0 = 2;
8817 dgst_pos1 = 3;
8818 dgst_pos2 = 4;
8819 dgst_pos3 = 5;
8820 break;
8821
8822 case 5100: hash_type = HASH_TYPE_MD5H;
8823 salt_type = SALT_TYPE_NONE;
8824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8825 opts_type = OPTS_TYPE_PT_GENERATE_LE
8826 | OPTS_TYPE_PT_ADD80
8827 | OPTS_TYPE_PT_ADDBITS14;
8828 kern_type = KERN_TYPE_MD5H;
8829 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8830 parse_func = md5half_parse_hash;
8831 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8832 opti_type = OPTI_TYPE_ZERO_BYTE
8833 | OPTI_TYPE_RAW_HASH;
8834 dgst_pos0 = 0;
8835 dgst_pos1 = 1;
8836 dgst_pos2 = 2;
8837 dgst_pos3 = 3;
8838 break;
8839
8840 case 5200: hash_type = HASH_TYPE_SHA256;
8841 salt_type = SALT_TYPE_EMBEDDED;
8842 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8843 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8844 kern_type = KERN_TYPE_PSAFE3;
8845 dgst_size = DGST_SIZE_4_8;
8846 parse_func = psafe3_parse_hash;
8847 sort_by_digest = sort_by_digest_4_8;
8848 opti_type = OPTI_TYPE_ZERO_BYTE;
8849 dgst_pos0 = 0;
8850 dgst_pos1 = 1;
8851 dgst_pos2 = 2;
8852 dgst_pos3 = 3;
8853 break;
8854
8855 case 5300: hash_type = HASH_TYPE_MD5;
8856 salt_type = SALT_TYPE_EMBEDDED;
8857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8858 opts_type = OPTS_TYPE_PT_GENERATE_LE
8859 | OPTS_TYPE_ST_ADD80;
8860 kern_type = KERN_TYPE_IKEPSK_MD5;
8861 dgst_size = DGST_SIZE_4_4;
8862 parse_func = ikepsk_md5_parse_hash;
8863 sort_by_digest = sort_by_digest_4_4;
8864 opti_type = OPTI_TYPE_ZERO_BYTE;
8865 dgst_pos0 = 0;
8866 dgst_pos1 = 3;
8867 dgst_pos2 = 2;
8868 dgst_pos3 = 1;
8869 break;
8870
8871 case 5400: hash_type = HASH_TYPE_SHA1;
8872 salt_type = SALT_TYPE_EMBEDDED;
8873 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8874 opts_type = OPTS_TYPE_PT_GENERATE_BE
8875 | OPTS_TYPE_ST_ADD80;
8876 kern_type = KERN_TYPE_IKEPSK_SHA1;
8877 dgst_size = DGST_SIZE_4_5;
8878 parse_func = ikepsk_sha1_parse_hash;
8879 sort_by_digest = sort_by_digest_4_5;
8880 opti_type = OPTI_TYPE_ZERO_BYTE;
8881 dgst_pos0 = 3;
8882 dgst_pos1 = 4;
8883 dgst_pos2 = 2;
8884 dgst_pos3 = 1;
8885 break;
8886
8887 case 5500: hash_type = HASH_TYPE_NETNTLM;
8888 salt_type = SALT_TYPE_EMBEDDED;
8889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8890 opts_type = OPTS_TYPE_PT_GENERATE_LE
8891 | OPTS_TYPE_PT_ADD80
8892 | OPTS_TYPE_PT_ADDBITS14
8893 | OPTS_TYPE_PT_UNICODE
8894 | OPTS_TYPE_ST_HEX;
8895 kern_type = KERN_TYPE_NETNTLMv1;
8896 dgst_size = DGST_SIZE_4_4;
8897 parse_func = netntlmv1_parse_hash;
8898 sort_by_digest = sort_by_digest_4_4;
8899 opti_type = OPTI_TYPE_ZERO_BYTE
8900 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8901 dgst_pos0 = 0;
8902 dgst_pos1 = 1;
8903 dgst_pos2 = 2;
8904 dgst_pos3 = 3;
8905 break;
8906
8907 case 5600: hash_type = HASH_TYPE_MD5;
8908 salt_type = SALT_TYPE_EMBEDDED;
8909 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8910 opts_type = OPTS_TYPE_PT_GENERATE_LE
8911 | OPTS_TYPE_PT_ADD80
8912 | OPTS_TYPE_PT_ADDBITS14
8913 | OPTS_TYPE_PT_UNICODE;
8914 kern_type = KERN_TYPE_NETNTLMv2;
8915 dgst_size = DGST_SIZE_4_4;
8916 parse_func = netntlmv2_parse_hash;
8917 sort_by_digest = sort_by_digest_4_4;
8918 opti_type = OPTI_TYPE_ZERO_BYTE;
8919 dgst_pos0 = 0;
8920 dgst_pos1 = 3;
8921 dgst_pos2 = 2;
8922 dgst_pos3 = 1;
8923 break;
8924
8925 case 5700: hash_type = HASH_TYPE_SHA256;
8926 salt_type = SALT_TYPE_NONE;
8927 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8928 opts_type = OPTS_TYPE_PT_GENERATE_BE
8929 | OPTS_TYPE_PT_ADD80
8930 | OPTS_TYPE_PT_ADDBITS15;
8931 kern_type = KERN_TYPE_SHA256;
8932 dgst_size = DGST_SIZE_4_8;
8933 parse_func = cisco4_parse_hash;
8934 sort_by_digest = sort_by_digest_4_8;
8935 opti_type = OPTI_TYPE_ZERO_BYTE
8936 | OPTI_TYPE_PRECOMPUTE_INIT
8937 | OPTI_TYPE_PRECOMPUTE_MERKLE
8938 | OPTI_TYPE_EARLY_SKIP
8939 | OPTI_TYPE_NOT_ITERATED
8940 | OPTI_TYPE_NOT_SALTED
8941 | OPTI_TYPE_RAW_HASH;
8942 dgst_pos0 = 3;
8943 dgst_pos1 = 7;
8944 dgst_pos2 = 2;
8945 dgst_pos3 = 6;
8946 break;
8947
8948 case 5800: hash_type = HASH_TYPE_SHA1;
8949 salt_type = SALT_TYPE_INTERN;
8950 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8951 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8952 | OPTS_TYPE_ST_ADD80;
8953 kern_type = KERN_TYPE_ANDROIDPIN;
8954 dgst_size = DGST_SIZE_4_5;
8955 parse_func = androidpin_parse_hash;
8956 sort_by_digest = sort_by_digest_4_5;
8957 opti_type = OPTI_TYPE_ZERO_BYTE;
8958 dgst_pos0 = 0;
8959 dgst_pos1 = 1;
8960 dgst_pos2 = 2;
8961 dgst_pos3 = 3;
8962 break;
8963
8964 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8965 salt_type = SALT_TYPE_NONE;
8966 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8967 opts_type = OPTS_TYPE_PT_GENERATE_LE
8968 | OPTS_TYPE_PT_ADD80;
8969 kern_type = KERN_TYPE_RIPEMD160;
8970 dgst_size = DGST_SIZE_4_5;
8971 parse_func = ripemd160_parse_hash;
8972 sort_by_digest = sort_by_digest_4_5;
8973 opti_type = OPTI_TYPE_ZERO_BYTE;
8974 dgst_pos0 = 0;
8975 dgst_pos1 = 1;
8976 dgst_pos2 = 2;
8977 dgst_pos3 = 3;
8978 break;
8979
8980 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8981 salt_type = SALT_TYPE_NONE;
8982 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8983 opts_type = OPTS_TYPE_PT_GENERATE_BE
8984 | OPTS_TYPE_PT_ADD80;
8985 kern_type = KERN_TYPE_WHIRLPOOL;
8986 dgst_size = DGST_SIZE_4_16;
8987 parse_func = whirlpool_parse_hash;
8988 sort_by_digest = sort_by_digest_4_16;
8989 opti_type = OPTI_TYPE_ZERO_BYTE;
8990 dgst_pos0 = 0;
8991 dgst_pos1 = 1;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 3;
8994 break;
8995
8996 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8997 salt_type = SALT_TYPE_EMBEDDED;
8998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9000 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9001 dgst_size = DGST_SIZE_4_5;
9002 parse_func = truecrypt_parse_hash_2k;
9003 sort_by_digest = sort_by_digest_4_5;
9004 opti_type = OPTI_TYPE_ZERO_BYTE;
9005 dgst_pos0 = 0;
9006 dgst_pos1 = 1;
9007 dgst_pos2 = 2;
9008 dgst_pos3 = 3;
9009 break;
9010
9011 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9012 salt_type = SALT_TYPE_EMBEDDED;
9013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9014 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9015 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9016 dgst_size = DGST_SIZE_4_5;
9017 parse_func = truecrypt_parse_hash_2k;
9018 sort_by_digest = sort_by_digest_4_5;
9019 opti_type = OPTI_TYPE_ZERO_BYTE;
9020 dgst_pos0 = 0;
9021 dgst_pos1 = 1;
9022 dgst_pos2 = 2;
9023 dgst_pos3 = 3;
9024 break;
9025
9026 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9027 salt_type = SALT_TYPE_EMBEDDED;
9028 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9029 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9030 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9031 dgst_size = DGST_SIZE_4_5;
9032 parse_func = truecrypt_parse_hash_2k;
9033 sort_by_digest = sort_by_digest_4_5;
9034 opti_type = OPTI_TYPE_ZERO_BYTE;
9035 dgst_pos0 = 0;
9036 dgst_pos1 = 1;
9037 dgst_pos2 = 2;
9038 dgst_pos3 = 3;
9039 break;
9040
9041 case 6221: hash_type = HASH_TYPE_SHA512;
9042 salt_type = SALT_TYPE_EMBEDDED;
9043 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9044 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9045 kern_type = KERN_TYPE_TCSHA512_XTS512;
9046 dgst_size = DGST_SIZE_8_8;
9047 parse_func = truecrypt_parse_hash_1k;
9048 sort_by_digest = sort_by_digest_8_8;
9049 opti_type = OPTI_TYPE_ZERO_BYTE
9050 | OPTI_TYPE_USES_BITS_64;
9051 dgst_pos0 = 0;
9052 dgst_pos1 = 1;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 3;
9055 break;
9056
9057 case 6222: hash_type = HASH_TYPE_SHA512;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9061 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9062 dgst_size = DGST_SIZE_8_8;
9063 parse_func = truecrypt_parse_hash_1k;
9064 sort_by_digest = sort_by_digest_8_8;
9065 opti_type = OPTI_TYPE_ZERO_BYTE
9066 | OPTI_TYPE_USES_BITS_64;
9067 dgst_pos0 = 0;
9068 dgst_pos1 = 1;
9069 dgst_pos2 = 2;
9070 dgst_pos3 = 3;
9071 break;
9072
9073 case 6223: hash_type = HASH_TYPE_SHA512;
9074 salt_type = SALT_TYPE_EMBEDDED;
9075 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9076 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9077 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9078 dgst_size = DGST_SIZE_8_8;
9079 parse_func = truecrypt_parse_hash_1k;
9080 sort_by_digest = sort_by_digest_8_8;
9081 opti_type = OPTI_TYPE_ZERO_BYTE
9082 | OPTI_TYPE_USES_BITS_64;
9083 dgst_pos0 = 0;
9084 dgst_pos1 = 1;
9085 dgst_pos2 = 2;
9086 dgst_pos3 = 3;
9087 break;
9088
9089 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9090 salt_type = SALT_TYPE_EMBEDDED;
9091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9092 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9093 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9094 dgst_size = DGST_SIZE_4_8;
9095 parse_func = truecrypt_parse_hash_1k;
9096 sort_by_digest = sort_by_digest_4_8;
9097 opti_type = OPTI_TYPE_ZERO_BYTE;
9098 dgst_pos0 = 0;
9099 dgst_pos1 = 1;
9100 dgst_pos2 = 2;
9101 dgst_pos3 = 3;
9102 break;
9103
9104 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9105 salt_type = SALT_TYPE_EMBEDDED;
9106 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9107 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9108 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9109 dgst_size = DGST_SIZE_4_8;
9110 parse_func = truecrypt_parse_hash_1k;
9111 sort_by_digest = sort_by_digest_4_8;
9112 opti_type = OPTI_TYPE_ZERO_BYTE;
9113 dgst_pos0 = 0;
9114 dgst_pos1 = 1;
9115 dgst_pos2 = 2;
9116 dgst_pos3 = 3;
9117 break;
9118
9119 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9120 salt_type = SALT_TYPE_EMBEDDED;
9121 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9122 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9123 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9124 dgst_size = DGST_SIZE_4_8;
9125 parse_func = truecrypt_parse_hash_1k;
9126 sort_by_digest = sort_by_digest_4_8;
9127 opti_type = OPTI_TYPE_ZERO_BYTE;
9128 dgst_pos0 = 0;
9129 dgst_pos1 = 1;
9130 dgst_pos2 = 2;
9131 dgst_pos3 = 3;
9132 break;
9133
9134 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9135 salt_type = SALT_TYPE_EMBEDDED;
9136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9137 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9138 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9139 dgst_size = DGST_SIZE_4_5;
9140 parse_func = truecrypt_parse_hash_1k;
9141 sort_by_digest = sort_by_digest_4_5;
9142 opti_type = OPTI_TYPE_ZERO_BYTE;
9143 dgst_pos0 = 0;
9144 dgst_pos1 = 1;
9145 dgst_pos2 = 2;
9146 dgst_pos3 = 3;
9147 break;
9148
9149 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9150 salt_type = SALT_TYPE_EMBEDDED;
9151 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9152 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9153 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9154 dgst_size = DGST_SIZE_4_5;
9155 parse_func = truecrypt_parse_hash_1k;
9156 sort_by_digest = sort_by_digest_4_5;
9157 opti_type = OPTI_TYPE_ZERO_BYTE;
9158 dgst_pos0 = 0;
9159 dgst_pos1 = 1;
9160 dgst_pos2 = 2;
9161 dgst_pos3 = 3;
9162 break;
9163
9164 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9165 salt_type = SALT_TYPE_EMBEDDED;
9166 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9167 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9168 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9169 dgst_size = DGST_SIZE_4_5;
9170 parse_func = truecrypt_parse_hash_1k;
9171 sort_by_digest = sort_by_digest_4_5;
9172 opti_type = OPTI_TYPE_ZERO_BYTE;
9173 dgst_pos0 = 0;
9174 dgst_pos1 = 1;
9175 dgst_pos2 = 2;
9176 dgst_pos3 = 3;
9177 break;
9178
9179 case 6300: hash_type = HASH_TYPE_MD5;
9180 salt_type = SALT_TYPE_EMBEDDED;
9181 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9182 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9183 kern_type = KERN_TYPE_MD5AIX;
9184 dgst_size = DGST_SIZE_4_4;
9185 parse_func = md5aix_parse_hash;
9186 sort_by_digest = sort_by_digest_4_4;
9187 opti_type = OPTI_TYPE_ZERO_BYTE;
9188 dgst_pos0 = 0;
9189 dgst_pos1 = 1;
9190 dgst_pos2 = 2;
9191 dgst_pos3 = 3;
9192 break;
9193
9194 case 6400: hash_type = HASH_TYPE_SHA256;
9195 salt_type = SALT_TYPE_EMBEDDED;
9196 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9197 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9198 kern_type = KERN_TYPE_SHA256AIX;
9199 dgst_size = DGST_SIZE_4_8;
9200 parse_func = sha256aix_parse_hash;
9201 sort_by_digest = sort_by_digest_4_8;
9202 opti_type = OPTI_TYPE_ZERO_BYTE;
9203 dgst_pos0 = 0;
9204 dgst_pos1 = 1;
9205 dgst_pos2 = 2;
9206 dgst_pos3 = 3;
9207 break;
9208
9209 case 6500: hash_type = HASH_TYPE_SHA512;
9210 salt_type = SALT_TYPE_EMBEDDED;
9211 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9212 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9213 kern_type = KERN_TYPE_SHA512AIX;
9214 dgst_size = DGST_SIZE_8_8;
9215 parse_func = sha512aix_parse_hash;
9216 sort_by_digest = sort_by_digest_8_8;
9217 opti_type = OPTI_TYPE_ZERO_BYTE
9218 | OPTI_TYPE_USES_BITS_64;
9219 dgst_pos0 = 0;
9220 dgst_pos1 = 1;
9221 dgst_pos2 = 2;
9222 dgst_pos3 = 3;
9223 break;
9224
9225 case 6600: hash_type = HASH_TYPE_AES;
9226 salt_type = SALT_TYPE_EMBEDDED;
9227 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9228 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9229 kern_type = KERN_TYPE_AGILEKEY;
9230 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9231 parse_func = agilekey_parse_hash;
9232 sort_by_digest = sort_by_digest_4_5;
9233 opti_type = OPTI_TYPE_ZERO_BYTE;
9234 dgst_pos0 = 0;
9235 dgst_pos1 = 1;
9236 dgst_pos2 = 2;
9237 dgst_pos3 = 3;
9238 break;
9239
9240 case 6700: hash_type = HASH_TYPE_SHA1;
9241 salt_type = SALT_TYPE_EMBEDDED;
9242 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9243 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9244 kern_type = KERN_TYPE_SHA1AIX;
9245 dgst_size = DGST_SIZE_4_5;
9246 parse_func = sha1aix_parse_hash;
9247 sort_by_digest = sort_by_digest_4_5;
9248 opti_type = OPTI_TYPE_ZERO_BYTE;
9249 dgst_pos0 = 0;
9250 dgst_pos1 = 1;
9251 dgst_pos2 = 2;
9252 dgst_pos3 = 3;
9253 break;
9254
9255 case 6800: hash_type = HASH_TYPE_AES;
9256 salt_type = SALT_TYPE_EMBEDDED;
9257 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9258 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9259 kern_type = KERN_TYPE_LASTPASS;
9260 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9261 parse_func = lastpass_parse_hash;
9262 sort_by_digest = sort_by_digest_4_8;
9263 opti_type = OPTI_TYPE_ZERO_BYTE;
9264 dgst_pos0 = 0;
9265 dgst_pos1 = 1;
9266 dgst_pos2 = 2;
9267 dgst_pos3 = 3;
9268 break;
9269
9270 case 6900: hash_type = HASH_TYPE_GOST;
9271 salt_type = SALT_TYPE_NONE;
9272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9273 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9274 kern_type = KERN_TYPE_GOST;
9275 dgst_size = DGST_SIZE_4_8;
9276 parse_func = gost_parse_hash;
9277 sort_by_digest = sort_by_digest_4_8;
9278 opti_type = OPTI_TYPE_ZERO_BYTE;
9279 dgst_pos0 = 0;
9280 dgst_pos1 = 1;
9281 dgst_pos2 = 2;
9282 dgst_pos3 = 3;
9283 break;
9284
9285 case 7100: hash_type = HASH_TYPE_SHA512;
9286 salt_type = SALT_TYPE_EMBEDDED;
9287 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9288 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9289 kern_type = KERN_TYPE_PBKDF2_SHA512;
9290 dgst_size = DGST_SIZE_8_16;
9291 parse_func = sha512osx_parse_hash;
9292 sort_by_digest = sort_by_digest_8_16;
9293 opti_type = OPTI_TYPE_ZERO_BYTE
9294 | OPTI_TYPE_USES_BITS_64
9295 | OPTI_TYPE_SLOW_HASH_SIMD;
9296 dgst_pos0 = 0;
9297 dgst_pos1 = 1;
9298 dgst_pos2 = 2;
9299 dgst_pos3 = 3;
9300 break;
9301
9302 case 7200: hash_type = HASH_TYPE_SHA512;
9303 salt_type = SALT_TYPE_EMBEDDED;
9304 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9305 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9306 kern_type = KERN_TYPE_PBKDF2_SHA512;
9307 dgst_size = DGST_SIZE_8_16;
9308 parse_func = sha512grub_parse_hash;
9309 sort_by_digest = sort_by_digest_8_16;
9310 opti_type = OPTI_TYPE_ZERO_BYTE
9311 | OPTI_TYPE_USES_BITS_64
9312 | OPTI_TYPE_SLOW_HASH_SIMD;
9313 dgst_pos0 = 0;
9314 dgst_pos1 = 1;
9315 dgst_pos2 = 2;
9316 dgst_pos3 = 3;
9317 break;
9318
9319 case 7300: hash_type = HASH_TYPE_SHA1;
9320 salt_type = SALT_TYPE_EMBEDDED;
9321 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9322 opts_type = OPTS_TYPE_PT_GENERATE_BE
9323 | OPTS_TYPE_ST_ADD80
9324 | OPTS_TYPE_ST_ADDBITS15;
9325 kern_type = KERN_TYPE_RAKP;
9326 dgst_size = DGST_SIZE_4_5;
9327 parse_func = rakp_parse_hash;
9328 sort_by_digest = sort_by_digest_4_5;
9329 opti_type = OPTI_TYPE_ZERO_BYTE
9330 | OPTI_TYPE_NOT_ITERATED;
9331 dgst_pos0 = 3;
9332 dgst_pos1 = 4;
9333 dgst_pos2 = 2;
9334 dgst_pos3 = 1;
9335 break;
9336
9337 case 7400: hash_type = HASH_TYPE_SHA256;
9338 salt_type = SALT_TYPE_EMBEDDED;
9339 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9340 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9341 kern_type = KERN_TYPE_SHA256CRYPT;
9342 dgst_size = DGST_SIZE_4_8;
9343 parse_func = sha256crypt_parse_hash;
9344 sort_by_digest = sort_by_digest_4_8;
9345 opti_type = OPTI_TYPE_ZERO_BYTE;
9346 dgst_pos0 = 0;
9347 dgst_pos1 = 1;
9348 dgst_pos2 = 2;
9349 dgst_pos3 = 3;
9350 break;
9351
9352 case 7500: hash_type = HASH_TYPE_KRB5PA;
9353 salt_type = SALT_TYPE_EMBEDDED;
9354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9355 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9356 kern_type = KERN_TYPE_KRB5PA;
9357 dgst_size = DGST_SIZE_4_4;
9358 parse_func = krb5pa_parse_hash;
9359 sort_by_digest = sort_by_digest_4_4;
9360 opti_type = OPTI_TYPE_ZERO_BYTE
9361 | OPTI_TYPE_NOT_ITERATED;
9362 dgst_pos0 = 0;
9363 dgst_pos1 = 1;
9364 dgst_pos2 = 2;
9365 dgst_pos3 = 3;
9366 break;
9367
9368 case 7600: hash_type = HASH_TYPE_SHA1;
9369 salt_type = SALT_TYPE_INTERN;
9370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9371 opts_type = OPTS_TYPE_PT_GENERATE_BE
9372 | OPTS_TYPE_PT_ADD80
9373 | OPTS_TYPE_PT_ADDBITS15;
9374 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9375 dgst_size = DGST_SIZE_4_5;
9376 parse_func = redmine_parse_hash;
9377 sort_by_digest = sort_by_digest_4_5;
9378 opti_type = OPTI_TYPE_ZERO_BYTE
9379 | OPTI_TYPE_PRECOMPUTE_INIT
9380 | OPTI_TYPE_EARLY_SKIP
9381 | OPTI_TYPE_NOT_ITERATED
9382 | OPTI_TYPE_PREPENDED_SALT;
9383 dgst_pos0 = 3;
9384 dgst_pos1 = 4;
9385 dgst_pos2 = 2;
9386 dgst_pos3 = 1;
9387 break;
9388
9389 case 7700: hash_type = HASH_TYPE_SAPB;
9390 salt_type = SALT_TYPE_EMBEDDED;
9391 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9392 opts_type = OPTS_TYPE_PT_GENERATE_LE
9393 | OPTS_TYPE_PT_UPPER
9394 | OPTS_TYPE_ST_UPPER;
9395 kern_type = KERN_TYPE_SAPB;
9396 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9397 parse_func = sapb_parse_hash;
9398 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9399 opti_type = OPTI_TYPE_ZERO_BYTE
9400 | OPTI_TYPE_PRECOMPUTE_INIT
9401 | OPTI_TYPE_NOT_ITERATED;
9402 dgst_pos0 = 0;
9403 dgst_pos1 = 1;
9404 dgst_pos2 = 2;
9405 dgst_pos3 = 3;
9406 break;
9407
9408 case 7800: hash_type = HASH_TYPE_SAPG;
9409 salt_type = SALT_TYPE_EMBEDDED;
9410 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9411 opts_type = OPTS_TYPE_PT_GENERATE_BE
9412 | OPTS_TYPE_ST_ADD80
9413 | OPTS_TYPE_ST_UPPER;
9414 kern_type = KERN_TYPE_SAPG;
9415 dgst_size = DGST_SIZE_4_5;
9416 parse_func = sapg_parse_hash;
9417 sort_by_digest = sort_by_digest_4_5;
9418 opti_type = OPTI_TYPE_ZERO_BYTE
9419 | OPTI_TYPE_PRECOMPUTE_INIT
9420 | OPTI_TYPE_NOT_ITERATED;
9421 dgst_pos0 = 3;
9422 dgst_pos1 = 4;
9423 dgst_pos2 = 2;
9424 dgst_pos3 = 1;
9425 break;
9426
9427 case 7900: hash_type = HASH_TYPE_SHA512;
9428 salt_type = SALT_TYPE_EMBEDDED;
9429 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9430 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9431 kern_type = KERN_TYPE_DRUPAL7;
9432 dgst_size = DGST_SIZE_8_8;
9433 parse_func = drupal7_parse_hash;
9434 sort_by_digest = sort_by_digest_8_8;
9435 opti_type = OPTI_TYPE_ZERO_BYTE
9436 | OPTI_TYPE_USES_BITS_64;
9437 dgst_pos0 = 0;
9438 dgst_pos1 = 1;
9439 dgst_pos2 = 2;
9440 dgst_pos3 = 3;
9441 break;
9442
9443 case 8000: hash_type = HASH_TYPE_SHA256;
9444 salt_type = SALT_TYPE_EMBEDDED;
9445 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9446 opts_type = OPTS_TYPE_PT_GENERATE_BE
9447 | OPTS_TYPE_PT_UNICODE
9448 | OPTS_TYPE_ST_ADD80
9449 | OPTS_TYPE_ST_HEX;
9450 kern_type = KERN_TYPE_SYBASEASE;
9451 dgst_size = DGST_SIZE_4_8;
9452 parse_func = sybasease_parse_hash;
9453 sort_by_digest = sort_by_digest_4_8;
9454 opti_type = OPTI_TYPE_ZERO_BYTE
9455 | OPTI_TYPE_PRECOMPUTE_INIT
9456 | OPTI_TYPE_EARLY_SKIP
9457 | OPTI_TYPE_NOT_ITERATED
9458 | OPTI_TYPE_RAW_HASH;
9459 dgst_pos0 = 3;
9460 dgst_pos1 = 7;
9461 dgst_pos2 = 2;
9462 dgst_pos3 = 6;
9463 break;
9464
9465 case 8100: hash_type = HASH_TYPE_SHA1;
9466 salt_type = SALT_TYPE_EMBEDDED;
9467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9468 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9469 kern_type = KERN_TYPE_NETSCALER;
9470 dgst_size = DGST_SIZE_4_5;
9471 parse_func = netscaler_parse_hash;
9472 sort_by_digest = sort_by_digest_4_5;
9473 opti_type = OPTI_TYPE_ZERO_BYTE
9474 | OPTI_TYPE_PRECOMPUTE_INIT
9475 | OPTI_TYPE_PRECOMPUTE_MERKLE
9476 | OPTI_TYPE_EARLY_SKIP
9477 | OPTI_TYPE_NOT_ITERATED
9478 | OPTI_TYPE_PREPENDED_SALT
9479 | OPTI_TYPE_RAW_HASH;
9480 dgst_pos0 = 3;
9481 dgst_pos1 = 4;
9482 dgst_pos2 = 2;
9483 dgst_pos3 = 1;
9484 break;
9485
9486 case 8200: hash_type = HASH_TYPE_SHA256;
9487 salt_type = SALT_TYPE_EMBEDDED;
9488 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9489 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9490 kern_type = KERN_TYPE_CLOUDKEY;
9491 dgst_size = DGST_SIZE_4_8;
9492 parse_func = cloudkey_parse_hash;
9493 sort_by_digest = sort_by_digest_4_8;
9494 opti_type = OPTI_TYPE_ZERO_BYTE;
9495 dgst_pos0 = 0;
9496 dgst_pos1 = 1;
9497 dgst_pos2 = 2;
9498 dgst_pos3 = 3;
9499 break;
9500
9501 case 8300: hash_type = HASH_TYPE_SHA1;
9502 salt_type = SALT_TYPE_EMBEDDED;
9503 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9504 opts_type = OPTS_TYPE_PT_GENERATE_BE
9505 | OPTS_TYPE_ST_HEX
9506 | OPTS_TYPE_ST_ADD80;
9507 kern_type = KERN_TYPE_NSEC3;
9508 dgst_size = DGST_SIZE_4_5;
9509 parse_func = nsec3_parse_hash;
9510 sort_by_digest = sort_by_digest_4_5;
9511 opti_type = OPTI_TYPE_ZERO_BYTE;
9512 dgst_pos0 = 3;
9513 dgst_pos1 = 4;
9514 dgst_pos2 = 2;
9515 dgst_pos3 = 1;
9516 break;
9517
9518 case 8400: hash_type = HASH_TYPE_SHA1;
9519 salt_type = SALT_TYPE_INTERN;
9520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9521 opts_type = OPTS_TYPE_PT_GENERATE_BE
9522 | OPTS_TYPE_PT_ADD80
9523 | OPTS_TYPE_PT_ADDBITS15;
9524 kern_type = KERN_TYPE_WBB3;
9525 dgst_size = DGST_SIZE_4_5;
9526 parse_func = wbb3_parse_hash;
9527 sort_by_digest = sort_by_digest_4_5;
9528 opti_type = OPTI_TYPE_ZERO_BYTE
9529 | OPTI_TYPE_PRECOMPUTE_INIT
9530 | OPTI_TYPE_NOT_ITERATED;
9531 dgst_pos0 = 3;
9532 dgst_pos1 = 4;
9533 dgst_pos2 = 2;
9534 dgst_pos3 = 1;
9535 break;
9536
9537 case 8500: hash_type = HASH_TYPE_DESRACF;
9538 salt_type = SALT_TYPE_EMBEDDED;
9539 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9540 opts_type = OPTS_TYPE_PT_GENERATE_LE
9541 | OPTS_TYPE_ST_UPPER;
9542 kern_type = KERN_TYPE_RACF;
9543 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9544 parse_func = racf_parse_hash;
9545 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9546 opti_type = OPTI_TYPE_ZERO_BYTE
9547 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9548 dgst_pos0 = 0;
9549 dgst_pos1 = 1;
9550 dgst_pos2 = 2;
9551 dgst_pos3 = 3;
9552 break;
9553
9554 case 8600: hash_type = HASH_TYPE_LOTUS5;
9555 salt_type = SALT_TYPE_NONE;
9556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9557 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9558 kern_type = KERN_TYPE_LOTUS5;
9559 dgst_size = DGST_SIZE_4_4;
9560 parse_func = lotus5_parse_hash;
9561 sort_by_digest = sort_by_digest_4_4;
9562 opti_type = OPTI_TYPE_EARLY_SKIP
9563 | OPTI_TYPE_NOT_ITERATED
9564 | OPTI_TYPE_NOT_SALTED
9565 | OPTI_TYPE_RAW_HASH;
9566 dgst_pos0 = 0;
9567 dgst_pos1 = 1;
9568 dgst_pos2 = 2;
9569 dgst_pos3 = 3;
9570 break;
9571
9572 case 8700: hash_type = HASH_TYPE_LOTUS6;
9573 salt_type = SALT_TYPE_EMBEDDED;
9574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9575 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9576 kern_type = KERN_TYPE_LOTUS6;
9577 dgst_size = DGST_SIZE_4_4;
9578 parse_func = lotus6_parse_hash;
9579 sort_by_digest = sort_by_digest_4_4;
9580 opti_type = OPTI_TYPE_EARLY_SKIP
9581 | OPTI_TYPE_NOT_ITERATED
9582 | OPTI_TYPE_RAW_HASH;
9583 dgst_pos0 = 0;
9584 dgst_pos1 = 1;
9585 dgst_pos2 = 2;
9586 dgst_pos3 = 3;
9587 break;
9588
9589 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9590 salt_type = SALT_TYPE_EMBEDDED;
9591 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9592 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9593 kern_type = KERN_TYPE_ANDROIDFDE;
9594 dgst_size = DGST_SIZE_4_4;
9595 parse_func = androidfde_parse_hash;
9596 sort_by_digest = sort_by_digest_4_4;
9597 opti_type = OPTI_TYPE_ZERO_BYTE;
9598 dgst_pos0 = 0;
9599 dgst_pos1 = 1;
9600 dgst_pos2 = 2;
9601 dgst_pos3 = 3;
9602 break;
9603
9604 case 8900: hash_type = HASH_TYPE_SCRYPT;
9605 salt_type = SALT_TYPE_EMBEDDED;
9606 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9607 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9608 kern_type = KERN_TYPE_SCRYPT;
9609 dgst_size = DGST_SIZE_4_8;
9610 parse_func = scrypt_parse_hash;
9611 sort_by_digest = sort_by_digest_4_8;
9612 opti_type = OPTI_TYPE_ZERO_BYTE;
9613 dgst_pos0 = 0;
9614 dgst_pos1 = 1;
9615 dgst_pos2 = 2;
9616 dgst_pos3 = 3;
9617 break;
9618
9619 case 9000: hash_type = HASH_TYPE_SHA1;
9620 salt_type = SALT_TYPE_EMBEDDED;
9621 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9622 opts_type = OPTS_TYPE_PT_GENERATE_LE
9623 | OPTS_TYPE_ST_GENERATE_LE;
9624 kern_type = KERN_TYPE_PSAFE2;
9625 dgst_size = DGST_SIZE_4_5;
9626 parse_func = psafe2_parse_hash;
9627 sort_by_digest = sort_by_digest_4_5;
9628 opti_type = OPTI_TYPE_ZERO_BYTE;
9629 dgst_pos0 = 0;
9630 dgst_pos1 = 1;
9631 dgst_pos2 = 2;
9632 dgst_pos3 = 3;
9633 break;
9634
9635 case 9100: hash_type = HASH_TYPE_LOTUS8;
9636 salt_type = SALT_TYPE_EMBEDDED;
9637 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9638 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9639 kern_type = KERN_TYPE_LOTUS8;
9640 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9641 parse_func = lotus8_parse_hash;
9642 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9643 opti_type = OPTI_TYPE_ZERO_BYTE;
9644 dgst_pos0 = 0;
9645 dgst_pos1 = 1;
9646 dgst_pos2 = 2;
9647 dgst_pos3 = 3;
9648 break;
9649
9650 case 9200: hash_type = HASH_TYPE_SHA256;
9651 salt_type = SALT_TYPE_EMBEDDED;
9652 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9653 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9654 kern_type = KERN_TYPE_PBKDF2_SHA256;
9655 dgst_size = DGST_SIZE_4_32;
9656 parse_func = cisco8_parse_hash;
9657 sort_by_digest = sort_by_digest_4_32;
9658 opti_type = OPTI_TYPE_ZERO_BYTE
9659 | OPTI_TYPE_SLOW_HASH_SIMD;
9660 dgst_pos0 = 0;
9661 dgst_pos1 = 1;
9662 dgst_pos2 = 2;
9663 dgst_pos3 = 3;
9664 break;
9665
9666 case 9300: hash_type = HASH_TYPE_SCRYPT;
9667 salt_type = SALT_TYPE_EMBEDDED;
9668 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9669 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9670 kern_type = KERN_TYPE_SCRYPT;
9671 dgst_size = DGST_SIZE_4_8;
9672 parse_func = cisco9_parse_hash;
9673 sort_by_digest = sort_by_digest_4_8;
9674 opti_type = OPTI_TYPE_ZERO_BYTE;
9675 dgst_pos0 = 0;
9676 dgst_pos1 = 1;
9677 dgst_pos2 = 2;
9678 dgst_pos3 = 3;
9679 break;
9680
9681 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9682 salt_type = SALT_TYPE_EMBEDDED;
9683 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9684 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9685 kern_type = KERN_TYPE_OFFICE2007;
9686 dgst_size = DGST_SIZE_4_4;
9687 parse_func = office2007_parse_hash;
9688 sort_by_digest = sort_by_digest_4_4;
9689 opti_type = OPTI_TYPE_ZERO_BYTE;
9690 dgst_pos0 = 0;
9691 dgst_pos1 = 1;
9692 dgst_pos2 = 2;
9693 dgst_pos3 = 3;
9694 break;
9695
9696 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9697 salt_type = SALT_TYPE_EMBEDDED;
9698 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9699 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9700 kern_type = KERN_TYPE_OFFICE2010;
9701 dgst_size = DGST_SIZE_4_4;
9702 parse_func = office2010_parse_hash;
9703 sort_by_digest = sort_by_digest_4_4;
9704 opti_type = OPTI_TYPE_ZERO_BYTE;
9705 dgst_pos0 = 0;
9706 dgst_pos1 = 1;
9707 dgst_pos2 = 2;
9708 dgst_pos3 = 3;
9709 break;
9710
9711 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9712 salt_type = SALT_TYPE_EMBEDDED;
9713 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9714 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9715 kern_type = KERN_TYPE_OFFICE2013;
9716 dgst_size = DGST_SIZE_4_4;
9717 parse_func = office2013_parse_hash;
9718 sort_by_digest = sort_by_digest_4_4;
9719 opti_type = OPTI_TYPE_ZERO_BYTE;
9720 dgst_pos0 = 0;
9721 dgst_pos1 = 1;
9722 dgst_pos2 = 2;
9723 dgst_pos3 = 3;
9724 break;
9725
9726 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9727 salt_type = SALT_TYPE_EMBEDDED;
9728 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9729 opts_type = OPTS_TYPE_PT_GENERATE_LE
9730 | OPTS_TYPE_PT_ADD80
9731 | OPTS_TYPE_PT_UNICODE;
9732 kern_type = KERN_TYPE_OLDOFFICE01;
9733 dgst_size = DGST_SIZE_4_4;
9734 parse_func = oldoffice01_parse_hash;
9735 sort_by_digest = sort_by_digest_4_4;
9736 opti_type = OPTI_TYPE_ZERO_BYTE
9737 | OPTI_TYPE_PRECOMPUTE_INIT
9738 | OPTI_TYPE_NOT_ITERATED;
9739 dgst_pos0 = 0;
9740 dgst_pos1 = 1;
9741 dgst_pos2 = 2;
9742 dgst_pos3 = 3;
9743 break;
9744
9745 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9746 salt_type = SALT_TYPE_EMBEDDED;
9747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9748 opts_type = OPTS_TYPE_PT_GENERATE_LE
9749 | OPTS_TYPE_PT_ADD80;
9750 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9751 dgst_size = DGST_SIZE_4_4;
9752 parse_func = oldoffice01cm1_parse_hash;
9753 sort_by_digest = sort_by_digest_4_4;
9754 opti_type = OPTI_TYPE_ZERO_BYTE
9755 | OPTI_TYPE_PRECOMPUTE_INIT
9756 | OPTI_TYPE_NOT_ITERATED;
9757 dgst_pos0 = 0;
9758 dgst_pos1 = 1;
9759 dgst_pos2 = 2;
9760 dgst_pos3 = 3;
9761 break;
9762
9763 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9764 salt_type = SALT_TYPE_EMBEDDED;
9765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9766 opts_type = OPTS_TYPE_PT_GENERATE_LE
9767 | OPTS_TYPE_PT_ADD80
9768 | OPTS_TYPE_PT_UNICODE
9769 | OPTS_TYPE_PT_NEVERCRACK;
9770 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9771 dgst_size = DGST_SIZE_4_4;
9772 parse_func = oldoffice01cm2_parse_hash;
9773 sort_by_digest = sort_by_digest_4_4;
9774 opti_type = OPTI_TYPE_ZERO_BYTE
9775 | OPTI_TYPE_PRECOMPUTE_INIT
9776 | OPTI_TYPE_NOT_ITERATED;
9777 dgst_pos0 = 0;
9778 dgst_pos1 = 1;
9779 dgst_pos2 = 2;
9780 dgst_pos3 = 3;
9781 break;
9782
9783 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9784 salt_type = SALT_TYPE_EMBEDDED;
9785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9786 opts_type = OPTS_TYPE_PT_GENERATE_BE
9787 | OPTS_TYPE_PT_ADD80
9788 | OPTS_TYPE_PT_UNICODE;
9789 kern_type = KERN_TYPE_OLDOFFICE34;
9790 dgst_size = DGST_SIZE_4_4;
9791 parse_func = oldoffice34_parse_hash;
9792 sort_by_digest = sort_by_digest_4_4;
9793 opti_type = OPTI_TYPE_ZERO_BYTE
9794 | OPTI_TYPE_PRECOMPUTE_INIT
9795 | OPTI_TYPE_NOT_ITERATED;
9796 dgst_pos0 = 0;
9797 dgst_pos1 = 1;
9798 dgst_pos2 = 2;
9799 dgst_pos3 = 3;
9800 break;
9801
9802 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9803 salt_type = SALT_TYPE_EMBEDDED;
9804 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9805 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9806 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9807 dgst_size = DGST_SIZE_4_4;
9808 parse_func = oldoffice34cm1_parse_hash;
9809 sort_by_digest = sort_by_digest_4_4;
9810 opti_type = OPTI_TYPE_ZERO_BYTE
9811 | OPTI_TYPE_PRECOMPUTE_INIT
9812 | OPTI_TYPE_NOT_ITERATED;
9813 dgst_pos0 = 0;
9814 dgst_pos1 = 1;
9815 dgst_pos2 = 2;
9816 dgst_pos3 = 3;
9817 break;
9818
9819 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9820 salt_type = SALT_TYPE_EMBEDDED;
9821 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9822 opts_type = OPTS_TYPE_PT_GENERATE_BE
9823 | OPTS_TYPE_PT_ADD80
9824 | OPTS_TYPE_PT_UNICODE
9825 | OPTS_TYPE_PT_NEVERCRACK;
9826 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9827 dgst_size = DGST_SIZE_4_4;
9828 parse_func = oldoffice34cm2_parse_hash;
9829 sort_by_digest = sort_by_digest_4_4;
9830 opti_type = OPTI_TYPE_ZERO_BYTE
9831 | OPTI_TYPE_PRECOMPUTE_INIT
9832 | OPTI_TYPE_NOT_ITERATED;
9833 dgst_pos0 = 0;
9834 dgst_pos1 = 1;
9835 dgst_pos2 = 2;
9836 dgst_pos3 = 3;
9837 break;
9838
9839 case 9900: hash_type = HASH_TYPE_MD5;
9840 salt_type = SALT_TYPE_NONE;
9841 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9842 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9843 kern_type = KERN_TYPE_RADMIN2;
9844 dgst_size = DGST_SIZE_4_4;
9845 parse_func = radmin2_parse_hash;
9846 sort_by_digest = sort_by_digest_4_4;
9847 opti_type = OPTI_TYPE_ZERO_BYTE
9848 | OPTI_TYPE_PRECOMPUTE_INIT
9849 | OPTI_TYPE_EARLY_SKIP
9850 | OPTI_TYPE_NOT_ITERATED
9851 | OPTI_TYPE_NOT_SALTED;
9852 dgst_pos0 = 0;
9853 dgst_pos1 = 3;
9854 dgst_pos2 = 2;
9855 dgst_pos3 = 1;
9856 break;
9857
9858 case 10000: hash_type = HASH_TYPE_SHA256;
9859 salt_type = SALT_TYPE_EMBEDDED;
9860 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9861 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9862 kern_type = KERN_TYPE_PBKDF2_SHA256;
9863 dgst_size = DGST_SIZE_4_32;
9864 parse_func = djangopbkdf2_parse_hash;
9865 sort_by_digest = sort_by_digest_4_32;
9866 opti_type = OPTI_TYPE_ZERO_BYTE
9867 | OPTI_TYPE_SLOW_HASH_SIMD;
9868 dgst_pos0 = 0;
9869 dgst_pos1 = 1;
9870 dgst_pos2 = 2;
9871 dgst_pos3 = 3;
9872 break;
9873
9874 case 10100: hash_type = HASH_TYPE_SIPHASH;
9875 salt_type = SALT_TYPE_EMBEDDED;
9876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9877 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9878 kern_type = KERN_TYPE_SIPHASH;
9879 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9880 parse_func = siphash_parse_hash;
9881 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9882 opti_type = OPTI_TYPE_ZERO_BYTE
9883 | OPTI_TYPE_NOT_ITERATED
9884 | OPTI_TYPE_RAW_HASH;
9885 dgst_pos0 = 0;
9886 dgst_pos1 = 1;
9887 dgst_pos2 = 2;
9888 dgst_pos3 = 3;
9889 break;
9890
9891 case 10200: hash_type = HASH_TYPE_MD5;
9892 salt_type = SALT_TYPE_EMBEDDED;
9893 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9894 opts_type = OPTS_TYPE_PT_GENERATE_LE
9895 | OPTS_TYPE_ST_ADD80
9896 | OPTS_TYPE_ST_ADDBITS14;
9897 kern_type = KERN_TYPE_HMACMD5_PW;
9898 dgst_size = DGST_SIZE_4_4;
9899 parse_func = crammd5_parse_hash;
9900 sort_by_digest = sort_by_digest_4_4;
9901 opti_type = OPTI_TYPE_ZERO_BYTE
9902 | OPTI_TYPE_NOT_ITERATED;
9903 dgst_pos0 = 0;
9904 dgst_pos1 = 3;
9905 dgst_pos2 = 2;
9906 dgst_pos3 = 1;
9907 break;
9908
9909 case 10300: hash_type = HASH_TYPE_SHA1;
9910 salt_type = SALT_TYPE_EMBEDDED;
9911 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9912 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9913 kern_type = KERN_TYPE_SAPH_SHA1;
9914 dgst_size = DGST_SIZE_4_5;
9915 parse_func = saph_sha1_parse_hash;
9916 sort_by_digest = sort_by_digest_4_5;
9917 opti_type = OPTI_TYPE_ZERO_BYTE;
9918 dgst_pos0 = 0;
9919 dgst_pos1 = 1;
9920 dgst_pos2 = 2;
9921 dgst_pos3 = 3;
9922 break;
9923
9924 case 10400: hash_type = HASH_TYPE_PDFU16;
9925 salt_type = SALT_TYPE_EMBEDDED;
9926 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9927 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9928 kern_type = KERN_TYPE_PDF11;
9929 dgst_size = DGST_SIZE_4_4;
9930 parse_func = pdf11_parse_hash;
9931 sort_by_digest = sort_by_digest_4_4;
9932 opti_type = OPTI_TYPE_ZERO_BYTE
9933 | OPTI_TYPE_NOT_ITERATED;
9934 dgst_pos0 = 0;
9935 dgst_pos1 = 1;
9936 dgst_pos2 = 2;
9937 dgst_pos3 = 3;
9938 break;
9939
9940 case 10410: hash_type = HASH_TYPE_PDFU16;
9941 salt_type = SALT_TYPE_EMBEDDED;
9942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9943 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9944 kern_type = KERN_TYPE_PDF11CM1;
9945 dgst_size = DGST_SIZE_4_4;
9946 parse_func = pdf11cm1_parse_hash;
9947 sort_by_digest = sort_by_digest_4_4;
9948 opti_type = OPTI_TYPE_ZERO_BYTE
9949 | OPTI_TYPE_NOT_ITERATED;
9950 dgst_pos0 = 0;
9951 dgst_pos1 = 1;
9952 dgst_pos2 = 2;
9953 dgst_pos3 = 3;
9954 break;
9955
9956 case 10420: hash_type = HASH_TYPE_PDFU16;
9957 salt_type = SALT_TYPE_EMBEDDED;
9958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9959 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9960 kern_type = KERN_TYPE_PDF11CM2;
9961 dgst_size = DGST_SIZE_4_4;
9962 parse_func = pdf11cm2_parse_hash;
9963 sort_by_digest = sort_by_digest_4_4;
9964 opti_type = OPTI_TYPE_ZERO_BYTE
9965 | OPTI_TYPE_NOT_ITERATED;
9966 dgst_pos0 = 0;
9967 dgst_pos1 = 1;
9968 dgst_pos2 = 2;
9969 dgst_pos3 = 3;
9970 break;
9971
9972 case 10500: hash_type = HASH_TYPE_PDFU16;
9973 salt_type = SALT_TYPE_EMBEDDED;
9974 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9975 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9976 kern_type = KERN_TYPE_PDF14;
9977 dgst_size = DGST_SIZE_4_4;
9978 parse_func = pdf14_parse_hash;
9979 sort_by_digest = sort_by_digest_4_4;
9980 opti_type = OPTI_TYPE_ZERO_BYTE
9981 | OPTI_TYPE_NOT_ITERATED;
9982 dgst_pos0 = 0;
9983 dgst_pos1 = 1;
9984 dgst_pos2 = 2;
9985 dgst_pos3 = 3;
9986 break;
9987
9988 case 10600: hash_type = HASH_TYPE_SHA256;
9989 salt_type = SALT_TYPE_EMBEDDED;
9990 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9991 opts_type = OPTS_TYPE_PT_GENERATE_BE
9992 | OPTS_TYPE_ST_ADD80
9993 | OPTS_TYPE_ST_ADDBITS15
9994 | OPTS_TYPE_HASH_COPY;
9995 kern_type = KERN_TYPE_SHA256_PWSLT;
9996 dgst_size = DGST_SIZE_4_8;
9997 parse_func = pdf17l3_parse_hash;
9998 sort_by_digest = sort_by_digest_4_8;
9999 opti_type = OPTI_TYPE_ZERO_BYTE
10000 | OPTI_TYPE_PRECOMPUTE_INIT
10001 | OPTI_TYPE_PRECOMPUTE_MERKLE
10002 | OPTI_TYPE_EARLY_SKIP
10003 | OPTI_TYPE_NOT_ITERATED
10004 | OPTI_TYPE_APPENDED_SALT
10005 | OPTI_TYPE_RAW_HASH;
10006 dgst_pos0 = 3;
10007 dgst_pos1 = 7;
10008 dgst_pos2 = 2;
10009 dgst_pos3 = 6;
10010 break;
10011
10012 case 10700: hash_type = HASH_TYPE_PDFU32;
10013 salt_type = SALT_TYPE_EMBEDDED;
10014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10015 opts_type = OPTS_TYPE_PT_GENERATE_LE
10016 | OPTS_TYPE_HASH_COPY;
10017 kern_type = KERN_TYPE_PDF17L8;
10018 dgst_size = DGST_SIZE_4_8;
10019 parse_func = pdf17l8_parse_hash;
10020 sort_by_digest = sort_by_digest_4_8;
10021 opti_type = OPTI_TYPE_ZERO_BYTE
10022 | OPTI_TYPE_NOT_ITERATED;
10023 dgst_pos0 = 0;
10024 dgst_pos1 = 1;
10025 dgst_pos2 = 2;
10026 dgst_pos3 = 3;
10027 break;
10028
10029 case 10800: hash_type = HASH_TYPE_SHA384;
10030 salt_type = SALT_TYPE_NONE;
10031 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10032 opts_type = OPTS_TYPE_PT_GENERATE_BE
10033 | OPTS_TYPE_PT_ADD80
10034 | OPTS_TYPE_PT_ADDBITS15;
10035 kern_type = KERN_TYPE_SHA384;
10036 dgst_size = DGST_SIZE_8_8;
10037 parse_func = sha384_parse_hash;
10038 sort_by_digest = sort_by_digest_8_8;
10039 opti_type = OPTI_TYPE_ZERO_BYTE
10040 | OPTI_TYPE_PRECOMPUTE_INIT
10041 | OPTI_TYPE_PRECOMPUTE_MERKLE
10042 | OPTI_TYPE_EARLY_SKIP
10043 | OPTI_TYPE_NOT_ITERATED
10044 | OPTI_TYPE_NOT_SALTED
10045 | OPTI_TYPE_USES_BITS_64
10046 | OPTI_TYPE_RAW_HASH;
10047 dgst_pos0 = 6;
10048 dgst_pos1 = 7;
10049 dgst_pos2 = 4;
10050 dgst_pos3 = 5;
10051 break;
10052
10053 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10054 salt_type = SALT_TYPE_EMBEDDED;
10055 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10056 opts_type = OPTS_TYPE_PT_GENERATE_LE
10057 | OPTS_TYPE_ST_BASE64
10058 | OPTS_TYPE_HASH_COPY;
10059 kern_type = KERN_TYPE_PBKDF2_SHA256;
10060 dgst_size = DGST_SIZE_4_32;
10061 parse_func = pbkdf2_sha256_parse_hash;
10062 sort_by_digest = sort_by_digest_4_32;
10063 opti_type = OPTI_TYPE_ZERO_BYTE
10064 | OPTI_TYPE_SLOW_HASH_SIMD;
10065 dgst_pos0 = 0;
10066 dgst_pos1 = 1;
10067 dgst_pos2 = 2;
10068 dgst_pos3 = 3;
10069 break;
10070
10071 case 11000: hash_type = HASH_TYPE_MD5;
10072 salt_type = SALT_TYPE_INTERN;
10073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10074 opts_type = OPTS_TYPE_PT_GENERATE_LE
10075 | OPTS_TYPE_PT_ADD80;
10076 kern_type = KERN_TYPE_PRESTASHOP;
10077 dgst_size = DGST_SIZE_4_4;
10078 parse_func = prestashop_parse_hash;
10079 sort_by_digest = sort_by_digest_4_4;
10080 opti_type = OPTI_TYPE_ZERO_BYTE
10081 | OPTI_TYPE_PRECOMPUTE_INIT
10082 | OPTI_TYPE_NOT_ITERATED
10083 | OPTI_TYPE_PREPENDED_SALT;
10084 dgst_pos0 = 0;
10085 dgst_pos1 = 3;
10086 dgst_pos2 = 2;
10087 dgst_pos3 = 1;
10088 break;
10089
10090 case 11100: hash_type = HASH_TYPE_MD5;
10091 salt_type = SALT_TYPE_EMBEDDED;
10092 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10093 opts_type = OPTS_TYPE_PT_GENERATE_LE
10094 | OPTS_TYPE_ST_ADD80;
10095 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10096 dgst_size = DGST_SIZE_4_4;
10097 parse_func = postgresql_auth_parse_hash;
10098 sort_by_digest = sort_by_digest_4_4;
10099 opti_type = OPTI_TYPE_ZERO_BYTE
10100 | OPTI_TYPE_PRECOMPUTE_INIT
10101 | OPTI_TYPE_PRECOMPUTE_MERKLE
10102 | OPTI_TYPE_EARLY_SKIP;
10103 dgst_pos0 = 0;
10104 dgst_pos1 = 3;
10105 dgst_pos2 = 2;
10106 dgst_pos3 = 1;
10107 break;
10108
10109 case 11200: hash_type = HASH_TYPE_SHA1;
10110 salt_type = SALT_TYPE_EMBEDDED;
10111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10112 opts_type = OPTS_TYPE_PT_GENERATE_BE
10113 | OPTS_TYPE_PT_ADD80
10114 | OPTS_TYPE_ST_HEX;
10115 kern_type = KERN_TYPE_MYSQL_AUTH;
10116 dgst_size = DGST_SIZE_4_5;
10117 parse_func = mysql_auth_parse_hash;
10118 sort_by_digest = sort_by_digest_4_5;
10119 opti_type = OPTI_TYPE_ZERO_BYTE
10120 | OPTI_TYPE_EARLY_SKIP;
10121 dgst_pos0 = 3;
10122 dgst_pos1 = 4;
10123 dgst_pos2 = 2;
10124 dgst_pos3 = 1;
10125 break;
10126
10127 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10128 salt_type = SALT_TYPE_EMBEDDED;
10129 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10130 opts_type = OPTS_TYPE_PT_GENERATE_LE
10131 | OPTS_TYPE_ST_HEX
10132 | OPTS_TYPE_ST_ADD80;
10133 kern_type = KERN_TYPE_BITCOIN_WALLET;
10134 dgst_size = DGST_SIZE_4_4;
10135 parse_func = bitcoin_wallet_parse_hash;
10136 sort_by_digest = sort_by_digest_4_4;
10137 opti_type = OPTI_TYPE_ZERO_BYTE;
10138 dgst_pos0 = 0;
10139 dgst_pos1 = 1;
10140 dgst_pos2 = 2;
10141 dgst_pos3 = 3;
10142 break;
10143
10144 case 11400: hash_type = HASH_TYPE_MD5;
10145 salt_type = SALT_TYPE_EMBEDDED;
10146 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10147 opts_type = OPTS_TYPE_PT_GENERATE_LE
10148 | OPTS_TYPE_PT_ADD80
10149 | OPTS_TYPE_HASH_COPY;
10150 kern_type = KERN_TYPE_SIP_AUTH;
10151 dgst_size = DGST_SIZE_4_4;
10152 parse_func = sip_auth_parse_hash;
10153 sort_by_digest = sort_by_digest_4_4;
10154 opti_type = OPTI_TYPE_ZERO_BYTE;
10155 dgst_pos0 = 0;
10156 dgst_pos1 = 3;
10157 dgst_pos2 = 2;
10158 dgst_pos3 = 1;
10159 break;
10160
10161 case 11500: hash_type = HASH_TYPE_CRC32;
10162 salt_type = SALT_TYPE_INTERN;
10163 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10164 opts_type = OPTS_TYPE_PT_GENERATE_LE
10165 | OPTS_TYPE_ST_GENERATE_LE
10166 | OPTS_TYPE_ST_HEX;
10167 kern_type = KERN_TYPE_CRC32;
10168 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10169 parse_func = crc32_parse_hash;
10170 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10171 opti_type = OPTI_TYPE_ZERO_BYTE;
10172 dgst_pos0 = 0;
10173 dgst_pos1 = 1;
10174 dgst_pos2 = 2;
10175 dgst_pos3 = 3;
10176 break;
10177
10178 case 11600: hash_type = HASH_TYPE_AES;
10179 salt_type = SALT_TYPE_EMBEDDED;
10180 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10181 opts_type = OPTS_TYPE_PT_GENERATE_LE
10182 | OPTS_TYPE_PT_NEVERCRACK;
10183 kern_type = KERN_TYPE_SEVEN_ZIP;
10184 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10185 parse_func = seven_zip_parse_hash;
10186 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10187 opti_type = OPTI_TYPE_ZERO_BYTE;
10188 dgst_pos0 = 0;
10189 dgst_pos1 = 1;
10190 dgst_pos2 = 2;
10191 dgst_pos3 = 3;
10192 break;
10193
10194 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10195 salt_type = SALT_TYPE_NONE;
10196 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10197 opts_type = OPTS_TYPE_PT_GENERATE_LE
10198 | OPTS_TYPE_PT_ADD01;
10199 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10200 dgst_size = DGST_SIZE_4_8;
10201 parse_func = gost2012sbog_256_parse_hash;
10202 sort_by_digest = sort_by_digest_4_8;
10203 opti_type = OPTI_TYPE_ZERO_BYTE;
10204 dgst_pos0 = 0;
10205 dgst_pos1 = 1;
10206 dgst_pos2 = 2;
10207 dgst_pos3 = 3;
10208 break;
10209
10210 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10211 salt_type = SALT_TYPE_NONE;
10212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10213 opts_type = OPTS_TYPE_PT_GENERATE_LE
10214 | OPTS_TYPE_PT_ADD01;
10215 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10216 dgst_size = DGST_SIZE_4_16;
10217 parse_func = gost2012sbog_512_parse_hash;
10218 sort_by_digest = sort_by_digest_4_16;
10219 opti_type = OPTI_TYPE_ZERO_BYTE;
10220 dgst_pos0 = 0;
10221 dgst_pos1 = 1;
10222 dgst_pos2 = 2;
10223 dgst_pos3 = 3;
10224 break;
10225
10226 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10227 salt_type = SALT_TYPE_EMBEDDED;
10228 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10229 opts_type = OPTS_TYPE_PT_GENERATE_LE
10230 | OPTS_TYPE_ST_BASE64
10231 | OPTS_TYPE_HASH_COPY;
10232 kern_type = KERN_TYPE_PBKDF2_MD5;
10233 dgst_size = DGST_SIZE_4_32;
10234 parse_func = pbkdf2_md5_parse_hash;
10235 sort_by_digest = sort_by_digest_4_32;
10236 opti_type = OPTI_TYPE_ZERO_BYTE
10237 | OPTI_TYPE_SLOW_HASH_SIMD;
10238 dgst_pos0 = 0;
10239 dgst_pos1 = 1;
10240 dgst_pos2 = 2;
10241 dgst_pos3 = 3;
10242 break;
10243
10244 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10245 salt_type = SALT_TYPE_EMBEDDED;
10246 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10247 opts_type = OPTS_TYPE_PT_GENERATE_LE
10248 | OPTS_TYPE_ST_BASE64
10249 | OPTS_TYPE_HASH_COPY;
10250 kern_type = KERN_TYPE_PBKDF2_SHA1;
10251 dgst_size = DGST_SIZE_4_32;
10252 parse_func = pbkdf2_sha1_parse_hash;
10253 sort_by_digest = sort_by_digest_4_32;
10254 opti_type = OPTI_TYPE_ZERO_BYTE
10255 | OPTI_TYPE_SLOW_HASH_SIMD;
10256 dgst_pos0 = 0;
10257 dgst_pos1 = 1;
10258 dgst_pos2 = 2;
10259 dgst_pos3 = 3;
10260 break;
10261
10262 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10263 salt_type = SALT_TYPE_EMBEDDED;
10264 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10265 opts_type = OPTS_TYPE_PT_GENERATE_LE
10266 | OPTS_TYPE_ST_BASE64
10267 | OPTS_TYPE_HASH_COPY;
10268 kern_type = KERN_TYPE_PBKDF2_SHA512;
10269 dgst_size = DGST_SIZE_8_16;
10270 parse_func = pbkdf2_sha512_parse_hash;
10271 sort_by_digest = sort_by_digest_8_16;
10272 opti_type = OPTI_TYPE_ZERO_BYTE
10273 | OPTI_TYPE_USES_BITS_64
10274 | OPTI_TYPE_SLOW_HASH_SIMD;
10275 dgst_pos0 = 0;
10276 dgst_pos1 = 1;
10277 dgst_pos2 = 2;
10278 dgst_pos3 = 3;
10279 break;
10280
10281 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10282 salt_type = SALT_TYPE_EMBEDDED;
10283 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10284 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10285 kern_type = KERN_TYPE_ECRYPTFS;
10286 dgst_size = DGST_SIZE_8_8;
10287 parse_func = ecryptfs_parse_hash;
10288 sort_by_digest = sort_by_digest_8_8;
10289 opti_type = OPTI_TYPE_ZERO_BYTE
10290 | OPTI_TYPE_USES_BITS_64;
10291 dgst_pos0 = 0;
10292 dgst_pos1 = 1;
10293 dgst_pos2 = 2;
10294 dgst_pos3 = 3;
10295 break;
10296
10297 case 12300: hash_type = HASH_TYPE_ORACLET;
10298 salt_type = SALT_TYPE_EMBEDDED;
10299 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10300 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10301 kern_type = KERN_TYPE_ORACLET;
10302 dgst_size = DGST_SIZE_8_16;
10303 parse_func = oraclet_parse_hash;
10304 sort_by_digest = sort_by_digest_8_16;
10305 opti_type = OPTI_TYPE_ZERO_BYTE
10306 | OPTI_TYPE_USES_BITS_64;
10307 dgst_pos0 = 0;
10308 dgst_pos1 = 1;
10309 dgst_pos2 = 2;
10310 dgst_pos3 = 3;
10311 break;
10312
10313 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10314 salt_type = SALT_TYPE_EMBEDDED;
10315 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10316 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10317 kern_type = KERN_TYPE_BSDICRYPT;
10318 dgst_size = DGST_SIZE_4_4;
10319 parse_func = bsdicrypt_parse_hash;
10320 sort_by_digest = sort_by_digest_4_4;
10321 opti_type = OPTI_TYPE_ZERO_BYTE
10322 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10323 dgst_pos0 = 0;
10324 dgst_pos1 = 1;
10325 dgst_pos2 = 2;
10326 dgst_pos3 = 3;
10327 break;
10328
10329 case 12500: hash_type = HASH_TYPE_RAR3HP;
10330 salt_type = SALT_TYPE_EMBEDDED;
10331 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10332 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10333 kern_type = KERN_TYPE_RAR3;
10334 dgst_size = DGST_SIZE_4_4;
10335 parse_func = rar3hp_parse_hash;
10336 sort_by_digest = sort_by_digest_4_4;
10337 opti_type = OPTI_TYPE_ZERO_BYTE;
10338 dgst_pos0 = 0;
10339 dgst_pos1 = 1;
10340 dgst_pos2 = 2;
10341 dgst_pos3 = 3;
10342 break;
10343
10344 case 12600: hash_type = HASH_TYPE_SHA256;
10345 salt_type = SALT_TYPE_INTERN;
10346 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10347 opts_type = OPTS_TYPE_PT_GENERATE_BE
10348 | OPTS_TYPE_PT_ADD80;
10349 kern_type = KERN_TYPE_CF10;
10350 dgst_size = DGST_SIZE_4_8;
10351 parse_func = cf10_parse_hash;
10352 sort_by_digest = sort_by_digest_4_8;
10353 opti_type = OPTI_TYPE_ZERO_BYTE
10354 | OPTI_TYPE_PRECOMPUTE_INIT
10355 | OPTI_TYPE_EARLY_SKIP
10356 | OPTI_TYPE_NOT_ITERATED;
10357 dgst_pos0 = 3;
10358 dgst_pos1 = 7;
10359 dgst_pos2 = 2;
10360 dgst_pos3 = 6;
10361 break;
10362
10363 case 12700: hash_type = HASH_TYPE_AES;
10364 salt_type = SALT_TYPE_EMBEDDED;
10365 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10366 opts_type = OPTS_TYPE_PT_GENERATE_LE
10367 | OPTS_TYPE_HASH_COPY;
10368 kern_type = KERN_TYPE_MYWALLET;
10369 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10370 parse_func = mywallet_parse_hash;
10371 sort_by_digest = sort_by_digest_4_5;
10372 opti_type = OPTI_TYPE_ZERO_BYTE;
10373 dgst_pos0 = 0;
10374 dgst_pos1 = 1;
10375 dgst_pos2 = 2;
10376 dgst_pos3 = 3;
10377 break;
10378
10379 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10380 salt_type = SALT_TYPE_EMBEDDED;
10381 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10382 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10383 kern_type = KERN_TYPE_MS_DRSR;
10384 dgst_size = DGST_SIZE_4_8;
10385 parse_func = ms_drsr_parse_hash;
10386 sort_by_digest = sort_by_digest_4_8;
10387 opti_type = OPTI_TYPE_ZERO_BYTE;
10388 dgst_pos0 = 0;
10389 dgst_pos1 = 1;
10390 dgst_pos2 = 2;
10391 dgst_pos3 = 3;
10392 break;
10393
10394 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10395 salt_type = SALT_TYPE_EMBEDDED;
10396 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10397 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10398 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10399 dgst_size = DGST_SIZE_4_8;
10400 parse_func = androidfde_samsung_parse_hash;
10401 sort_by_digest = sort_by_digest_4_8;
10402 opti_type = OPTI_TYPE_ZERO_BYTE;
10403 dgst_pos0 = 0;
10404 dgst_pos1 = 1;
10405 dgst_pos2 = 2;
10406 dgst_pos3 = 3;
10407 break;
10408
10409 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10410 salt_type = SALT_TYPE_EMBEDDED;
10411 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10412 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10413 kern_type = KERN_TYPE_RAR5;
10414 dgst_size = DGST_SIZE_4_4;
10415 parse_func = rar5_parse_hash;
10416 sort_by_digest = sort_by_digest_4_4;
10417 opti_type = OPTI_TYPE_ZERO_BYTE;
10418 dgst_pos0 = 0;
10419 dgst_pos1 = 1;
10420 dgst_pos2 = 2;
10421 dgst_pos3 = 3;
10422 break;
10423
10424 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10425 salt_type = SALT_TYPE_EMBEDDED;
10426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10427 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10428 kern_type = KERN_TYPE_KRB5TGS;
10429 dgst_size = DGST_SIZE_4_4;
10430 parse_func = krb5tgs_parse_hash;
10431 sort_by_digest = sort_by_digest_4_4;
10432 opti_type = OPTI_TYPE_ZERO_BYTE
10433 | OPTI_TYPE_NOT_ITERATED;
10434 dgst_pos0 = 0;
10435 dgst_pos1 = 1;
10436 dgst_pos2 = 2;
10437 dgst_pos3 = 3;
10438 break;
10439
10440 case 13200: hash_type = HASH_TYPE_AES;
10441 salt_type = SALT_TYPE_EMBEDDED;
10442 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10443 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10444 kern_type = KERN_TYPE_AXCRYPT;
10445 dgst_size = DGST_SIZE_4_4;
10446 parse_func = axcrypt_parse_hash;
10447 sort_by_digest = sort_by_digest_4_4;
10448 opti_type = OPTI_TYPE_ZERO_BYTE;
10449 dgst_pos0 = 0;
10450 dgst_pos1 = 1;
10451 dgst_pos2 = 2;
10452 dgst_pos3 = 3;
10453 break;
10454
10455 case 13300: hash_type = HASH_TYPE_SHA1;
10456 salt_type = SALT_TYPE_NONE;
10457 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10458 opts_type = OPTS_TYPE_PT_GENERATE_BE
10459 | OPTS_TYPE_PT_ADD80
10460 | OPTS_TYPE_PT_ADDBITS15;
10461 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10462 dgst_size = DGST_SIZE_4_5;
10463 parse_func = sha1axcrypt_parse_hash;
10464 sort_by_digest = sort_by_digest_4_5;
10465 opti_type = OPTI_TYPE_ZERO_BYTE
10466 | OPTI_TYPE_PRECOMPUTE_INIT
10467 | OPTI_TYPE_EARLY_SKIP
10468 | OPTI_TYPE_NOT_ITERATED
10469 | OPTI_TYPE_NOT_SALTED;
10470 dgst_pos0 = 0;
10471 dgst_pos1 = 4;
10472 dgst_pos2 = 3;
10473 dgst_pos3 = 2;
10474 break;
10475
10476 case 13400: hash_type = HASH_TYPE_AES;
10477 salt_type = SALT_TYPE_EMBEDDED;
10478 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10479 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10480 kern_type = KERN_TYPE_KEEPASS;
10481 dgst_size = DGST_SIZE_4_4;
10482 parse_func = keepass_parse_hash;
10483 sort_by_digest = sort_by_digest_4_4;
10484 opti_type = OPTI_TYPE_ZERO_BYTE;
10485 dgst_pos0 = 0;
10486 dgst_pos1 = 1;
10487 dgst_pos2 = 2;
10488 dgst_pos3 = 3;
10489 break;
10490
10491 case 13500: hash_type = HASH_TYPE_SHA1;
10492 salt_type = SALT_TYPE_EMBEDDED;
10493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10494 opts_type = OPTS_TYPE_PT_GENERATE_BE
10495 | OPTS_TYPE_PT_UNICODE
10496 | OPTS_TYPE_PT_ADD80;
10497 kern_type = KERN_TYPE_PSTOKEN;
10498 dgst_size = DGST_SIZE_4_5;
10499 parse_func = pstoken_parse_hash;
10500 sort_by_digest = sort_by_digest_4_5;
10501 opti_type = OPTI_TYPE_ZERO_BYTE
10502 | OPTI_TYPE_PRECOMPUTE_INIT
10503 | OPTI_TYPE_EARLY_SKIP
10504 | OPTI_TYPE_NOT_ITERATED
10505 | OPTI_TYPE_PREPENDED_SALT
10506 | OPTI_TYPE_RAW_HASH;
10507 dgst_pos0 = 3;
10508 dgst_pos1 = 4;
10509 dgst_pos2 = 2;
10510 dgst_pos3 = 1;
10511 break;
10512
10513 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10514 salt_type = SALT_TYPE_EMBEDDED;
10515 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10516 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10517 kern_type = KERN_TYPE_ZIP2;
10518 dgst_size = DGST_SIZE_4_4;
10519 parse_func = zip2_parse_hash;
10520 sort_by_digest = sort_by_digest_4_4;
10521 opti_type = OPTI_TYPE_ZERO_BYTE;
10522 dgst_pos0 = 0;
10523 dgst_pos1 = 1;
10524 dgst_pos2 = 2;
10525 dgst_pos3 = 3;
10526 break;
10527
10528 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10529 salt_type = SALT_TYPE_EMBEDDED;
10530 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10531 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10532 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10533 dgst_size = DGST_SIZE_4_5;
10534 parse_func = veracrypt_parse_hash_655331;
10535 sort_by_digest = sort_by_digest_4_5;
10536 opti_type = OPTI_TYPE_ZERO_BYTE;
10537 dgst_pos0 = 0;
10538 dgst_pos1 = 1;
10539 dgst_pos2 = 2;
10540 dgst_pos3 = 3;
10541 break;
10542
10543 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10544 salt_type = SALT_TYPE_EMBEDDED;
10545 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10546 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10547 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10548 dgst_size = DGST_SIZE_4_5;
10549 parse_func = veracrypt_parse_hash_655331;
10550 sort_by_digest = sort_by_digest_4_5;
10551 opti_type = OPTI_TYPE_ZERO_BYTE;
10552 dgst_pos0 = 0;
10553 dgst_pos1 = 1;
10554 dgst_pos2 = 2;
10555 dgst_pos3 = 3;
10556 break;
10557
10558 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10559 salt_type = SALT_TYPE_EMBEDDED;
10560 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10561 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10562 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10563 dgst_size = DGST_SIZE_4_5;
10564 parse_func = veracrypt_parse_hash_655331;
10565 sort_by_digest = sort_by_digest_4_5;
10566 opti_type = OPTI_TYPE_ZERO_BYTE;
10567 dgst_pos0 = 0;
10568 dgst_pos1 = 1;
10569 dgst_pos2 = 2;
10570 dgst_pos3 = 3;
10571 break;
10572
10573 case 13721: hash_type = HASH_TYPE_SHA512;
10574 salt_type = SALT_TYPE_EMBEDDED;
10575 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10576 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10577 kern_type = KERN_TYPE_TCSHA512_XTS512;
10578 dgst_size = DGST_SIZE_8_8;
10579 parse_func = veracrypt_parse_hash_500000;
10580 sort_by_digest = sort_by_digest_8_8;
10581 opti_type = OPTI_TYPE_ZERO_BYTE
10582 | OPTI_TYPE_USES_BITS_64;
10583 dgst_pos0 = 0;
10584 dgst_pos1 = 1;
10585 dgst_pos2 = 2;
10586 dgst_pos3 = 3;
10587 break;
10588
10589 case 13722: hash_type = HASH_TYPE_SHA512;
10590 salt_type = SALT_TYPE_EMBEDDED;
10591 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10592 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10593 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10594 dgst_size = DGST_SIZE_8_8;
10595 parse_func = veracrypt_parse_hash_500000;
10596 sort_by_digest = sort_by_digest_8_8;
10597 opti_type = OPTI_TYPE_ZERO_BYTE
10598 | OPTI_TYPE_USES_BITS_64;
10599 dgst_pos0 = 0;
10600 dgst_pos1 = 1;
10601 dgst_pos2 = 2;
10602 dgst_pos3 = 3;
10603 break;
10604
10605 case 13723: hash_type = HASH_TYPE_SHA512;
10606 salt_type = SALT_TYPE_EMBEDDED;
10607 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10608 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10609 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10610 dgst_size = DGST_SIZE_8_8;
10611 parse_func = veracrypt_parse_hash_500000;
10612 sort_by_digest = sort_by_digest_8_8;
10613 opti_type = OPTI_TYPE_ZERO_BYTE
10614 | OPTI_TYPE_USES_BITS_64;
10615 dgst_pos0 = 0;
10616 dgst_pos1 = 1;
10617 dgst_pos2 = 2;
10618 dgst_pos3 = 3;
10619 break;
10620
10621 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10622 salt_type = SALT_TYPE_EMBEDDED;
10623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10624 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10625 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10626 dgst_size = DGST_SIZE_4_8;
10627 parse_func = veracrypt_parse_hash_500000;
10628 sort_by_digest = sort_by_digest_4_8;
10629 opti_type = OPTI_TYPE_ZERO_BYTE;
10630 dgst_pos0 = 0;
10631 dgst_pos1 = 1;
10632 dgst_pos2 = 2;
10633 dgst_pos3 = 3;
10634 break;
10635
10636 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10637 salt_type = SALT_TYPE_EMBEDDED;
10638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10639 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10640 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10641 dgst_size = DGST_SIZE_4_8;
10642 parse_func = veracrypt_parse_hash_500000;
10643 sort_by_digest = sort_by_digest_4_8;
10644 opti_type = OPTI_TYPE_ZERO_BYTE;
10645 dgst_pos0 = 0;
10646 dgst_pos1 = 1;
10647 dgst_pos2 = 2;
10648 dgst_pos3 = 3;
10649 break;
10650
10651 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10652 salt_type = SALT_TYPE_EMBEDDED;
10653 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10654 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10655 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10656 dgst_size = DGST_SIZE_4_8;
10657 parse_func = veracrypt_parse_hash_500000;
10658 sort_by_digest = sort_by_digest_4_8;
10659 opti_type = OPTI_TYPE_ZERO_BYTE;
10660 dgst_pos0 = 0;
10661 dgst_pos1 = 1;
10662 dgst_pos2 = 2;
10663 dgst_pos3 = 3;
10664 break;
10665
10666 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10667 salt_type = SALT_TYPE_EMBEDDED;
10668 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10669 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10670 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10671 dgst_size = DGST_SIZE_4_5;
10672 parse_func = veracrypt_parse_hash_327661;
10673 sort_by_digest = sort_by_digest_4_5;
10674 opti_type = OPTI_TYPE_ZERO_BYTE;
10675 dgst_pos0 = 0;
10676 dgst_pos1 = 1;
10677 dgst_pos2 = 2;
10678 dgst_pos3 = 3;
10679 break;
10680
10681 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10682 salt_type = SALT_TYPE_EMBEDDED;
10683 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10684 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10685 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10686 dgst_size = DGST_SIZE_4_5;
10687 parse_func = veracrypt_parse_hash_327661;
10688 sort_by_digest = sort_by_digest_4_5;
10689 opti_type = OPTI_TYPE_ZERO_BYTE;
10690 dgst_pos0 = 0;
10691 dgst_pos1 = 1;
10692 dgst_pos2 = 2;
10693 dgst_pos3 = 3;
10694 break;
10695
10696 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10697 salt_type = SALT_TYPE_EMBEDDED;
10698 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10699 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10700 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10701 dgst_size = DGST_SIZE_4_5;
10702 parse_func = veracrypt_parse_hash_327661;
10703 sort_by_digest = sort_by_digest_4_5;
10704 opti_type = OPTI_TYPE_ZERO_BYTE;
10705 dgst_pos0 = 0;
10706 dgst_pos1 = 1;
10707 dgst_pos2 = 2;
10708 dgst_pos3 = 3;
10709 break;
10710
10711 case 13751: hash_type = HASH_TYPE_SHA256;
10712 salt_type = SALT_TYPE_EMBEDDED;
10713 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10714 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10715 kern_type = KERN_TYPE_VCSHA256_XTS512;
10716 dgst_size = DGST_SIZE_4_8;
10717 parse_func = veracrypt_parse_hash_500000;
10718 sort_by_digest = sort_by_digest_4_8;
10719 opti_type = OPTI_TYPE_ZERO_BYTE;
10720 dgst_pos0 = 0;
10721 dgst_pos1 = 1;
10722 dgst_pos2 = 2;
10723 dgst_pos3 = 3;
10724 break;
10725
10726 case 13752: hash_type = HASH_TYPE_SHA256;
10727 salt_type = SALT_TYPE_EMBEDDED;
10728 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10729 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10730 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10731 dgst_size = DGST_SIZE_4_8;
10732 parse_func = veracrypt_parse_hash_500000;
10733 sort_by_digest = sort_by_digest_4_8;
10734 opti_type = OPTI_TYPE_ZERO_BYTE;
10735 dgst_pos0 = 0;
10736 dgst_pos1 = 1;
10737 dgst_pos2 = 2;
10738 dgst_pos3 = 3;
10739 break;
10740
10741 case 13753: hash_type = HASH_TYPE_SHA256;
10742 salt_type = SALT_TYPE_EMBEDDED;
10743 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10744 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10745 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10746 dgst_size = DGST_SIZE_4_8;
10747 parse_func = veracrypt_parse_hash_500000;
10748 sort_by_digest = sort_by_digest_4_8;
10749 opti_type = OPTI_TYPE_ZERO_BYTE;
10750 dgst_pos0 = 0;
10751 dgst_pos1 = 1;
10752 dgst_pos2 = 2;
10753 dgst_pos3 = 3;
10754 break;
10755
10756 case 13761: hash_type = HASH_TYPE_SHA256;
10757 salt_type = SALT_TYPE_EMBEDDED;
10758 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10759 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10760 kern_type = KERN_TYPE_VCSHA256_XTS512;
10761 dgst_size = DGST_SIZE_4_8;
10762 parse_func = veracrypt_parse_hash_200000;
10763 sort_by_digest = sort_by_digest_4_8;
10764 opti_type = OPTI_TYPE_ZERO_BYTE;
10765 dgst_pos0 = 0;
10766 dgst_pos1 = 1;
10767 dgst_pos2 = 2;
10768 dgst_pos3 = 3;
10769 break;
10770
10771 case 13762: hash_type = HASH_TYPE_SHA256;
10772 salt_type = SALT_TYPE_EMBEDDED;
10773 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10774 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10775 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10776 dgst_size = DGST_SIZE_4_8;
10777 parse_func = veracrypt_parse_hash_200000;
10778 sort_by_digest = sort_by_digest_4_8;
10779 opti_type = OPTI_TYPE_ZERO_BYTE;
10780 dgst_pos0 = 0;
10781 dgst_pos1 = 1;
10782 dgst_pos2 = 2;
10783 dgst_pos3 = 3;
10784 break;
10785
10786 case 13763: hash_type = HASH_TYPE_SHA256;
10787 salt_type = SALT_TYPE_EMBEDDED;
10788 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10789 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10790 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10791 dgst_size = DGST_SIZE_4_8;
10792 parse_func = veracrypt_parse_hash_200000;
10793 sort_by_digest = sort_by_digest_4_8;
10794 opti_type = OPTI_TYPE_ZERO_BYTE;
10795 dgst_pos0 = 0;
10796 dgst_pos1 = 1;
10797 dgst_pos2 = 2;
10798 dgst_pos3 = 3;
10799 break;
10800
10801 case 13800: hash_type = HASH_TYPE_SHA256;
10802 salt_type = SALT_TYPE_EMBEDDED;
10803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10804 opts_type = OPTS_TYPE_PT_GENERATE_BE
10805 | OPTS_TYPE_PT_UNICODE;
10806 kern_type = KERN_TYPE_WIN8PHONE;
10807 dgst_size = DGST_SIZE_4_8;
10808 parse_func = win8phone_parse_hash;
10809 sort_by_digest = sort_by_digest_4_8;
10810 opti_type = OPTI_TYPE_ZERO_BYTE
10811 | OPTI_TYPE_PRECOMPUTE_INIT
10812 | OPTI_TYPE_EARLY_SKIP
10813 | OPTI_TYPE_NOT_ITERATED
10814 | OPTI_TYPE_RAW_HASH;
10815 dgst_pos0 = 3;
10816 dgst_pos1 = 7;
10817 dgst_pos2 = 2;
10818 dgst_pos3 = 6;
10819 break;
10820
10821
10822 default: usage_mini_print (PROGNAME); return (-1);
10823 }
10824
10825 /**
10826 * parser
10827 */
10828
10829 data.parse_func = parse_func;
10830
10831 /**
10832 * misc stuff
10833 */
10834
10835 if (hex_salt)
10836 {
10837 if (salt_type == SALT_TYPE_INTERN)
10838 {
10839 opts_type |= OPTS_TYPE_ST_HEX;
10840 }
10841 else
10842 {
10843 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10844
10845 return (-1);
10846 }
10847 }
10848
10849 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10850 | (salt_type == SALT_TYPE_EXTERN)
10851 | (salt_type == SALT_TYPE_EMBEDDED)
10852 | (salt_type == SALT_TYPE_VIRTUAL));
10853
10854 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10855
10856 data.hash_type = hash_type;
10857 data.attack_mode = attack_mode;
10858 data.attack_kern = attack_kern;
10859 data.attack_exec = attack_exec;
10860 data.kern_type = kern_type;
10861 data.opts_type = opts_type;
10862 data.dgst_size = dgst_size;
10863 data.salt_type = salt_type;
10864 data.isSalted = isSalted;
10865 data.sort_by_digest = sort_by_digest;
10866 data.dgst_pos0 = dgst_pos0;
10867 data.dgst_pos1 = dgst_pos1;
10868 data.dgst_pos2 = dgst_pos2;
10869 data.dgst_pos3 = dgst_pos3;
10870
10871 esalt_size = 0;
10872
10873 switch (hash_mode)
10874 {
10875 case 2500: esalt_size = sizeof (wpa_t); break;
10876 case 5300: esalt_size = sizeof (ikepsk_t); break;
10877 case 5400: esalt_size = sizeof (ikepsk_t); break;
10878 case 5500: esalt_size = sizeof (netntlm_t); break;
10879 case 5600: esalt_size = sizeof (netntlm_t); break;
10880 case 6211: esalt_size = sizeof (tc_t); break;
10881 case 6212: esalt_size = sizeof (tc_t); break;
10882 case 6213: esalt_size = sizeof (tc_t); break;
10883 case 6221: esalt_size = sizeof (tc_t); break;
10884 case 6222: esalt_size = sizeof (tc_t); break;
10885 case 6223: esalt_size = sizeof (tc_t); break;
10886 case 6231: esalt_size = sizeof (tc_t); break;
10887 case 6232: esalt_size = sizeof (tc_t); break;
10888 case 6233: esalt_size = sizeof (tc_t); break;
10889 case 6241: esalt_size = sizeof (tc_t); break;
10890 case 6242: esalt_size = sizeof (tc_t); break;
10891 case 6243: esalt_size = sizeof (tc_t); break;
10892 case 6600: esalt_size = sizeof (agilekey_t); break;
10893 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10894 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10895 case 7300: esalt_size = sizeof (rakp_t); break;
10896 case 7500: esalt_size = sizeof (krb5pa_t); break;
10897 case 8200: esalt_size = sizeof (cloudkey_t); break;
10898 case 8800: esalt_size = sizeof (androidfde_t); break;
10899 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10900 case 9400: esalt_size = sizeof (office2007_t); break;
10901 case 9500: esalt_size = sizeof (office2010_t); break;
10902 case 9600: esalt_size = sizeof (office2013_t); break;
10903 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10904 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10905 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10906 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10907 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10908 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10909 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10910 case 10200: esalt_size = sizeof (cram_md5_t); break;
10911 case 10400: esalt_size = sizeof (pdf_t); break;
10912 case 10410: esalt_size = sizeof (pdf_t); break;
10913 case 10420: esalt_size = sizeof (pdf_t); break;
10914 case 10500: esalt_size = sizeof (pdf_t); break;
10915 case 10600: esalt_size = sizeof (pdf_t); break;
10916 case 10700: esalt_size = sizeof (pdf_t); break;
10917 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10918 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10919 case 11400: esalt_size = sizeof (sip_t); break;
10920 case 11600: esalt_size = sizeof (seven_zip_t); break;
10921 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10922 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10923 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10924 case 13000: esalt_size = sizeof (rar5_t); break;
10925 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10926 case 13400: esalt_size = sizeof (keepass_t); break;
10927 case 13500: esalt_size = sizeof (pstoken_t); break;
10928 case 13600: esalt_size = sizeof (zip2_t); break;
10929 case 13711: esalt_size = sizeof (tc_t); break;
10930 case 13712: esalt_size = sizeof (tc_t); break;
10931 case 13713: esalt_size = sizeof (tc_t); break;
10932 case 13721: esalt_size = sizeof (tc_t); break;
10933 case 13722: esalt_size = sizeof (tc_t); break;
10934 case 13723: esalt_size = sizeof (tc_t); break;
10935 case 13731: esalt_size = sizeof (tc_t); break;
10936 case 13732: esalt_size = sizeof (tc_t); break;
10937 case 13733: esalt_size = sizeof (tc_t); break;
10938 case 13741: esalt_size = sizeof (tc_t); break;
10939 case 13742: esalt_size = sizeof (tc_t); break;
10940 case 13743: esalt_size = sizeof (tc_t); break;
10941 case 13751: esalt_size = sizeof (tc_t); break;
10942 case 13752: esalt_size = sizeof (tc_t); break;
10943 case 13753: esalt_size = sizeof (tc_t); break;
10944 case 13761: esalt_size = sizeof (tc_t); break;
10945 case 13762: esalt_size = sizeof (tc_t); break;
10946 case 13763: esalt_size = sizeof (tc_t); break;
10947 case 13800: esalt_size = sizeof (win8phone_t); break;
10948 }
10949
10950 data.esalt_size = esalt_size;
10951
10952 /**
10953 * choose dictionary parser
10954 */
10955
10956 if (hash_type == HASH_TYPE_LM)
10957 {
10958 get_next_word_func = get_next_word_lm;
10959 }
10960 else if (opts_type & OPTS_TYPE_PT_UPPER)
10961 {
10962 get_next_word_func = get_next_word_uc;
10963 }
10964 else
10965 {
10966 get_next_word_func = get_next_word_std;
10967 }
10968
10969 /**
10970 * dictstat
10971 */
10972
10973 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10974
10975 #ifdef _POSIX
10976 size_t dictstat_nmemb = 0;
10977 #endif
10978
10979 #ifdef _WIN
10980 uint dictstat_nmemb = 0;
10981 #endif
10982
10983 char dictstat[256] = { 0 };
10984
10985 FILE *dictstat_fp = NULL;
10986
10987 if (keyspace == 0)
10988 {
10989 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10990
10991 dictstat_fp = fopen (dictstat, "rb");
10992
10993 if (dictstat_fp)
10994 {
10995 #ifdef _POSIX
10996 struct stat tmpstat;
10997
10998 fstat (fileno (dictstat_fp), &tmpstat);
10999 #endif
11000
11001 #ifdef _WIN
11002 struct stat64 tmpstat;
11003
11004 _fstat64 (fileno (dictstat_fp), &tmpstat);
11005 #endif
11006
11007 if (tmpstat.st_mtime < COMPTIME)
11008 {
11009 /* with v0.15 the format changed so we have to ensure user is using a good version
11010 since there is no version-header in the dictstat file */
11011
11012 fclose (dictstat_fp);
11013
11014 unlink (dictstat);
11015 }
11016 else
11017 {
11018 while (!feof (dictstat_fp))
11019 {
11020 dictstat_t d;
11021
11022 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11023
11024 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11025
11026 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11027 {
11028 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11029
11030 return -1;
11031 }
11032 }
11033
11034 fclose (dictstat_fp);
11035 }
11036 }
11037 }
11038
11039 /**
11040 * potfile
11041 */
11042
11043 char potfile[256] = { 0 };
11044
11045 if (potfile_path == NULL)
11046 {
11047 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11048 }
11049 else
11050 {
11051 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11052 }
11053
11054 data.pot_fp = NULL;
11055
11056 FILE *out_fp = NULL;
11057 FILE *pot_fp = NULL;
11058
11059 if (show == 1 || left == 1)
11060 {
11061 pot_fp = fopen (potfile, "rb");
11062
11063 if (pot_fp == NULL)
11064 {
11065 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11066
11067 return (-1);
11068 }
11069
11070 if (outfile != NULL)
11071 {
11072 if ((out_fp = fopen (outfile, "ab")) == NULL)
11073 {
11074 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11075
11076 fclose (pot_fp);
11077
11078 return (-1);
11079 }
11080 }
11081 else
11082 {
11083 out_fp = stdout;
11084 }
11085 }
11086 else
11087 {
11088 if (potfile_disable == 0)
11089 {
11090 pot_fp = fopen (potfile, "ab");
11091
11092 if (pot_fp == NULL)
11093 {
11094 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11095
11096 return (-1);
11097 }
11098
11099 data.pot_fp = pot_fp;
11100 }
11101 }
11102
11103 pot_t *pot = NULL;
11104
11105 uint pot_cnt = 0;
11106 uint pot_avail = 0;
11107
11108 if (show == 1 || left == 1)
11109 {
11110 SUPPRESS_OUTPUT = 1;
11111
11112 pot_avail = count_lines (pot_fp);
11113
11114 rewind (pot_fp);
11115
11116 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11117
11118 uint pot_hashes_avail = 0;
11119
11120 uint line_num = 0;
11121
11122 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11123
11124 while (!feof (pot_fp))
11125 {
11126 line_num++;
11127
11128 int line_len = fgetl (pot_fp, line_buf);
11129
11130 if (line_len == 0) continue;
11131
11132 char *plain_buf = line_buf + line_len;
11133
11134 pot_t *pot_ptr = &pot[pot_cnt];
11135
11136 hash_t *hashes_buf = &pot_ptr->hash;
11137
11138 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11139 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11140
11141 if (pot_cnt == pot_hashes_avail)
11142 {
11143 uint pos = 0;
11144
11145 for (pos = 0; pos < INCR_POT; pos++)
11146 {
11147 if ((pot_cnt + pos) >= pot_avail) break;
11148
11149 pot_t *tmp_pot = &pot[pot_cnt + pos];
11150
11151 hash_t *tmp_hash = &tmp_pot->hash;
11152
11153 tmp_hash->digest = mymalloc (dgst_size);
11154
11155 if (isSalted)
11156 {
11157 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11158 }
11159
11160 if (esalt_size)
11161 {
11162 tmp_hash->esalt = mymalloc (esalt_size);
11163 }
11164
11165 pot_hashes_avail++;
11166 }
11167 }
11168
11169 int plain_len = 0;
11170
11171 int parser_status;
11172
11173 int iter = MAX_CUT_TRIES;
11174
11175 do
11176 {
11177 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11178 {
11179 if (line_buf[i] == ':')
11180 {
11181 line_len--;
11182
11183 break;
11184 }
11185 }
11186
11187 if (data.hash_mode != 2500)
11188 {
11189 parser_status = parse_func (line_buf, line_len, hashes_buf);
11190 }
11191 else
11192 {
11193 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11194
11195 if (line_len > max_salt_size)
11196 {
11197 parser_status = PARSER_GLOBAL_LENGTH;
11198 }
11199 else
11200 {
11201 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11202
11203 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11204
11205 hashes_buf->salt->salt_len = line_len;
11206
11207 parser_status = PARSER_OK;
11208 }
11209 }
11210
11211 // if NOT parsed without error, we add the ":" to the plain
11212
11213 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11214 {
11215 plain_len++;
11216 plain_buf--;
11217 }
11218
11219 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11220
11221 if (parser_status < PARSER_GLOBAL_ZERO)
11222 {
11223 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11224
11225 continue;
11226 }
11227
11228 if (plain_len >= 255) continue;
11229
11230 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11231
11232 pot_ptr->plain_len = plain_len;
11233
11234 pot_cnt++;
11235 }
11236
11237 myfree (line_buf);
11238
11239 fclose (pot_fp);
11240
11241 SUPPRESS_OUTPUT = 0;
11242
11243 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11244 }
11245
11246 /**
11247 * word len
11248 */
11249
11250 uint pw_min = PW_MIN;
11251 uint pw_max = PW_MAX;
11252
11253 switch (hash_mode)
11254 {
11255 case 125: if (pw_max > 32) pw_max = 32;
11256 break;
11257 case 400: if (pw_max > 40) pw_max = 40;
11258 break;
11259 case 500: if (pw_max > 16) pw_max = 16;
11260 break;
11261 case 1500: if (pw_max > 8) pw_max = 8;
11262 break;
11263 case 1600: if (pw_max > 16) pw_max = 16;
11264 break;
11265 case 1800: if (pw_max > 16) pw_max = 16;
11266 break;
11267 case 2100: if (pw_max > 16) pw_max = 16;
11268 break;
11269 case 2500: if (pw_min < 8) pw_min = 8;
11270 break;
11271 case 3000: if (pw_max > 7) pw_max = 7;
11272 break;
11273 case 5200: if (pw_max > 24) pw_max = 24;
11274 break;
11275 case 5800: if (pw_max > 16) pw_max = 16;
11276 break;
11277 case 6300: if (pw_max > 16) pw_max = 16;
11278 break;
11279 case 7400: if (pw_max > 16) pw_max = 16;
11280 break;
11281 case 7500: if (pw_max > 8) pw_max = 8;
11282 break;
11283 case 7900: if (pw_max > 48) pw_max = 48;
11284 break;
11285 case 8500: if (pw_max > 8) pw_max = 8;
11286 break;
11287 case 8600: if (pw_max > 16) pw_max = 16;
11288 break;
11289 case 9710: pw_min = 5;
11290 pw_max = 5;
11291 break;
11292 case 9810: pw_min = 5;
11293 pw_max = 5;
11294 break;
11295 case 10410: pw_min = 5;
11296 pw_max = 5;
11297 break;
11298 case 10300: if (pw_max < 3) pw_min = 3;
11299 if (pw_max > 40) pw_max = 40;
11300 break;
11301 case 10500: if (pw_max < 3) pw_min = 3;
11302 if (pw_max > 40) pw_max = 40;
11303 break;
11304 case 10700: if (pw_max > 16) pw_max = 16;
11305 break;
11306 case 11300: if (pw_max > 40) pw_max = 40;
11307 break;
11308 case 11600: if (pw_max > 32) pw_max = 32;
11309 break;
11310 case 12500: if (pw_max > 20) pw_max = 20;
11311 break;
11312 case 12800: if (pw_max > 24) pw_max = 24;
11313 break;
11314 }
11315
11316 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11317 {
11318 switch (attack_kern)
11319 {
11320 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11321 break;
11322 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11323 break;
11324 }
11325 }
11326
11327 /**
11328 * charsets : keep them together for more easy maintainnce
11329 */
11330
11331 cs_t mp_sys[6] = { { { 0 }, 0 } };
11332 cs_t mp_usr[4] = { { { 0 }, 0 } };
11333
11334 mp_setup_sys (mp_sys);
11335
11336 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11337 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11338 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11339 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11340
11341 /**
11342 * load hashes, part I: find input mode, count hashes
11343 */
11344
11345 uint hashlist_mode = 0;
11346 uint hashlist_format = HLFMT_HASHCAT;
11347
11348 uint hashes_avail = 0;
11349
11350 if (benchmark == 0)
11351 {
11352 struct stat f;
11353
11354 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11355
11356 if ((hash_mode == 2500) ||
11357 (hash_mode == 5200) ||
11358 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11359 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11360 (hash_mode == 9000))
11361 {
11362 hashlist_mode = HL_MODE_ARG;
11363
11364 char *hashfile = myargv[optind];
11365
11366 data.hashfile = hashfile;
11367
11368 logfile_top_var_string ("target", hashfile);
11369 }
11370
11371 if (hashlist_mode == HL_MODE_ARG)
11372 {
11373 if (hash_mode == 2500)
11374 {
11375 struct stat st;
11376
11377 if (stat (data.hashfile, &st) == -1)
11378 {
11379 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11380
11381 return (-1);
11382 }
11383
11384 hashes_avail = st.st_size / sizeof (hccap_t);
11385 }
11386 else
11387 {
11388 hashes_avail = 1;
11389 }
11390 }
11391 else if (hashlist_mode == HL_MODE_FILE)
11392 {
11393 char *hashfile = myargv[optind];
11394
11395 data.hashfile = hashfile;
11396
11397 logfile_top_var_string ("target", hashfile);
11398
11399 FILE *fp = NULL;
11400
11401 if ((fp = fopen (hashfile, "rb")) == NULL)
11402 {
11403 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11404
11405 return (-1);
11406 }
11407
11408 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11409
11410 hashes_avail = count_lines (fp);
11411
11412 rewind (fp);
11413
11414 if (hashes_avail == 0)
11415 {
11416 log_error ("ERROR: hashfile is empty or corrupt");
11417
11418 fclose (fp);
11419
11420 return (-1);
11421 }
11422
11423 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11424
11425 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11426 {
11427 log_error ("ERROR: remove not supported in native hashfile-format mode");
11428
11429 fclose (fp);
11430
11431 return (-1);
11432 }
11433
11434 fclose (fp);
11435 }
11436 }
11437 else
11438 {
11439 hashlist_mode = HL_MODE_ARG;
11440
11441 hashes_avail = 1;
11442 }
11443
11444 if (hash_mode == 3000) hashes_avail *= 2;
11445
11446 data.hashlist_mode = hashlist_mode;
11447 data.hashlist_format = hashlist_format;
11448
11449 logfile_top_uint (hashlist_mode);
11450 logfile_top_uint (hashlist_format);
11451
11452 /**
11453 * load hashes, part II: allocate required memory, set pointers
11454 */
11455
11456 hash_t *hashes_buf = NULL;
11457 void *digests_buf = NULL;
11458 salt_t *salts_buf = NULL;
11459 void *esalts_buf = NULL;
11460
11461 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11462
11463 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11464
11465 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11466 {
11467 u32 hash_pos;
11468
11469 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11470 {
11471 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11472
11473 hashes_buf[hash_pos].hash_info = hash_info;
11474
11475 if (username && (remove || show || left))
11476 {
11477 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11478 }
11479
11480 if (benchmark)
11481 {
11482 hash_info->orighash = (char *) mymalloc (256);
11483 }
11484 }
11485 }
11486
11487 if (isSalted)
11488 {
11489 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11490
11491 if (esalt_size)
11492 {
11493 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11494 }
11495 }
11496 else
11497 {
11498 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11499 }
11500
11501 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11502 {
11503 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11504
11505 if (isSalted)
11506 {
11507 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11508
11509 if (esalt_size)
11510 {
11511 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11512 }
11513 }
11514 else
11515 {
11516 hashes_buf[hash_pos].salt = &salts_buf[0];
11517 }
11518 }
11519
11520 /**
11521 * load hashes, part III: parse hashes or generate them if benchmark
11522 */
11523
11524 uint hashes_cnt = 0;
11525
11526 if (benchmark == 0)
11527 {
11528 if (keyspace == 1)
11529 {
11530 // useless to read hash file for keyspace, cheat a little bit w/ optind
11531 }
11532 else if (hashes_avail == 0)
11533 {
11534 }
11535 else if (hashlist_mode == HL_MODE_ARG)
11536 {
11537 char *input_buf = myargv[optind];
11538
11539 uint input_len = strlen (input_buf);
11540
11541 logfile_top_var_string ("target", input_buf);
11542
11543 char *hash_buf = NULL;
11544 int hash_len = 0;
11545
11546 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11547
11548 bool hash_fmt_error = 0;
11549
11550 if (hash_len < 1) hash_fmt_error = 1;
11551 if (hash_buf == NULL) hash_fmt_error = 1;
11552
11553 if (hash_fmt_error)
11554 {
11555 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11556 }
11557 else
11558 {
11559 if (opts_type & OPTS_TYPE_HASH_COPY)
11560 {
11561 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11562
11563 hash_info_tmp->orighash = mystrdup (hash_buf);
11564 }
11565
11566 if (isSalted)
11567 {
11568 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11569 }
11570
11571 int parser_status = PARSER_OK;
11572
11573 if (hash_mode == 2500)
11574 {
11575 if (hash_len == 0)
11576 {
11577 log_error ("ERROR: hccap file not specified");
11578
11579 return (-1);
11580 }
11581
11582 hashlist_mode = HL_MODE_FILE;
11583
11584 data.hashlist_mode = hashlist_mode;
11585
11586 FILE *fp = fopen (hash_buf, "rb");
11587
11588 if (fp == NULL)
11589 {
11590 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11591
11592 return (-1);
11593 }
11594
11595 if (hashes_avail < 1)
11596 {
11597 log_error ("ERROR: hccap file is empty or corrupt");
11598
11599 fclose (fp);
11600
11601 return (-1);
11602 }
11603
11604 uint hccap_size = sizeof (hccap_t);
11605
11606 char *in = (char *) mymalloc (hccap_size);
11607
11608 while (!feof (fp))
11609 {
11610 int n = fread (in, hccap_size, 1, fp);
11611
11612 if (n != 1)
11613 {
11614 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11615
11616 break;
11617 }
11618
11619 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11620
11621 if (parser_status != PARSER_OK)
11622 {
11623 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11624
11625 continue;
11626 }
11627
11628 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11629
11630 if ((show == 1) || (left == 1))
11631 {
11632 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11633
11634 char *salt_ptr = (char *) tmp_salt->salt_buf;
11635
11636 int cur_pos = tmp_salt->salt_len;
11637 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11638
11639 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11640
11641 // do the appending task
11642
11643 snprintf (salt_ptr + cur_pos,
11644 rem_len,
11645 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11646 wpa->orig_mac1[0],
11647 wpa->orig_mac1[1],
11648 wpa->orig_mac1[2],
11649 wpa->orig_mac1[3],
11650 wpa->orig_mac1[4],
11651 wpa->orig_mac1[5],
11652 wpa->orig_mac2[0],
11653 wpa->orig_mac2[1],
11654 wpa->orig_mac2[2],
11655 wpa->orig_mac2[3],
11656 wpa->orig_mac2[4],
11657 wpa->orig_mac2[5]);
11658
11659 // memset () the remaining part of the salt
11660
11661 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11662 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11663
11664 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11665
11666 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11667 }
11668
11669 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);
11670 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);
11671
11672 hashes_cnt++;
11673 }
11674
11675 fclose (fp);
11676
11677 myfree (in);
11678 }
11679 else if (hash_mode == 3000)
11680 {
11681 if (hash_len == 32)
11682 {
11683 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11684
11685 hash_t *lm_hash_left = NULL;
11686
11687 if (parser_status == PARSER_OK)
11688 {
11689 lm_hash_left = &hashes_buf[hashes_cnt];
11690
11691 hashes_cnt++;
11692 }
11693 else
11694 {
11695 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11696 }
11697
11698 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11699
11700 hash_t *lm_hash_right = NULL;
11701
11702 if (parser_status == PARSER_OK)
11703 {
11704 lm_hash_right = &hashes_buf[hashes_cnt];
11705
11706 hashes_cnt++;
11707 }
11708 else
11709 {
11710 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11711 }
11712
11713 // show / left
11714
11715 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11716 {
11717 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);
11718 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);
11719 }
11720 }
11721 else
11722 {
11723 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11724
11725 if (parser_status == PARSER_OK)
11726 {
11727 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11728 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11729 }
11730
11731 if (parser_status == PARSER_OK)
11732 {
11733 hashes_cnt++;
11734 }
11735 else
11736 {
11737 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11738 }
11739 }
11740 }
11741 else
11742 {
11743 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11744
11745 if (parser_status == PARSER_OK)
11746 {
11747 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11748 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11749 }
11750
11751 if (parser_status == PARSER_OK)
11752 {
11753 hashes_cnt++;
11754 }
11755 else
11756 {
11757 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11758 }
11759 }
11760 }
11761 }
11762 else if (hashlist_mode == HL_MODE_FILE)
11763 {
11764 char *hashfile = data.hashfile;
11765
11766 FILE *fp;
11767
11768 if ((fp = fopen (hashfile, "rb")) == NULL)
11769 {
11770 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11771
11772 return (-1);
11773 }
11774
11775 uint line_num = 0;
11776
11777 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11778
11779 while (!feof (fp))
11780 {
11781 line_num++;
11782
11783 int line_len = fgetl (fp, line_buf);
11784
11785 if (line_len == 0) continue;
11786
11787 char *hash_buf = NULL;
11788 int hash_len = 0;
11789
11790 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11791
11792 bool hash_fmt_error = 0;
11793
11794 if (hash_len < 1) hash_fmt_error = 1;
11795 if (hash_buf == NULL) hash_fmt_error = 1;
11796
11797 if (hash_fmt_error)
11798 {
11799 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11800
11801 continue;
11802 }
11803
11804 if (username)
11805 {
11806 char *user_buf = NULL;
11807 int user_len = 0;
11808
11809 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11810
11811 if (remove || show)
11812 {
11813 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11814
11815 *user = (user_t *) mymalloc (sizeof (user_t));
11816
11817 user_t *user_ptr = *user;
11818
11819 if (user_buf != NULL)
11820 {
11821 user_ptr->user_name = mystrdup (user_buf);
11822 }
11823 else
11824 {
11825 user_ptr->user_name = mystrdup ("");
11826 }
11827
11828 user_ptr->user_len = user_len;
11829 }
11830 }
11831
11832 if (opts_type & OPTS_TYPE_HASH_COPY)
11833 {
11834 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11835
11836 hash_info_tmp->orighash = mystrdup (hash_buf);
11837 }
11838
11839 if (isSalted)
11840 {
11841 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11842 }
11843
11844 if (hash_mode == 3000)
11845 {
11846 if (hash_len == 32)
11847 {
11848 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11849
11850 if (parser_status < PARSER_GLOBAL_ZERO)
11851 {
11852 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11853
11854 continue;
11855 }
11856
11857 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11858
11859 hashes_cnt++;
11860
11861 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11862
11863 if (parser_status < PARSER_GLOBAL_ZERO)
11864 {
11865 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11866
11867 continue;
11868 }
11869
11870 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11871
11872 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);
11873
11874 hashes_cnt++;
11875
11876 // show / left
11877
11878 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);
11879 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);
11880 }
11881 else
11882 {
11883 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11884
11885 if (parser_status < PARSER_GLOBAL_ZERO)
11886 {
11887 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11888
11889 continue;
11890 }
11891
11892 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);
11893
11894 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11895 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11896
11897 hashes_cnt++;
11898 }
11899 }
11900 else
11901 {
11902 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11903
11904 if (parser_status < PARSER_GLOBAL_ZERO)
11905 {
11906 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11907
11908 continue;
11909 }
11910
11911 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);
11912
11913 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11914 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11915
11916 hashes_cnt++;
11917 }
11918 }
11919
11920 myfree (line_buf);
11921
11922 fclose (fp);
11923
11924 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11925
11926 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11927 }
11928 }
11929 else
11930 {
11931 if (isSalted)
11932 {
11933 hashes_buf[0].salt->salt_len = 8;
11934
11935 // special salt handling
11936
11937 switch (hash_mode)
11938 {
11939 case 1500: hashes_buf[0].salt->salt_len = 2;
11940 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11941 break;
11942 case 1731: hashes_buf[0].salt->salt_len = 4;
11943 break;
11944 case 2410: hashes_buf[0].salt->salt_len = 4;
11945 break;
11946 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11947 break;
11948 case 3100: hashes_buf[0].salt->salt_len = 1;
11949 break;
11950 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11951 break;
11952 case 5800: hashes_buf[0].salt->salt_len = 16;
11953 break;
11954 case 6800: hashes_buf[0].salt->salt_len = 32;
11955 break;
11956 case 8400: hashes_buf[0].salt->salt_len = 40;
11957 break;
11958 case 8800: hashes_buf[0].salt->salt_len = 16;
11959 break;
11960 case 8900: hashes_buf[0].salt->salt_len = 16;
11961 hashes_buf[0].salt->scrypt_N = 1024;
11962 hashes_buf[0].salt->scrypt_r = 1;
11963 hashes_buf[0].salt->scrypt_p = 1;
11964 break;
11965 case 9100: hashes_buf[0].salt->salt_len = 16;
11966 break;
11967 case 9300: hashes_buf[0].salt->salt_len = 14;
11968 hashes_buf[0].salt->scrypt_N = 16384;
11969 hashes_buf[0].salt->scrypt_r = 1;
11970 hashes_buf[0].salt->scrypt_p = 1;
11971 break;
11972 case 9400: hashes_buf[0].salt->salt_len = 16;
11973 break;
11974 case 9500: hashes_buf[0].salt->salt_len = 16;
11975 break;
11976 case 9600: hashes_buf[0].salt->salt_len = 16;
11977 break;
11978 case 9700: hashes_buf[0].salt->salt_len = 16;
11979 break;
11980 case 9710: hashes_buf[0].salt->salt_len = 16;
11981 break;
11982 case 9720: hashes_buf[0].salt->salt_len = 16;
11983 break;
11984 case 9800: hashes_buf[0].salt->salt_len = 16;
11985 break;
11986 case 9810: hashes_buf[0].salt->salt_len = 16;
11987 break;
11988 case 9820: hashes_buf[0].salt->salt_len = 16;
11989 break;
11990 case 10300: hashes_buf[0].salt->salt_len = 12;
11991 break;
11992 case 11500: hashes_buf[0].salt->salt_len = 4;
11993 break;
11994 case 11600: hashes_buf[0].salt->salt_len = 4;
11995 break;
11996 case 12400: hashes_buf[0].salt->salt_len = 4;
11997 break;
11998 case 12500: hashes_buf[0].salt->salt_len = 8;
11999 break;
12000 case 12600: hashes_buf[0].salt->salt_len = 64;
12001 break;
12002 }
12003
12004 // special esalt handling
12005
12006 switch (hash_mode)
12007 {
12008 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12009 break;
12010 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12011 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12012 break;
12013 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12014 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12015 break;
12016 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12017 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12018 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12019 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12020 break;
12021 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12022 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12023 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12024 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12025 break;
12026 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12027 break;
12028 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12029 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12030 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12031 break;
12032 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12033 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12034 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12035 break;
12036 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12037 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12038 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12039 break;
12040 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12041 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12042 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12043 break;
12044 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12045 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12046 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12047 break;
12048 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12049 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12050 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12051 break;
12052 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12053 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12054 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12055 break;
12056 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12057 break;
12058 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12059 break;
12060 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12061 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12062 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12063 break;
12064 }
12065 }
12066
12067 // set hashfile
12068
12069 switch (hash_mode)
12070 {
12071 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12072 break;
12073 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12074 break;
12075 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12076 break;
12077 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12078 break;
12079 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12080 break;
12081 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12082 break;
12083 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12084 break;
12085 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12086 break;
12087 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12088 break;
12089 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12090 break;
12091 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12092 break;
12093 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12094 break;
12095 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12096 break;
12097 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12098 break;
12099 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12100 break;
12101 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12102 break;
12103 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12104 break;
12105 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12106 break;
12107 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12108 break;
12109 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12110 break;
12111 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12112 break;
12113 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12114 break;
12115 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12116 break;
12117 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12118 break;
12119 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12120 break;
12121 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12122 break;
12123 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12124 break;
12125 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12126 break;
12127 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12128 break;
12129 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12130 break;
12131 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12132 break;
12133 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12134 break;
12135 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12136 break;
12137 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12138 break;
12139 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12140 break;
12141 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12142 break;
12143 }
12144
12145 // set default iterations
12146
12147 switch (hash_mode)
12148 {
12149 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12150 break;
12151 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12152 break;
12153 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12154 break;
12155 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12156 break;
12157 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12158 break;
12159 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12160 break;
12161 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12162 break;
12163 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12164 break;
12165 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12166 break;
12167 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12168 break;
12169 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12170 break;
12171 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12172 break;
12173 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12174 break;
12175 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12176 break;
12177 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12178 break;
12179 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12180 break;
12181 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12182 break;
12183 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12184 break;
12185 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12186 break;
12187 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12188 break;
12189 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12190 break;
12191 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12192 break;
12193 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12194 break;
12195 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12196 break;
12197 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12198 break;
12199 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12200 break;
12201 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12202 break;
12203 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12204 break;
12205 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12206 break;
12207 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12208 break;
12209 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12210 break;
12211 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12212 break;
12213 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12214 break;
12215 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12216 break;
12217 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12218 break;
12219 case 8900: hashes_buf[0].salt->salt_iter = 1;
12220 break;
12221 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12222 break;
12223 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12224 break;
12225 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12226 break;
12227 case 9300: hashes_buf[0].salt->salt_iter = 1;
12228 break;
12229 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12230 break;
12231 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12232 break;
12233 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12234 break;
12235 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12236 break;
12237 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12238 break;
12239 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12240 break;
12241 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12242 break;
12243 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12244 break;
12245 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12246 break;
12247 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12248 break;
12249 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12250 break;
12251 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12252 break;
12253 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12254 break;
12255 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12256 break;
12257 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12258 break;
12259 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12260 break;
12261 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12262 break;
12263 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12264 break;
12265 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12266 break;
12267 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12268 break;
12269 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12270 break;
12271 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12272 break;
12273 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12274 break;
12275 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12276 break;
12277 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12278 break;
12279 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12280 break;
12281 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12282 break;
12283 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12284 break;
12285 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12286 break;
12287 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12288 break;
12289 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12290 break;
12291 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12292 break;
12293 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12294 break;
12295 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12296 break;
12297 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12298 break;
12299 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12300 break;
12301 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12302 break;
12303 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12304 break;
12305 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12306 break;
12307 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12308 break;
12309 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12310 break;
12311 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12312 break;
12313 }
12314
12315 hashes_cnt = 1;
12316 }
12317
12318 if (show == 1 || left == 1)
12319 {
12320 for (uint i = 0; i < pot_cnt; i++)
12321 {
12322 pot_t *pot_ptr = &pot[i];
12323
12324 hash_t *hashes_buf = &pot_ptr->hash;
12325
12326 local_free (hashes_buf->digest);
12327
12328 if (isSalted)
12329 {
12330 local_free (hashes_buf->salt);
12331 }
12332 }
12333
12334 local_free (pot);
12335
12336 if (data.quiet == 0) log_info_nn ("");
12337
12338 return (0);
12339 }
12340
12341 if (keyspace == 0)
12342 {
12343 if (hashes_cnt == 0)
12344 {
12345 log_error ("ERROR: No hashes loaded");
12346
12347 return (-1);
12348 }
12349 }
12350
12351 /**
12352 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12353 */
12354
12355 if (data.outfile != NULL)
12356 {
12357 if (data.hashfile != NULL)
12358 {
12359 #ifdef _POSIX
12360 struct stat tmpstat_outfile;
12361 struct stat tmpstat_hashfile;
12362 #endif
12363
12364 #ifdef _WIN
12365 struct stat64 tmpstat_outfile;
12366 struct stat64 tmpstat_hashfile;
12367 #endif
12368
12369 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12370
12371 if (tmp_outfile_fp)
12372 {
12373 #ifdef _POSIX
12374 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12375 #endif
12376
12377 #ifdef _WIN
12378 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12379 #endif
12380
12381 fclose (tmp_outfile_fp);
12382 }
12383
12384 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12385
12386 if (tmp_hashfile_fp)
12387 {
12388 #ifdef _POSIX
12389 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12390 #endif
12391
12392 #ifdef _WIN
12393 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12394 #endif
12395
12396 fclose (tmp_hashfile_fp);
12397 }
12398
12399 if (tmp_outfile_fp && tmp_outfile_fp)
12400 {
12401 tmpstat_outfile.st_mode = 0;
12402 tmpstat_outfile.st_nlink = 0;
12403 tmpstat_outfile.st_uid = 0;
12404 tmpstat_outfile.st_gid = 0;
12405 tmpstat_outfile.st_rdev = 0;
12406 tmpstat_outfile.st_atime = 0;
12407
12408 tmpstat_hashfile.st_mode = 0;
12409 tmpstat_hashfile.st_nlink = 0;
12410 tmpstat_hashfile.st_uid = 0;
12411 tmpstat_hashfile.st_gid = 0;
12412 tmpstat_hashfile.st_rdev = 0;
12413 tmpstat_hashfile.st_atime = 0;
12414
12415 #ifdef _POSIX
12416 tmpstat_outfile.st_blksize = 0;
12417 tmpstat_outfile.st_blocks = 0;
12418
12419 tmpstat_hashfile.st_blksize = 0;
12420 tmpstat_hashfile.st_blocks = 0;
12421 #endif
12422
12423 #ifdef _POSIX
12424 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12425 {
12426 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12427
12428 return (-1);
12429 }
12430 #endif
12431
12432 #ifdef _WIN
12433 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12434 {
12435 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12436
12437 return (-1);
12438 }
12439 #endif
12440 }
12441 }
12442 }
12443
12444 /**
12445 * Remove duplicates
12446 */
12447
12448 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12449
12450 if (isSalted)
12451 {
12452 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12453 }
12454 else
12455 {
12456 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12457 }
12458
12459 uint hashes_cnt_orig = hashes_cnt;
12460
12461 hashes_cnt = 1;
12462
12463 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12464 {
12465 if (isSalted)
12466 {
12467 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12468 {
12469 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12470 }
12471 }
12472 else
12473 {
12474 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12475 }
12476
12477 if (hashes_pos > hashes_cnt)
12478 {
12479 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12480 }
12481
12482 hashes_cnt++;
12483 }
12484
12485 /**
12486 * Potfile removes
12487 */
12488
12489 uint potfile_remove_cracks = 0;
12490
12491 if (potfile_disable == 0)
12492 {
12493 hash_t hash_buf;
12494
12495 hash_buf.digest = mymalloc (dgst_size);
12496 hash_buf.salt = NULL;
12497 hash_buf.esalt = NULL;
12498 hash_buf.hash_info = NULL;
12499 hash_buf.cracked = 0;
12500
12501 if (isSalted)
12502 {
12503 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12504 }
12505
12506 if (esalt_size)
12507 {
12508 hash_buf.esalt = mymalloc (esalt_size);
12509 }
12510
12511 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12512
12513 // no solution for these special hash types (for instane because they use hashfile in output etc)
12514 if ((hash_mode != 5200) &&
12515 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12516 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12517 (hash_mode != 9000))
12518 {
12519 FILE *fp = fopen (potfile, "rb");
12520
12521 if (fp != NULL)
12522 {
12523 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12524
12525 // to be safe work with a copy (because of line_len loop, i etc)
12526 // moved up here because it's easier to handle continue case
12527 // it's just 64kb
12528
12529 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12530
12531 while (!feof (fp))
12532 {
12533 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12534
12535 if (ptr == NULL) break;
12536
12537 int line_len = strlen (line_buf);
12538
12539 if (line_len == 0) continue;
12540
12541 int iter = MAX_CUT_TRIES;
12542
12543 for (int i = line_len - 1; i && iter; i--, line_len--)
12544 {
12545 if (line_buf[i] != ':') continue;
12546
12547 if (isSalted)
12548 {
12549 memset (hash_buf.salt, 0, sizeof (salt_t));
12550 }
12551
12552 hash_t *found = NULL;
12553
12554 if (hash_mode == 6800)
12555 {
12556 if (i < 64) // 64 = 16 * uint in salt_buf[]
12557 {
12558 // manipulate salt_buf
12559 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12560
12561 hash_buf.salt->salt_len = i;
12562
12563 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12564 }
12565 }
12566 else if (hash_mode == 2500)
12567 {
12568 if (i < 64) // 64 = 16 * uint in salt_buf[]
12569 {
12570 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12571 // manipulate salt_buf
12572
12573 memcpy (line_buf_cpy, line_buf, i);
12574
12575 char *mac2_pos = strrchr (line_buf_cpy, ':');
12576
12577 if (mac2_pos == NULL) continue;
12578
12579 mac2_pos[0] = 0;
12580 mac2_pos++;
12581
12582 if (strlen (mac2_pos) != 12) continue;
12583
12584 char *mac1_pos = strrchr (line_buf_cpy, ':');
12585
12586 if (mac1_pos == NULL) continue;
12587
12588 mac1_pos[0] = 0;
12589 mac1_pos++;
12590
12591 if (strlen (mac1_pos) != 12) continue;
12592
12593 uint essid_length = mac1_pos - line_buf_cpy - 1;
12594
12595 // here we need the ESSID
12596 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12597
12598 hash_buf.salt->salt_len = essid_length;
12599
12600 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12601
12602 if (found)
12603 {
12604 wpa_t *wpa = (wpa_t *) found->esalt;
12605
12606 // compare hex string(s) vs binary MAC address(es)
12607
12608 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12609 {
12610 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12611 {
12612 found = NULL;
12613
12614 break;
12615 }
12616 }
12617
12618 // early skip ;)
12619 if (!found) continue;
12620
12621 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12622 {
12623 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12624 {
12625 found = NULL;
12626
12627 break;
12628 }
12629 }
12630 }
12631 }
12632 }
12633 else
12634 {
12635 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12636
12637 if (parser_status == PARSER_OK)
12638 {
12639 if (isSalted)
12640 {
12641 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12642 }
12643 else
12644 {
12645 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12646 }
12647 }
12648 }
12649
12650 if (found == NULL) continue;
12651
12652 if (!found->cracked) potfile_remove_cracks++;
12653
12654 found->cracked = 1;
12655
12656 if (found) break;
12657
12658 iter--;
12659 }
12660 }
12661
12662 myfree (line_buf_cpy);
12663
12664 myfree (line_buf);
12665
12666 fclose (fp);
12667 }
12668 }
12669
12670 if (esalt_size)
12671 {
12672 local_free (hash_buf.esalt);
12673 }
12674
12675 if (isSalted)
12676 {
12677 local_free (hash_buf.salt);
12678 }
12679
12680 local_free (hash_buf.digest);
12681 }
12682
12683 /**
12684 * Now generate all the buffers required for later
12685 */
12686
12687 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12688
12689 salt_t *salts_buf_new = NULL;
12690 void *esalts_buf_new = NULL;
12691
12692 if (isSalted)
12693 {
12694 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12695
12696 if (esalt_size)
12697 {
12698 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12699 }
12700 }
12701 else
12702 {
12703 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12704 }
12705
12706 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12707
12708 uint digests_cnt = hashes_cnt;
12709 uint digests_done = 0;
12710
12711 size_t size_digests = digests_cnt * dgst_size;
12712 size_t size_shown = digests_cnt * sizeof (uint);
12713
12714 uint *digests_shown = (uint *) mymalloc (size_shown);
12715 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12716
12717 uint salts_cnt = 0;
12718 uint salts_done = 0;
12719
12720 hashinfo_t **hash_info = NULL;
12721
12722 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12723 {
12724 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12725
12726 if (username && (remove || show))
12727 {
12728 uint user_pos;
12729
12730 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12731 {
12732 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12733
12734 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12735 }
12736 }
12737 }
12738
12739 uint *salts_shown = (uint *) mymalloc (size_shown);
12740
12741 salt_t *salt_buf;
12742
12743 {
12744 // copied from inner loop
12745
12746 salt_buf = &salts_buf_new[salts_cnt];
12747
12748 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12749
12750 if (esalt_size)
12751 {
12752 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12753 }
12754
12755 salt_buf->digests_cnt = 0;
12756 salt_buf->digests_done = 0;
12757 salt_buf->digests_offset = 0;
12758
12759 salts_cnt++;
12760 }
12761
12762 if (hashes_buf[0].cracked == 1)
12763 {
12764 digests_shown[0] = 1;
12765
12766 digests_done++;
12767
12768 salt_buf->digests_done++;
12769 }
12770
12771 salt_buf->digests_cnt++;
12772
12773 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12774
12775 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12776 {
12777 hash_info[0] = hashes_buf[0].hash_info;
12778 }
12779
12780 // copy from inner loop
12781
12782 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12783 {
12784 if (isSalted)
12785 {
12786 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12787 {
12788 salt_buf = &salts_buf_new[salts_cnt];
12789
12790 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12791
12792 if (esalt_size)
12793 {
12794 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12795 }
12796
12797 salt_buf->digests_cnt = 0;
12798 salt_buf->digests_done = 0;
12799 salt_buf->digests_offset = hashes_pos;
12800
12801 salts_cnt++;
12802 }
12803 }
12804
12805 if (hashes_buf[hashes_pos].cracked == 1)
12806 {
12807 digests_shown[hashes_pos] = 1;
12808
12809 digests_done++;
12810
12811 salt_buf->digests_done++;
12812 }
12813
12814 salt_buf->digests_cnt++;
12815
12816 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12817
12818 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12819 {
12820 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12821 }
12822 }
12823
12824 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12825 {
12826 salt_t *salt_buf = &salts_buf_new[salt_pos];
12827
12828 if (salt_buf->digests_done == salt_buf->digests_cnt)
12829 {
12830 salts_shown[salt_pos] = 1;
12831
12832 salts_done++;
12833 }
12834
12835 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12836 }
12837
12838 local_free (digests_buf);
12839 local_free (salts_buf);
12840 local_free (esalts_buf);
12841
12842 digests_buf = digests_buf_new;
12843 salts_buf = salts_buf_new;
12844 esalts_buf = esalts_buf_new;
12845
12846 local_free (hashes_buf);
12847
12848 /**
12849 * special modification not set from parser
12850 */
12851
12852 switch (hash_mode)
12853 {
12854 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12855 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12856 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12857 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12858 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12859 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12860 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12861 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12862 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12863 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12864 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12865 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12866 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12867 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12868 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12869 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12870 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12871 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12872 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12873 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12874 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12875 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12876 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12877 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12878 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12879 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12880 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12881 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12882 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12883 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12884 }
12885
12886 if (truecrypt_keyfiles)
12887 {
12888 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12889
12890 char *keyfiles = strdup (truecrypt_keyfiles);
12891
12892 char *keyfile = strtok (keyfiles, ",");
12893
12894 do
12895 {
12896 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12897
12898 } while ((keyfile = strtok (NULL, ",")) != NULL);
12899
12900 free (keyfiles);
12901 }
12902
12903 if (veracrypt_keyfiles)
12904 {
12905 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12906
12907 char *keyfiles = strdup (veracrypt_keyfiles);
12908
12909 char *keyfile = strtok (keyfiles, ",");
12910
12911 do
12912 {
12913 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12914
12915 } while ((keyfile = strtok (NULL, ",")) != NULL);
12916
12917 free (keyfiles);
12918 }
12919
12920 data.digests_cnt = digests_cnt;
12921 data.digests_done = digests_done;
12922 data.digests_buf = digests_buf;
12923 data.digests_shown = digests_shown;
12924 data.digests_shown_tmp = digests_shown_tmp;
12925
12926 data.salts_cnt = salts_cnt;
12927 data.salts_done = salts_done;
12928 data.salts_buf = salts_buf;
12929 data.salts_shown = salts_shown;
12930
12931 data.esalts_buf = esalts_buf;
12932 data.hash_info = hash_info;
12933
12934 /**
12935 * Automatic Optimizers
12936 */
12937
12938 if (salts_cnt == 1)
12939 opti_type |= OPTI_TYPE_SINGLE_SALT;
12940
12941 if (digests_cnt == 1)
12942 opti_type |= OPTI_TYPE_SINGLE_HASH;
12943
12944 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12945 opti_type |= OPTI_TYPE_NOT_ITERATED;
12946
12947 if (attack_mode == ATTACK_MODE_BF)
12948 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12949
12950 data.opti_type = opti_type;
12951
12952 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12953 {
12954 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12955 {
12956 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12957 {
12958 if (opts_type & OPTS_TYPE_ST_ADD80)
12959 {
12960 opts_type &= ~OPTS_TYPE_ST_ADD80;
12961 opts_type |= OPTS_TYPE_PT_ADD80;
12962 }
12963
12964 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12965 {
12966 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12967 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12968 }
12969
12970 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12971 {
12972 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12973 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12974 }
12975 }
12976 }
12977 }
12978
12979 /**
12980 * Some algorithm, like descrypt, can benefit from JIT compilation
12981 */
12982
12983 int force_jit_compilation = -1;
12984
12985 if (hash_mode == 8900)
12986 {
12987 force_jit_compilation = 8900;
12988 }
12989 else if (hash_mode == 9300)
12990 {
12991 force_jit_compilation = 8900;
12992 }
12993 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12994 {
12995 force_jit_compilation = 1500;
12996 }
12997
12998 /**
12999 * generate bitmap tables
13000 */
13001
13002 const uint bitmap_shift1 = 5;
13003 const uint bitmap_shift2 = 13;
13004
13005 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13006
13007 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13008 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13009 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13010 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13011 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13012 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13013 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13014 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13015
13016 uint bitmap_bits;
13017 uint bitmap_nums;
13018 uint bitmap_mask;
13019 uint bitmap_size;
13020
13021 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13022 {
13023 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13024
13025 bitmap_nums = 1 << bitmap_bits;
13026
13027 bitmap_mask = bitmap_nums - 1;
13028
13029 bitmap_size = bitmap_nums * sizeof (uint);
13030
13031 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13032
13033 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;
13034 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;
13035
13036 break;
13037 }
13038
13039 bitmap_nums = 1 << bitmap_bits;
13040
13041 bitmap_mask = bitmap_nums - 1;
13042
13043 bitmap_size = bitmap_nums * sizeof (uint);
13044
13045 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);
13046 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);
13047
13048 /**
13049 * prepare quick rule
13050 */
13051
13052 data.rule_buf_l = rule_buf_l;
13053 data.rule_buf_r = rule_buf_r;
13054
13055 int rule_len_l = (int) strlen (rule_buf_l);
13056 int rule_len_r = (int) strlen (rule_buf_r);
13057
13058 data.rule_len_l = rule_len_l;
13059 data.rule_len_r = rule_len_r;
13060
13061 /**
13062 * load rules
13063 */
13064
13065 uint *all_kernel_rules_cnt = NULL;
13066
13067 kernel_rule_t **all_kernel_rules_buf = NULL;
13068
13069 if (rp_files_cnt)
13070 {
13071 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13072
13073 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13074 }
13075
13076 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13077
13078 int rule_len = 0;
13079
13080 for (uint i = 0; i < rp_files_cnt; i++)
13081 {
13082 uint kernel_rules_avail = 0;
13083
13084 uint kernel_rules_cnt = 0;
13085
13086 kernel_rule_t *kernel_rules_buf = NULL;
13087
13088 char *rp_file = rp_files[i];
13089
13090 char in[BLOCK_SIZE] = { 0 };
13091 char out[BLOCK_SIZE] = { 0 };
13092
13093 FILE *fp = NULL;
13094
13095 uint rule_line = 0;
13096
13097 if ((fp = fopen (rp_file, "rb")) == NULL)
13098 {
13099 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13100
13101 return (-1);
13102 }
13103
13104 while (!feof (fp))
13105 {
13106 memset (rule_buf, 0, HCBUFSIZ);
13107
13108 rule_len = fgetl (fp, rule_buf);
13109
13110 rule_line++;
13111
13112 if (rule_len == 0) continue;
13113
13114 if (rule_buf[0] == '#') continue;
13115
13116 if (kernel_rules_avail == kernel_rules_cnt)
13117 {
13118 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13119
13120 kernel_rules_avail += INCR_RULES;
13121 }
13122
13123 memset (in, 0, BLOCK_SIZE);
13124 memset (out, 0, BLOCK_SIZE);
13125
13126 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13127
13128 if (result == -1)
13129 {
13130 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13131
13132 continue;
13133 }
13134
13135 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13136 {
13137 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13138
13139 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13140
13141 continue;
13142 }
13143
13144 /* its so slow
13145 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13146 {
13147 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13148
13149 continue;
13150 }
13151 */
13152
13153 kernel_rules_cnt++;
13154 }
13155
13156 fclose (fp);
13157
13158 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13159
13160 all_kernel_rules_buf[i] = kernel_rules_buf;
13161 }
13162
13163 /**
13164 * merge rules or automatic rule generator
13165 */
13166
13167 uint kernel_rules_cnt = 0;
13168
13169 kernel_rule_t *kernel_rules_buf = NULL;
13170
13171 if (attack_mode == ATTACK_MODE_STRAIGHT)
13172 {
13173 if (rp_files_cnt)
13174 {
13175 kernel_rules_cnt = 1;
13176
13177 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13178
13179 repeats[0] = kernel_rules_cnt;
13180
13181 for (uint i = 0; i < rp_files_cnt; i++)
13182 {
13183 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13184
13185 repeats[i + 1] = kernel_rules_cnt;
13186 }
13187
13188 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13189
13190 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13191
13192 for (uint i = 0; i < kernel_rules_cnt; i++)
13193 {
13194 uint out_pos = 0;
13195
13196 kernel_rule_t *out = &kernel_rules_buf[i];
13197
13198 for (uint j = 0; j < rp_files_cnt; j++)
13199 {
13200 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13201 uint in_pos;
13202
13203 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13204
13205 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13206 {
13207 if (out_pos == RULES_MAX - 1)
13208 {
13209 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13210
13211 break;
13212 }
13213
13214 out->cmds[out_pos] = in->cmds[in_pos];
13215 }
13216 }
13217 }
13218
13219 local_free (repeats);
13220 }
13221 else if (rp_gen)
13222 {
13223 uint kernel_rules_avail = 0;
13224
13225 while (kernel_rules_cnt < rp_gen)
13226 {
13227 if (kernel_rules_avail == kernel_rules_cnt)
13228 {
13229 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13230
13231 kernel_rules_avail += INCR_RULES;
13232 }
13233
13234 memset (rule_buf, 0, HCBUFSIZ);
13235
13236 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13237
13238 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13239
13240 kernel_rules_cnt++;
13241 }
13242 }
13243 }
13244
13245 myfree (rule_buf);
13246
13247 /**
13248 * generate NOP rules
13249 */
13250
13251 if (kernel_rules_cnt == 0)
13252 {
13253 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13254
13255 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13256
13257 kernel_rules_cnt++;
13258 }
13259
13260 data.kernel_rules_cnt = kernel_rules_cnt;
13261 data.kernel_rules_buf = kernel_rules_buf;
13262
13263 /**
13264 * OpenCL platforms: detect
13265 */
13266
13267 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13268 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13269
13270 cl_uint platforms_cnt = 0;
13271 cl_uint platform_devices_cnt = 0;
13272
13273 if (keyspace == 0)
13274 {
13275 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13276
13277 if (platforms_cnt == 0)
13278 {
13279 log_info ("");
13280 log_info ("ATTENTION! No OpenCL compatible platform found");
13281 log_info ("");
13282 log_info ("You're probably missing the OpenCL runtime installation");
13283 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13284 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13285 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13286 log_info ("");
13287
13288 return (-1);
13289 }
13290
13291 if (opencl_platforms_filter != (uint) -1)
13292 {
13293 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13294
13295 if (opencl_platforms_filter > platform_cnt_mask)
13296 {
13297 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13298
13299 return (-1);
13300 }
13301 }
13302 }
13303
13304 /**
13305 * OpenCL device types:
13306 * 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.
13307 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13308 */
13309
13310 if (opencl_device_types == NULL)
13311 {
13312 cl_device_type device_types_all = 0;
13313
13314 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13315 {
13316 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13317
13318 cl_platform_id platform = platforms[platform_id];
13319
13320 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13321
13322 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13323 {
13324 cl_device_id device = platform_devices[platform_devices_id];
13325
13326 cl_device_type device_type;
13327
13328 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13329
13330 device_types_all |= device_type;
13331 }
13332 }
13333
13334 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13335 {
13336 device_types_filter |= CL_DEVICE_TYPE_CPU;
13337 }
13338 }
13339
13340 /**
13341 * OpenCL devices: simply push all devices from all platforms into the same device array
13342 */
13343
13344 int need_adl = 0;
13345 int need_nvapi = 0;
13346 int need_nvml = 0;
13347
13348 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13349
13350 data.devices_param = devices_param;
13351
13352 uint devices_cnt = 0;
13353
13354 uint devices_active = 0;
13355
13356 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13357 {
13358 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13359
13360 cl_platform_id platform = platforms[platform_id];
13361
13362 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13363
13364 char platform_vendor[INFOSZ] = { 0 };
13365
13366 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13367
13368 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13369 // this causes trouble with vendor id based macros
13370 // we'll assign generic to those without special optimization available
13371
13372 cl_uint platform_vendor_id = 0;
13373
13374 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13375 {
13376 platform_vendor_id = VENDOR_ID_AMD;
13377 }
13378 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13379 {
13380 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13381 }
13382 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13383 {
13384 platform_vendor_id = VENDOR_ID_APPLE;
13385 }
13386 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13387 {
13388 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13389 }
13390 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13391 {
13392 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13393 }
13394 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13395 {
13396 platform_vendor_id = VENDOR_ID_MESA;
13397 }
13398 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13399 {
13400 platform_vendor_id = VENDOR_ID_NV;
13401 }
13402 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13403 {
13404 platform_vendor_id = VENDOR_ID_POCL;
13405 }
13406 else
13407 {
13408 platform_vendor_id = VENDOR_ID_GENERIC;
13409 }
13410
13411 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13412 {
13413 size_t param_value_size = 0;
13414
13415 const uint device_id = devices_cnt;
13416
13417 hc_device_param_t *device_param = &data.devices_param[device_id];
13418
13419 device_param->platform_vendor_id = platform_vendor_id;
13420
13421 device_param->device = platform_devices[platform_devices_id];
13422
13423 device_param->device_id = device_id;
13424
13425 device_param->platform_devices_id = platform_devices_id;
13426
13427 // device_type
13428
13429 cl_device_type device_type;
13430
13431 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13432
13433 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13434
13435 device_param->device_type = device_type;
13436
13437 // device_name
13438
13439 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13440
13441 char *device_name = (char *) mymalloc (param_value_size);
13442
13443 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13444
13445 device_param->device_name = device_name;
13446
13447 // device_vendor
13448
13449 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13450
13451 char *device_vendor = (char *) mymalloc (param_value_size);
13452
13453 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13454
13455 device_param->device_vendor = device_vendor;
13456
13457 cl_uint device_vendor_id = 0;
13458
13459 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13460 {
13461 device_vendor_id = VENDOR_ID_AMD;
13462 }
13463 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13464 {
13465 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13466 }
13467 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13468 {
13469 device_vendor_id = VENDOR_ID_APPLE;
13470 }
13471 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13472 {
13473 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13474 }
13475 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13476 {
13477 device_vendor_id = VENDOR_ID_INTEL_SDK;
13478 }
13479 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13480 {
13481 device_vendor_id = VENDOR_ID_MESA;
13482 }
13483 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13484 {
13485 device_vendor_id = VENDOR_ID_NV;
13486 }
13487 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13488 {
13489 device_vendor_id = VENDOR_ID_POCL;
13490 }
13491 else
13492 {
13493 device_vendor_id = VENDOR_ID_GENERIC;
13494 }
13495
13496 device_param->device_vendor_id = device_vendor_id;
13497
13498 // tuning db
13499
13500 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13501
13502 // device_version
13503
13504 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13505
13506 char *device_version = (char *) mymalloc (param_value_size);
13507
13508 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13509
13510 device_param->device_version = device_version;
13511
13512 // device_opencl_version
13513
13514 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13515
13516 char *device_opencl_version = (char *) mymalloc (param_value_size);
13517
13518 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13519
13520 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13521
13522 myfree (device_opencl_version);
13523
13524 // vector_width
13525
13526 cl_uint vector_width;
13527
13528 if (opencl_vector_width_chgd == 0)
13529 {
13530 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13531 {
13532 if (opti_type & OPTI_TYPE_USES_BITS_64)
13533 {
13534 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13535 }
13536 else
13537 {
13538 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13539 }
13540 }
13541 else
13542 {
13543 vector_width = (cl_uint) tuningdb_entry->vector_width;
13544 }
13545 }
13546 else
13547 {
13548 vector_width = opencl_vector_width;
13549 }
13550
13551 if (vector_width > 16) vector_width = 16;
13552
13553 device_param->vector_width = vector_width;
13554
13555 // max_compute_units
13556
13557 cl_uint device_processors;
13558
13559 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13560
13561 device_param->device_processors = device_processors;
13562
13563 // device_maxmem_alloc
13564 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13565
13566 cl_ulong device_maxmem_alloc;
13567
13568 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13569
13570 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13571
13572 // device_global_mem
13573
13574 cl_ulong device_global_mem;
13575
13576 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13577
13578 device_param->device_global_mem = device_global_mem;
13579
13580 // max_work_group_size
13581
13582 size_t device_maxworkgroup_size;
13583
13584 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13585
13586 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13587
13588 // max_clock_frequency
13589
13590 cl_uint device_maxclock_frequency;
13591
13592 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13593
13594 device_param->device_maxclock_frequency = device_maxclock_frequency;
13595
13596 // device_endian_little
13597
13598 cl_bool device_endian_little;
13599
13600 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13601
13602 if (device_endian_little == CL_FALSE)
13603 {
13604 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13605
13606 device_param->skipped = 1;
13607 }
13608
13609 // device_available
13610
13611 cl_bool device_available;
13612
13613 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13614
13615 if (device_available == CL_FALSE)
13616 {
13617 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13618
13619 device_param->skipped = 1;
13620 }
13621
13622 // device_compiler_available
13623
13624 cl_bool device_compiler_available;
13625
13626 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13627
13628 if (device_compiler_available == CL_FALSE)
13629 {
13630 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13631
13632 device_param->skipped = 1;
13633 }
13634
13635 // device_execution_capabilities
13636
13637 cl_device_exec_capabilities device_execution_capabilities;
13638
13639 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13640
13641 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13642 {
13643 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13644
13645 device_param->skipped = 1;
13646 }
13647
13648 // device_extensions
13649
13650 size_t device_extensions_size;
13651
13652 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13653
13654 char *device_extensions = mymalloc (device_extensions_size + 1);
13655
13656 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13657
13658 if (strstr (device_extensions, "base_atomics") == 0)
13659 {
13660 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13661
13662 device_param->skipped = 1;
13663 }
13664
13665 if (strstr (device_extensions, "byte_addressable_store") == 0)
13666 {
13667 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13668
13669 device_param->skipped = 1;
13670 }
13671
13672 myfree (device_extensions);
13673
13674 // device_local_mem_size
13675
13676 cl_ulong device_local_mem_size;
13677
13678 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13679
13680 if (device_local_mem_size < 32768)
13681 {
13682 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13683
13684 device_param->skipped = 1;
13685 }
13686
13687 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13688 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13689 // This results in both utilizing it for 50%
13690 // However, Intel has much better SIMD control over their own hardware
13691 // It makes sense to give them full control over their own hardware
13692
13693 if (device_type & CL_DEVICE_TYPE_CPU)
13694 {
13695 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13696 {
13697 if (data.force == 0)
13698 {
13699 if (algorithm_pos == 0)
13700 {
13701 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
13702 log_info (" You can use --force to override this but do not post error reports if you do so");
13703 }
13704
13705 device_param->skipped = 1;
13706 }
13707 }
13708 }
13709
13710 // skipped
13711
13712 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13713 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13714
13715 // driver_version
13716
13717 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13718
13719 char *driver_version = (char *) mymalloc (param_value_size);
13720
13721 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13722
13723 device_param->driver_version = driver_version;
13724
13725 // device_name_chksum
13726
13727 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13728
13729 #if __x86_64__
13730 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);
13731 #else
13732 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);
13733 #endif
13734
13735 uint device_name_digest[4] = { 0 };
13736
13737 md5_64 ((uint *) device_name_chksum, device_name_digest);
13738
13739 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13740
13741 device_param->device_name_chksum = device_name_chksum;
13742
13743 // device_processor_cores
13744
13745 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
13746 {
13747 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
13748 {
13749 need_adl = 1;
13750 }
13751
13752 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
13753 {
13754 need_nvml = 1;
13755
13756 #ifdef _WIN
13757 need_nvapi = 1;
13758 #endif
13759 }
13760 }
13761
13762 // device_processor_cores
13763
13764 if (device_type & CL_DEVICE_TYPE_CPU)
13765 {
13766 cl_uint device_processor_cores = 1;
13767
13768 device_param->device_processor_cores = device_processor_cores;
13769 }
13770
13771 if (device_type & CL_DEVICE_TYPE_GPU)
13772 {
13773 if (device_vendor_id == VENDOR_ID_AMD)
13774 {
13775 cl_uint device_processor_cores = 0;
13776
13777 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13778
13779 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13780
13781 device_param->device_processor_cores = device_processor_cores;
13782 }
13783 else if (device_vendor_id == VENDOR_ID_NV)
13784 {
13785 cl_uint kernel_exec_timeout = 0;
13786
13787 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13788
13789 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13790
13791 device_param->kernel_exec_timeout = kernel_exec_timeout;
13792
13793 cl_uint device_processor_cores = 0;
13794
13795 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13796
13797 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13798
13799 device_param->device_processor_cores = device_processor_cores;
13800
13801 cl_uint sm_minor = 0;
13802 cl_uint sm_major = 0;
13803
13804 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13805 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13806
13807 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13808 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13809
13810 device_param->sm_minor = sm_minor;
13811 device_param->sm_major = sm_major;
13812 }
13813 else
13814 {
13815 cl_uint device_processor_cores = 1;
13816
13817 device_param->device_processor_cores = device_processor_cores;
13818 }
13819 }
13820
13821 // display results
13822
13823 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13824 {
13825 if (machine_readable == 0)
13826 {
13827 if (device_param->skipped == 0)
13828 {
13829 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13830 device_id + 1,
13831 device_name,
13832 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13833 (unsigned int) (device_global_mem / 1024 / 1024),
13834 (unsigned int) device_processors);
13835 }
13836 else
13837 {
13838 log_info ("Device #%u: %s, skipped",
13839 device_id + 1,
13840 device_name);
13841 }
13842 }
13843 }
13844
13845 // common driver check
13846
13847 if (device_param->skipped == 0)
13848 {
13849 if (device_type & CL_DEVICE_TYPE_GPU)
13850 {
13851 if (platform_vendor_id == VENDOR_ID_AMD)
13852 {
13853 int catalyst_check = (force == 1) ? 0 : 1;
13854
13855 int catalyst_warn = 0;
13856
13857 int catalyst_broken = 0;
13858
13859 if (catalyst_check == 1)
13860 {
13861 catalyst_warn = 1;
13862
13863 // v14.9 and higher
13864 if (atoi (device_param->driver_version) >= 1573)
13865 {
13866 catalyst_warn = 0;
13867 }
13868
13869 catalyst_check = 0;
13870 }
13871
13872 if (catalyst_broken == 1)
13873 {
13874 log_info ("");
13875 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13876 log_info ("It will pass over cracked hashes and does not report them as cracked");
13877 log_info ("You are STRONGLY encouraged not to use it");
13878 log_info ("You can use --force to override this but do not post error reports if you do so");
13879 log_info ("");
13880
13881 return (-1);
13882 }
13883
13884 if (catalyst_warn == 1)
13885 {
13886 log_info ("");
13887 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13888 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13889 log_info ("See hashcat's homepage for official supported catalyst drivers");
13890 #ifdef _WIN
13891 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13892 #endif
13893 log_info ("You can use --force to override this but do not post error reports if you do so");
13894 log_info ("");
13895
13896 return (-1);
13897 }
13898 }
13899 else if (platform_vendor_id == VENDOR_ID_NV)
13900 {
13901 if (device_param->kernel_exec_timeout != 0)
13902 {
13903 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);
13904 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13905 }
13906 }
13907 }
13908
13909 /* turns out pocl still creates segfaults (because of llvm)
13910 if (device_type & CL_DEVICE_TYPE_CPU)
13911 {
13912 if (platform_vendor_id == VENDOR_ID_AMD)
13913 {
13914 if (force == 0)
13915 {
13916 log_info ("");
13917 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13918 log_info ("You are STRONGLY encouraged not to use it");
13919 log_info ("You can use --force to override this but do not post error reports if you do so");
13920 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13921 log_info ("");
13922
13923 return (-1);
13924 }
13925 }
13926 }
13927 */
13928
13929 /**
13930 * kernel accel and loops tuning db adjustment
13931 */
13932
13933 device_param->kernel_accel_min = 1;
13934 device_param->kernel_accel_max = 1024;
13935
13936 device_param->kernel_loops_min = 1;
13937 device_param->kernel_loops_max = 1024;
13938
13939 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13940
13941 if (tuningdb_entry)
13942 {
13943 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13944 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13945
13946 if (_kernel_accel)
13947 {
13948 device_param->kernel_accel_min = _kernel_accel;
13949 device_param->kernel_accel_max = _kernel_accel;
13950 }
13951
13952 if (_kernel_loops)
13953 {
13954 if (workload_profile == 1)
13955 {
13956 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13957 }
13958 else if (workload_profile == 2)
13959 {
13960 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13961 }
13962
13963 device_param->kernel_loops_min = _kernel_loops;
13964 device_param->kernel_loops_max = _kernel_loops;
13965 }
13966 }
13967
13968 // commandline parameters overwrite tuningdb entries
13969
13970 if (kernel_accel)
13971 {
13972 device_param->kernel_accel_min = kernel_accel;
13973 device_param->kernel_accel_max = kernel_accel;
13974 }
13975
13976 if (kernel_loops)
13977 {
13978 device_param->kernel_loops_min = kernel_loops;
13979 device_param->kernel_loops_max = kernel_loops;
13980 }
13981
13982 /**
13983 * activate device
13984 */
13985
13986 devices_active++;
13987 }
13988
13989 // next please
13990
13991 devices_cnt++;
13992 }
13993 }
13994
13995 if (keyspace == 0 && devices_active == 0)
13996 {
13997 log_error ("ERROR: No devices found/left");
13998
13999 return (-1);
14000 }
14001
14002 // 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)
14003
14004 if (devices_filter != (uint) -1)
14005 {
14006 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14007
14008 if (devices_filter > devices_cnt_mask)
14009 {
14010 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14011
14012 return (-1);
14013 }
14014 }
14015
14016 data.devices_cnt = devices_cnt;
14017
14018 data.devices_active = devices_active;
14019
14020 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14021 {
14022 if (machine_readable == 0)
14023 {
14024 log_info ("");
14025 }
14026 }
14027
14028 /**
14029 * HM devices: init
14030 */
14031
14032 #ifdef HAVE_HWMON
14033 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14034 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14035 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14036
14037 if (gpu_temp_disable == 0)
14038 {
14039 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14040 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14041 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14042
14043 data.hm_adl = NULL;
14044 data.hm_nvapi = NULL;
14045 data.hm_nvml = NULL;
14046
14047 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14048 {
14049 data.hm_nvml = nvml;
14050 }
14051
14052 if (data.hm_nvml)
14053 {
14054 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14055 {
14056 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14057
14058 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14059
14060 int tmp_out = 0;
14061
14062 for (int i = 0; i < tmp_in; i++)
14063 {
14064 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14065 }
14066
14067 for (int i = 0; i < tmp_out; i++)
14068 {
14069 unsigned int speed;
14070
14071 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14072
14073 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14074
14075 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14076 }
14077 }
14078 }
14079
14080 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14081 {
14082 data.hm_nvapi = nvapi;
14083 }
14084
14085 if (data.hm_nvapi)
14086 {
14087 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14088 {
14089 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14090
14091 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14092
14093 int tmp_out = 0;
14094
14095 for (int i = 0; i < tmp_in; i++)
14096 {
14097 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14098 }
14099 }
14100 }
14101
14102 if ((need_adl == 1) && (adl_init (adl) == 0))
14103 {
14104 data.hm_adl = adl;
14105 }
14106
14107 if (data.hm_adl)
14108 {
14109 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14110 {
14111 // total number of adapters
14112
14113 int hm_adapters_num;
14114
14115 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14116
14117 // adapter info
14118
14119 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14120
14121 if (lpAdapterInfo == NULL) return (-1);
14122
14123 // get a list (of ids of) valid/usable adapters
14124
14125 int num_adl_adapters = 0;
14126
14127 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14128
14129 if (num_adl_adapters > 0)
14130 {
14131 hc_thread_mutex_lock (mux_adl);
14132
14133 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14134
14135 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14136
14137 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14138 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14139
14140 hc_thread_mutex_unlock (mux_adl);
14141 }
14142
14143 myfree (valid_adl_device_list);
14144 myfree (lpAdapterInfo);
14145 }
14146 }
14147
14148 if (data.hm_adl == NULL && data.hm_nvml == NULL)
14149 {
14150 gpu_temp_disable = 1;
14151 }
14152 }
14153
14154 /**
14155 * OpenCL devices: allocate buffer for device specific information
14156 */
14157
14158 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14159 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14160
14161 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14162
14163 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14164
14165 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14166
14167 /**
14168 * User-defined GPU temp handling
14169 */
14170
14171 if (gpu_temp_disable == 1)
14172 {
14173 gpu_temp_abort = 0;
14174 gpu_temp_retain = 0;
14175 }
14176
14177 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14178 {
14179 if (gpu_temp_abort < gpu_temp_retain)
14180 {
14181 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14182
14183 return (-1);
14184 }
14185 }
14186
14187 data.gpu_temp_disable = gpu_temp_disable;
14188 data.gpu_temp_abort = gpu_temp_abort;
14189 data.gpu_temp_retain = gpu_temp_retain;
14190 #endif
14191
14192 /**
14193 * enable custom signal handler(s)
14194 */
14195
14196 if (benchmark == 0)
14197 {
14198 hc_signal (sigHandler_default);
14199 }
14200 else
14201 {
14202 hc_signal (sigHandler_benchmark);
14203 }
14204
14205 /**
14206 * inform the user
14207 */
14208
14209 if (data.quiet == 0)
14210 {
14211 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14212
14213 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);
14214
14215 if (attack_mode == ATTACK_MODE_STRAIGHT)
14216 {
14217 log_info ("Rules: %u", kernel_rules_cnt);
14218 }
14219
14220 if (opti_type)
14221 {
14222 log_info ("Applicable Optimizers:");
14223
14224 for (uint i = 0; i < 32; i++)
14225 {
14226 const uint opti_bit = 1u << i;
14227
14228 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14229 }
14230 }
14231
14232 /**
14233 * Watchdog and Temperature balance
14234 */
14235
14236 #ifdef HAVE_HWMON
14237 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
14238 {
14239 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14240 }
14241
14242 if (gpu_temp_abort == 0)
14243 {
14244 log_info ("Watchdog: Temperature abort trigger disabled");
14245 }
14246 else
14247 {
14248 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14249 }
14250
14251 if (gpu_temp_retain == 0)
14252 {
14253 log_info ("Watchdog: Temperature retain trigger disabled");
14254 }
14255 else
14256 {
14257 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14258 }
14259
14260 if (data.quiet == 0) log_info ("");
14261 #endif
14262 }
14263
14264 #ifdef HAVE_HWMON
14265
14266 /**
14267 * HM devices: copy
14268 */
14269
14270 if (gpu_temp_disable == 0)
14271 {
14272 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14273 {
14274 hc_device_param_t *device_param = &data.devices_param[device_id];
14275
14276 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14277
14278 if (device_param->skipped) continue;
14279
14280 const uint platform_devices_id = device_param->platform_devices_id;
14281
14282 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14283 {
14284 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14285 data.hm_device[device_id].nvapi = 0;
14286 data.hm_device[device_id].nvml = 0;
14287 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14288 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14289 data.hm_device[device_id].fan_set_supported = hm_adapters_adl[platform_devices_id].fan_set_supported;
14290 }
14291
14292 if (device_param->device_vendor_id == VENDOR_ID_NV)
14293 {
14294 data.hm_device[device_id].adl = 0;
14295 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14296 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14297 data.hm_device[device_id].od_version = 0;
14298 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14299 data.hm_device[device_id].fan_set_supported = 0;
14300 }
14301 }
14302 }
14303
14304 /**
14305 * powertune on user request
14306 */
14307
14308 if (powertune_enable == 1)
14309 {
14310 hc_thread_mutex_lock (mux_adl);
14311
14312 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14313 {
14314 hc_device_param_t *device_param = &data.devices_param[device_id];
14315
14316 if (device_param->skipped) continue;
14317
14318 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14319 {
14320 /**
14321 * Temporary fix:
14322 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14323 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14324 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14325 * Driver / ADL bug?
14326 */
14327
14328 if (data.hm_device[device_id].od_version == 6)
14329 {
14330 int ADL_rc;
14331
14332 // check powertune capabilities first, if not available then skip device
14333
14334 int powertune_supported = 0;
14335
14336 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14337 {
14338 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14339
14340 return (-1);
14341 }
14342
14343 // first backup current value, we will restore it later
14344
14345 if (powertune_supported != 0)
14346 {
14347 // powercontrol settings
14348
14349 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14350
14351 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14352 {
14353 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14354 }
14355
14356 if (ADL_rc != ADL_OK)
14357 {
14358 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14359
14360 return (-1);
14361 }
14362
14363 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14364 {
14365 log_error ("ERROR: Failed to set new ADL PowerControl values");
14366
14367 return (-1);
14368 }
14369
14370 // clocks
14371
14372 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14373
14374 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14375
14376 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14377 {
14378 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14379
14380 return (-1);
14381 }
14382
14383 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14384
14385 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14386
14387 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14388 {
14389 log_error ("ERROR: Failed to get ADL device capabilities");
14390
14391 return (-1);
14392 }
14393
14394 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14395 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14396
14397 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14398 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14399
14400 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14401 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14402
14403 // warning if profile has too low max values
14404
14405 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14406 {
14407 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14408 }
14409
14410 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14411 {
14412 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14413 }
14414
14415 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14416
14417 performance_state->iNumberOfPerformanceLevels = 2;
14418
14419 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14420 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14421 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14422 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14423
14424 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14425 {
14426 log_info ("ERROR: Failed to set ADL performance state");
14427
14428 return (-1);
14429 }
14430
14431 local_free (performance_state);
14432 }
14433
14434 // set powertune value only
14435
14436 if (powertune_supported != 0)
14437 {
14438 // powertune set
14439 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14440
14441 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14442 {
14443 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14444
14445 return (-1);
14446 }
14447
14448 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14449 {
14450 log_error ("ERROR: Failed to set new ADL PowerControl values");
14451
14452 return (-1);
14453 }
14454 }
14455 }
14456 }
14457
14458 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14459 {
14460 // first backup current value, we will restore it later
14461
14462 unsigned int limit;
14463
14464 int powertune_supported = 0;
14465
14466 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14467 {
14468 powertune_supported = 1;
14469 }
14470
14471 // if backup worked, activate the maximum allowed
14472
14473 if (powertune_supported != 0)
14474 {
14475 unsigned int minLimit;
14476 unsigned int maxLimit;
14477
14478 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14479 {
14480 if (maxLimit > 0)
14481 {
14482 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14483 {
14484 // now we can be sure we need to reset later
14485
14486 nvml_power_limit[device_id] = limit;
14487 }
14488 }
14489 }
14490 }
14491 }
14492 }
14493
14494 hc_thread_mutex_unlock (mux_adl);
14495 }
14496
14497 #endif // HAVE_HWMON
14498
14499 #ifdef DEBUG
14500 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14501 #endif
14502
14503 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14504
14505 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14506 {
14507 /**
14508 * host buffer
14509 */
14510
14511 hc_device_param_t *device_param = &data.devices_param[device_id];
14512
14513 if (device_param->skipped) continue;
14514
14515 /**
14516 * device properties
14517 */
14518
14519 const char *device_name_chksum = device_param->device_name_chksum;
14520 const u32 device_processors = device_param->device_processors;
14521 const u32 device_processor_cores = device_param->device_processor_cores;
14522
14523 /**
14524 * create context for each device
14525 */
14526
14527 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14528
14529 /**
14530 * create command-queue
14531 */
14532
14533 // not supported with NV
14534 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14535
14536 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14537
14538 /**
14539 * kernel threads: some algorithms need a fixed kernel-threads count
14540 * because of shared memory usage or bitslice
14541 * there needs to be some upper limit, otherwise there's too much overhead
14542 */
14543
14544 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14545
14546 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14547 {
14548 kernel_threads = KERNEL_THREADS_MAX_CPU;
14549 }
14550
14551 if (hash_mode == 1500) kernel_threads = 64; // DES
14552 if (hash_mode == 3000) kernel_threads = 64; // DES
14553 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14554 if (hash_mode == 7500) kernel_threads = 64; // RC4
14555 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14556 if (hash_mode == 9700) kernel_threads = 64; // RC4
14557 if (hash_mode == 9710) kernel_threads = 64; // RC4
14558 if (hash_mode == 9800) kernel_threads = 64; // RC4
14559 if (hash_mode == 9810) kernel_threads = 64; // RC4
14560 if (hash_mode == 10400) kernel_threads = 64; // RC4
14561 if (hash_mode == 10410) kernel_threads = 64; // RC4
14562 if (hash_mode == 10500) kernel_threads = 64; // RC4
14563 if (hash_mode == 13100) kernel_threads = 64; // RC4
14564
14565 device_param->kernel_threads = kernel_threads;
14566
14567 device_param->hardware_power = device_processors * kernel_threads;
14568
14569 /**
14570 * create input buffers on device : calculate size of fixed memory buffers
14571 */
14572
14573 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14574 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14575
14576 device_param->size_root_css = size_root_css;
14577 device_param->size_markov_css = size_markov_css;
14578
14579 size_t size_results = sizeof (uint);
14580
14581 device_param->size_results = size_results;
14582
14583 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14584 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14585
14586 size_t size_plains = digests_cnt * sizeof (plain_t);
14587 size_t size_salts = salts_cnt * sizeof (salt_t);
14588 size_t size_esalts = salts_cnt * esalt_size;
14589
14590 device_param->size_plains = size_plains;
14591 device_param->size_digests = size_digests;
14592 device_param->size_shown = size_shown;
14593 device_param->size_salts = size_salts;
14594
14595 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14596 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14597 size_t size_tm = 32 * sizeof (bs_word_t);
14598
14599 // scryptV stuff
14600
14601 size_t size_scryptV = 1;
14602
14603 if ((hash_mode == 8900) || (hash_mode == 9300))
14604 {
14605 uint tmto_start = 0;
14606 uint tmto_stop = 10;
14607
14608 if (scrypt_tmto)
14609 {
14610 tmto_start = scrypt_tmto;
14611 }
14612 else
14613 {
14614 // in case the user did not specify the tmto manually
14615 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14616 // but set the lower end only in case the user has a device with too less memory
14617
14618 if (hash_mode == 8900)
14619 {
14620 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14621 {
14622 tmto_start = 1;
14623 }
14624 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14625 {
14626 tmto_start = 2;
14627 }
14628 }
14629 else if (hash_mode == 9300)
14630 {
14631 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14632 {
14633 tmto_start = 2;
14634 }
14635 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14636 {
14637 tmto_start = 2;
14638 }
14639 }
14640 }
14641
14642 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14643 {
14644 // TODO: in theory the following calculation needs to be done per salt, not global
14645 // we assume all hashes have the same scrypt settings
14646
14647 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14648
14649 size_scryptV /= 1 << tmto;
14650
14651 size_scryptV *= device_processors * device_processor_cores;
14652
14653 if (size_scryptV > device_param->device_maxmem_alloc)
14654 {
14655 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14656
14657 continue;
14658 }
14659
14660 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14661 {
14662 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14663 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14664 }
14665
14666 break;
14667 }
14668
14669 if (data.salts_buf[0].scrypt_phy == 0)
14670 {
14671 log_error ("ERROR: can't allocate enough device memory");
14672
14673 return -1;
14674 }
14675
14676 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14677 }
14678
14679 /**
14680 * some algorithms need a fixed kernel-loops count
14681 */
14682
14683 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
14684 {
14685 const u32 kernel_loops_fixed = 1024;
14686
14687 device_param->kernel_loops_min = kernel_loops_fixed;
14688 device_param->kernel_loops_max = kernel_loops_fixed;
14689 }
14690
14691 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
14692 {
14693 const u32 kernel_loops_fixed = 1024;
14694
14695 device_param->kernel_loops_min = kernel_loops_fixed;
14696 device_param->kernel_loops_max = kernel_loops_fixed;
14697 }
14698
14699 if (hash_mode == 8900)
14700 {
14701 const u32 kernel_loops_fixed = 1;
14702
14703 device_param->kernel_loops_min = kernel_loops_fixed;
14704 device_param->kernel_loops_max = kernel_loops_fixed;
14705 }
14706
14707 if (hash_mode == 9300)
14708 {
14709 const u32 kernel_loops_fixed = 1;
14710
14711 device_param->kernel_loops_min = kernel_loops_fixed;
14712 device_param->kernel_loops_max = kernel_loops_fixed;
14713 }
14714
14715 if (hash_mode == 12500)
14716 {
14717 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14718
14719 device_param->kernel_loops_min = kernel_loops_fixed;
14720 device_param->kernel_loops_max = kernel_loops_fixed;
14721 }
14722
14723 /**
14724 * some algorithms have a maximum kernel-loops count
14725 */
14726
14727 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14728 {
14729 u32 innerloop_cnt = 0;
14730
14731 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14732 {
14733 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14734 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14735 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14736 }
14737 else
14738 {
14739 innerloop_cnt = data.salts_buf[0].salt_iter;
14740 }
14741
14742 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14743 (innerloop_cnt <= device_param->kernel_loops_max))
14744 {
14745 device_param->kernel_loops_max = innerloop_cnt;
14746 }
14747 }
14748
14749 u32 kernel_accel_min = device_param->kernel_accel_min;
14750 u32 kernel_accel_max = device_param->kernel_accel_max;
14751
14752 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14753
14754 size_t size_pws = 4;
14755 size_t size_tmps = 4;
14756 size_t size_hooks = 4;
14757
14758 while (kernel_accel_max >= kernel_accel_min)
14759 {
14760 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14761
14762 // size_pws
14763
14764 size_pws = kernel_power_max * sizeof (pw_t);
14765
14766 // size_tmps
14767
14768 switch (hash_mode)
14769 {
14770 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14771 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14772 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14773 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14774 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14775 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14776 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14777 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14778 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14779 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14780 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14781 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14782 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14783 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14784 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14785 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14786 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14787 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14788 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14789 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14790 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14791 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14792 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14793 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14794 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14795 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14796 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14797 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14798 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14799 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14800 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14801 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14802 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14803 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14804 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14805 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14806 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14807 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14808 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14809 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14810 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14811 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14812 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14813 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14814 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14815 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14816 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14817 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14818 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14819 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14820 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14821 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14822 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14823 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14824 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14825 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14826 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14827 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14828 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14829 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14830 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14831 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14832 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14833 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14834 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14835 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14836 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14837 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14838 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14839 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14840 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14841 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14842 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14843 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14844 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14845 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14846 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14847 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14848 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14849 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14850 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14851 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14852 };
14853
14854 // size_hooks
14855
14856 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14857 {
14858 // none yet
14859 }
14860
14861 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14862 // if not, decrease amplifier and try again
14863
14864 int skip = 0;
14865
14866 const u64 size_total
14867 = bitmap_size
14868 + bitmap_size
14869 + bitmap_size
14870 + bitmap_size
14871 + bitmap_size
14872 + bitmap_size
14873 + bitmap_size
14874 + bitmap_size
14875 + size_bfs
14876 + size_combs
14877 + size_digests
14878 + size_esalts
14879 + size_hooks
14880 + size_markov_css
14881 + size_plains
14882 + size_pws
14883 + size_pws // not a bug
14884 + size_results
14885 + size_root_css
14886 + size_rules
14887 + size_rules_c
14888 + size_salts
14889 + size_scryptV
14890 + size_shown
14891 + size_tm
14892 + size_tmps;
14893
14894 // Don't ask me, ask AMD!
14895
14896 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14897 if (size_total > device_param->device_global_mem) skip = 1;
14898
14899 if (skip == 1)
14900 {
14901 kernel_accel_max--;
14902
14903 continue;
14904 }
14905
14906 break;
14907 }
14908
14909 /*
14910 if (kernel_accel_max == 0)
14911 {
14912 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14913
14914 return -1;
14915 }
14916 */
14917
14918 device_param->kernel_accel_min = kernel_accel_min;
14919 device_param->kernel_accel_max = kernel_accel_max;
14920
14921 /*
14922 if (kernel_accel_max < kernel_accel)
14923 {
14924 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14925
14926 device_param->kernel_accel = kernel_accel_max;
14927 }
14928 */
14929
14930 device_param->size_bfs = size_bfs;
14931 device_param->size_combs = size_combs;
14932 device_param->size_rules = size_rules;
14933 device_param->size_rules_c = size_rules_c;
14934 device_param->size_pws = size_pws;
14935 device_param->size_tmps = size_tmps;
14936 device_param->size_hooks = size_hooks;
14937
14938 /**
14939 * default building options
14940 */
14941
14942 char build_opts[1024] = { 0 };
14943
14944 // we don't have sm_* on vendors not NV but it doesn't matter
14945
14946 #if _WIN
14947 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);
14948 #else
14949 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);
14950 #endif
14951
14952 char build_opts_new[1024] = { 0 };
14953
14954 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);
14955
14956 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14957
14958 /*
14959 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14960 {
14961 // we do vectorizing much better than the auto-vectorizer
14962
14963 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14964
14965 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14966 }
14967 */
14968
14969 #ifdef DEBUG
14970 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14971 #endif
14972
14973 /**
14974 * main kernel
14975 */
14976
14977 {
14978 /**
14979 * kernel source filename
14980 */
14981
14982 char source_file[256] = { 0 };
14983
14984 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14985
14986 struct stat sst;
14987
14988 if (stat (source_file, &sst) == -1)
14989 {
14990 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14991
14992 return -1;
14993 }
14994
14995 /**
14996 * kernel cached filename
14997 */
14998
14999 char cached_file[256] = { 0 };
15000
15001 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15002
15003 int cached = 1;
15004
15005 struct stat cst;
15006
15007 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15008 {
15009 cached = 0;
15010 }
15011
15012 /**
15013 * kernel compile or load
15014 */
15015
15016 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15017
15018 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15019
15020 if (force_jit_compilation == -1)
15021 {
15022 if (cached == 0)
15023 {
15024 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15025
15026 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15027
15028 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15029
15030 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15031
15032 #ifdef DEBUG
15033 size_t build_log_size = 0;
15034
15035 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15036
15037 if (build_log_size > 1)
15038 {
15039 char *build_log = (char *) malloc (build_log_size + 1);
15040
15041 memset (build_log, 0, build_log_size + 1);
15042
15043 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15044
15045 puts (build_log);
15046
15047 free (build_log);
15048 }
15049 #endif
15050
15051 if (rc != 0)
15052 {
15053 device_param->skipped = true;
15054
15055 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15056
15057 continue;
15058 }
15059
15060 size_t binary_size;
15061
15062 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15063
15064 u8 *binary = (u8 *) mymalloc (binary_size);
15065
15066 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15067
15068 writeProgramBin (cached_file, binary, binary_size);
15069
15070 local_free (binary);
15071 }
15072 else
15073 {
15074 #ifdef DEBUG
15075 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15076 #endif
15077
15078 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15079
15080 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15081
15082 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15083 }
15084 }
15085 else
15086 {
15087 #ifdef DEBUG
15088 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15089 #endif
15090
15091 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15092
15093 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15094
15095 char build_opts_update[1024] = { 0 };
15096
15097 if (force_jit_compilation == 1500)
15098 {
15099 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15100 }
15101 else if (force_jit_compilation == 8900)
15102 {
15103 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);
15104 }
15105 else
15106 {
15107 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15108 }
15109
15110 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15111
15112 #ifdef DEBUG
15113 size_t build_log_size = 0;
15114
15115 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15116
15117 if (build_log_size > 1)
15118 {
15119 char *build_log = (char *) malloc (build_log_size + 1);
15120
15121 memset (build_log, 0, build_log_size + 1);
15122
15123 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15124
15125 puts (build_log);
15126
15127 free (build_log);
15128 }
15129 #endif
15130
15131 if (rc != 0)
15132 {
15133 device_param->skipped = true;
15134
15135 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15136 }
15137 }
15138
15139 local_free (kernel_lengths);
15140 local_free (kernel_sources[0]);
15141 local_free (kernel_sources);
15142 }
15143
15144 /**
15145 * word generator kernel
15146 */
15147
15148 if (attack_mode != ATTACK_MODE_STRAIGHT)
15149 {
15150 /**
15151 * kernel mp source filename
15152 */
15153
15154 char source_file[256] = { 0 };
15155
15156 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15157
15158 struct stat sst;
15159
15160 if (stat (source_file, &sst) == -1)
15161 {
15162 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15163
15164 return -1;
15165 }
15166
15167 /**
15168 * kernel mp cached filename
15169 */
15170
15171 char cached_file[256] = { 0 };
15172
15173 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15174
15175 int cached = 1;
15176
15177 struct stat cst;
15178
15179 if (stat (cached_file, &cst) == -1)
15180 {
15181 cached = 0;
15182 }
15183
15184 /**
15185 * kernel compile or load
15186 */
15187
15188 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15189
15190 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15191
15192 if (cached == 0)
15193 {
15194 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15195 if (quiet == 0) log_info ("");
15196
15197 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15198
15199 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15200
15201 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15202
15203 if (rc != 0)
15204 {
15205 device_param->skipped = true;
15206
15207 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15208
15209 continue;
15210 }
15211
15212 size_t binary_size;
15213
15214 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15215
15216 u8 *binary = (u8 *) mymalloc (binary_size);
15217
15218 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15219
15220 writeProgramBin (cached_file, binary, binary_size);
15221
15222 local_free (binary);
15223 }
15224 else
15225 {
15226 #ifdef DEBUG
15227 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15228 #endif
15229
15230 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15231
15232 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15233
15234 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15235 }
15236
15237 local_free (kernel_lengths);
15238 local_free (kernel_sources[0]);
15239 local_free (kernel_sources);
15240 }
15241
15242 /**
15243 * amplifier kernel
15244 */
15245
15246 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15247 {
15248
15249 }
15250 else
15251 {
15252 /**
15253 * kernel amp source filename
15254 */
15255
15256 char source_file[256] = { 0 };
15257
15258 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15259
15260 struct stat sst;
15261
15262 if (stat (source_file, &sst) == -1)
15263 {
15264 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15265
15266 return -1;
15267 }
15268
15269 /**
15270 * kernel amp cached filename
15271 */
15272
15273 char cached_file[256] = { 0 };
15274
15275 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15276
15277 int cached = 1;
15278
15279 struct stat cst;
15280
15281 if (stat (cached_file, &cst) == -1)
15282 {
15283 cached = 0;
15284 }
15285
15286 /**
15287 * kernel compile or load
15288 */
15289
15290 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15291
15292 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15293
15294 if (cached == 0)
15295 {
15296 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15297 if (quiet == 0) log_info ("");
15298
15299 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15300
15301 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15302
15303 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15304
15305 if (rc != 0)
15306 {
15307 device_param->skipped = true;
15308
15309 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15310
15311 continue;
15312 }
15313
15314 size_t binary_size;
15315
15316 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15317
15318 u8 *binary = (u8 *) mymalloc (binary_size);
15319
15320 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15321
15322 writeProgramBin (cached_file, binary, binary_size);
15323
15324 local_free (binary);
15325 }
15326 else
15327 {
15328 #ifdef DEBUG
15329 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15330 #endif
15331
15332 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15333
15334 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15335
15336 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15337 }
15338
15339 local_free (kernel_lengths);
15340 local_free (kernel_sources[0]);
15341 local_free (kernel_sources);
15342 }
15343
15344 // some algorithm collide too fast, make that impossible
15345
15346 if (benchmark == 1)
15347 {
15348 ((uint *) digests_buf)[0] = -1;
15349 ((uint *) digests_buf)[1] = -1;
15350 ((uint *) digests_buf)[2] = -1;
15351 ((uint *) digests_buf)[3] = -1;
15352 }
15353
15354 /**
15355 * global buffers
15356 */
15357
15358 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15359 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15360 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15361 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15362 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15363 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15364 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15365 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15366 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15367 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15368 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15369 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15370 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15371 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15372 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15373 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15374 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15375 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15376
15377 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);
15378 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);
15379 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);
15380 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);
15381 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);
15382 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);
15383 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);
15384 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);
15385 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15386 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15387 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15388
15389 /**
15390 * special buffers
15391 */
15392
15393 if (attack_kern == ATTACK_KERN_STRAIGHT)
15394 {
15395 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15396 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15397
15398 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15399 }
15400 else if (attack_kern == ATTACK_KERN_COMBI)
15401 {
15402 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15403 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15404 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15405 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15406 }
15407 else if (attack_kern == ATTACK_KERN_BF)
15408 {
15409 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15410 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15411 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15412 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15413 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15414 }
15415
15416 if (size_esalts)
15417 {
15418 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15419
15420 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15421 }
15422
15423 /**
15424 * main host data
15425 */
15426
15427 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15428
15429 device_param->pws_buf = pws_buf;
15430
15431 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15432
15433 device_param->combs_buf = combs_buf;
15434
15435 void *hooks_buf = mymalloc (size_hooks);
15436
15437 device_param->hooks_buf = hooks_buf;
15438
15439 /**
15440 * kernel args
15441 */
15442
15443 device_param->kernel_params_buf32[21] = bitmap_mask;
15444 device_param->kernel_params_buf32[22] = bitmap_shift1;
15445 device_param->kernel_params_buf32[23] = bitmap_shift2;
15446 device_param->kernel_params_buf32[24] = 0; // salt_pos
15447 device_param->kernel_params_buf32[25] = 0; // loop_pos
15448 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15449 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15450 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15451 device_param->kernel_params_buf32[29] = 0; // digests_offset
15452 device_param->kernel_params_buf32[30] = 0; // combs_mode
15453 device_param->kernel_params_buf32[31] = 0; // gid_max
15454
15455 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15456 ? &device_param->d_pws_buf
15457 : &device_param->d_pws_amp_buf;
15458 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15459 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15460 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15461 device_param->kernel_params[ 4] = &device_param->d_tmps;
15462 device_param->kernel_params[ 5] = &device_param->d_hooks;
15463 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15464 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15465 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15466 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15467 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15468 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15469 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15470 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15471 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15472 device_param->kernel_params[15] = &device_param->d_digests_buf;
15473 device_param->kernel_params[16] = &device_param->d_digests_shown;
15474 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15475 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15476 device_param->kernel_params[19] = &device_param->d_result;
15477 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15478 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15479 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15480 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15481 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15482 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15483 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15484 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15485 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15486 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15487 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15488 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15489
15490 device_param->kernel_params_mp_buf64[3] = 0;
15491 device_param->kernel_params_mp_buf32[4] = 0;
15492 device_param->kernel_params_mp_buf32[5] = 0;
15493 device_param->kernel_params_mp_buf32[6] = 0;
15494 device_param->kernel_params_mp_buf32[7] = 0;
15495 device_param->kernel_params_mp_buf32[8] = 0;
15496
15497 device_param->kernel_params_mp[0] = NULL;
15498 device_param->kernel_params_mp[1] = NULL;
15499 device_param->kernel_params_mp[2] = NULL;
15500 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15501 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15502 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15503 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15504 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15505 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15506
15507 device_param->kernel_params_mp_l_buf64[3] = 0;
15508 device_param->kernel_params_mp_l_buf32[4] = 0;
15509 device_param->kernel_params_mp_l_buf32[5] = 0;
15510 device_param->kernel_params_mp_l_buf32[6] = 0;
15511 device_param->kernel_params_mp_l_buf32[7] = 0;
15512 device_param->kernel_params_mp_l_buf32[8] = 0;
15513 device_param->kernel_params_mp_l_buf32[9] = 0;
15514
15515 device_param->kernel_params_mp_l[0] = NULL;
15516 device_param->kernel_params_mp_l[1] = NULL;
15517 device_param->kernel_params_mp_l[2] = NULL;
15518 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15519 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15520 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15521 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15522 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15523 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15524 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15525
15526 device_param->kernel_params_mp_r_buf64[3] = 0;
15527 device_param->kernel_params_mp_r_buf32[4] = 0;
15528 device_param->kernel_params_mp_r_buf32[5] = 0;
15529 device_param->kernel_params_mp_r_buf32[6] = 0;
15530 device_param->kernel_params_mp_r_buf32[7] = 0;
15531 device_param->kernel_params_mp_r_buf32[8] = 0;
15532
15533 device_param->kernel_params_mp_r[0] = NULL;
15534 device_param->kernel_params_mp_r[1] = NULL;
15535 device_param->kernel_params_mp_r[2] = NULL;
15536 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15537 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15538 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15539 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15540 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15541 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15542
15543 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15544 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15545
15546 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15547 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15548 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15549 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15550 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15551 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15552 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15553
15554 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15555 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15556
15557 device_param->kernel_params_memset_buf32[1] = 0; // value
15558 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15559
15560 device_param->kernel_params_memset[0] = NULL;
15561 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15562 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15563
15564 /**
15565 * kernel name
15566 */
15567
15568 size_t kernel_wgs_tmp;
15569
15570 char kernel_name[64] = { 0 };
15571
15572 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15573 {
15574 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15575 {
15576 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15577
15578 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15579
15580 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15581
15582 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15583
15584 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15585
15586 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15587 }
15588 else
15589 {
15590 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15591
15592 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15593
15594 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15595
15596 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15597
15598 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15599
15600 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15601 }
15602
15603 if (data.attack_mode == ATTACK_MODE_BF)
15604 {
15605 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15606 {
15607 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15608
15609 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15610
15611 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);
15612 }
15613 }
15614 }
15615 else
15616 {
15617 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15618
15619 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15620
15621 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15622
15623 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15624
15625 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15626
15627 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15628
15629 if (opts_type & OPTS_TYPE_HOOK12)
15630 {
15631 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15632
15633 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15634
15635 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);
15636 }
15637
15638 if (opts_type & OPTS_TYPE_HOOK23)
15639 {
15640 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15641
15642 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15643
15644 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);
15645 }
15646 }
15647
15648 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);
15649 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);
15650 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);
15651
15652 for (uint i = 0; i <= 20; i++)
15653 {
15654 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15655 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15656 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15657
15658 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15659 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15660 }
15661
15662 for (uint i = 21; i <= 31; i++)
15663 {
15664 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15665 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15666 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15667
15668 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15669 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15670 }
15671
15672 // GPU memset
15673
15674 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15675
15676 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);
15677
15678 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15679 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15680 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15681
15682 // MP start
15683
15684 if (attack_mode == ATTACK_MODE_BF)
15685 {
15686 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15687 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15688
15689 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);
15690 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);
15691
15692 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15693 {
15694 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15695 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15696 }
15697 }
15698 else if (attack_mode == ATTACK_MODE_HYBRID1)
15699 {
15700 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15701
15702 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);
15703 }
15704 else if (attack_mode == ATTACK_MODE_HYBRID2)
15705 {
15706 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15707
15708 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);
15709 }
15710
15711 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15712 {
15713 // nothing to do
15714 }
15715 else
15716 {
15717 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15718
15719 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);
15720 }
15721
15722 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15723 {
15724 // nothing to do
15725 }
15726 else
15727 {
15728 for (uint i = 0; i < 5; i++)
15729 {
15730 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15731 }
15732
15733 for (uint i = 5; i < 7; i++)
15734 {
15735 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15736 }
15737 }
15738
15739 // maybe this has been updated by clGetKernelWorkGroupInfo()
15740 // value can only be decreased, so we don't need to reallocate buffers
15741
15742 device_param->kernel_threads = kernel_threads;
15743
15744 // zero some data buffers
15745
15746 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15747 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15748 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15749 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15750 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15751 run_kernel_bzero (device_param, device_param->d_result, size_results);
15752
15753 /**
15754 * special buffers
15755 */
15756
15757 if (attack_kern == ATTACK_KERN_STRAIGHT)
15758 {
15759 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15760 }
15761 else if (attack_kern == ATTACK_KERN_COMBI)
15762 {
15763 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15764 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15765 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15766 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15767 }
15768 else if (attack_kern == ATTACK_KERN_BF)
15769 {
15770 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15771 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15772 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15773 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15774 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15775 }
15776
15777 #if defined(HAVE_HWMON)
15778
15779 /**
15780 * Store initial fanspeed if gpu_temp_retain is enabled
15781 */
15782
15783 if (gpu_temp_disable == 0)
15784 {
15785 if (gpu_temp_retain != 0)
15786 {
15787 hc_thread_mutex_lock (mux_adl);
15788
15789 if (data.hm_device[device_id].fan_get_supported == 1)
15790 {
15791 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15792 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15793
15794 temp_retain_fanspeed_value[device_id] = fanspeed;
15795 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15796
15797 // we also set it to tell the OS we take control over the fan and it's automatic controller
15798 // if it was set to automatic. we do not control user-defined fanspeeds.
15799
15800 if (fanpolicy == 1)
15801 {
15802 data.hm_device[device_id].fan_set_supported = 1;
15803
15804 int rc = -1;
15805
15806 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15807 {
15808 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
15809 }
15810 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15811 {
15812
15813 }
15814
15815 if (rc == 0)
15816 {
15817 data.hm_device[device_id].fan_set_supported = 1;
15818 }
15819 else
15820 {
15821 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15822
15823 data.hm_device[device_id].fan_set_supported = 0;
15824 }
15825 }
15826 else
15827 {
15828 data.hm_device[device_id].fan_set_supported = 0;
15829 }
15830 }
15831
15832 hc_thread_mutex_unlock (mux_adl);
15833 }
15834 }
15835
15836 #endif // HAVE_HWMON
15837 }
15838
15839 if (data.quiet == 0) log_info_nn ("");
15840
15841 /**
15842 * In benchmark-mode, inform user which algorithm is checked
15843 */
15844
15845 if (benchmark == 1)
15846 {
15847 if (machine_readable == 0)
15848 {
15849 quiet = 0;
15850
15851 data.quiet = quiet;
15852
15853 char *hash_type = strhashtype (data.hash_mode); // not a bug
15854
15855 log_info ("Hashtype: %s", hash_type);
15856 log_info ("");
15857 }
15858 }
15859
15860 /**
15861 * keep track of the progress
15862 */
15863
15864 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15865 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15866 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15867
15868 /**
15869 * open filehandles
15870 */
15871
15872 #if _WIN
15873 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15874 {
15875 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15876
15877 return (-1);
15878 }
15879
15880 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15881 {
15882 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15883
15884 return (-1);
15885 }
15886
15887 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15888 {
15889 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15890
15891 return (-1);
15892 }
15893 #endif
15894
15895 /**
15896 * dictionary pad
15897 */
15898
15899 segment_size *= (1024 * 1024);
15900
15901 data.segment_size = segment_size;
15902
15903 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15904
15905 wl_data->buf = (char *) mymalloc (segment_size);
15906 wl_data->avail = segment_size;
15907 wl_data->incr = segment_size;
15908 wl_data->cnt = 0;
15909 wl_data->pos = 0;
15910
15911 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15912
15913 data.wordlist_mode = wordlist_mode;
15914
15915 cs_t *css_buf = NULL;
15916 uint css_cnt = 0;
15917 uint dictcnt = 0;
15918 uint maskcnt = 1;
15919 char **masks = NULL;
15920 char **dictfiles = NULL;
15921
15922 uint mask_from_file = 0;
15923
15924 if (attack_mode == ATTACK_MODE_STRAIGHT)
15925 {
15926 if (wordlist_mode == WL_MODE_FILE)
15927 {
15928 int wls_left = myargc - (optind + 1);
15929
15930 for (int i = 0; i < wls_left; i++)
15931 {
15932 char *l0_filename = myargv[optind + 1 + i];
15933
15934 struct stat l0_stat;
15935
15936 if (stat (l0_filename, &l0_stat) == -1)
15937 {
15938 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15939
15940 return (-1);
15941 }
15942
15943 uint is_dir = S_ISDIR (l0_stat.st_mode);
15944
15945 if (is_dir == 0)
15946 {
15947 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15948
15949 dictcnt++;
15950
15951 dictfiles[dictcnt - 1] = l0_filename;
15952 }
15953 else
15954 {
15955 // do not allow --keyspace w/ a directory
15956
15957 if (keyspace == 1)
15958 {
15959 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15960
15961 return (-1);
15962 }
15963
15964 char **dictionary_files = NULL;
15965
15966 dictionary_files = scan_directory (l0_filename);
15967
15968 if (dictionary_files != NULL)
15969 {
15970 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15971
15972 for (int d = 0; dictionary_files[d] != NULL; d++)
15973 {
15974 char *l1_filename = dictionary_files[d];
15975
15976 struct stat l1_stat;
15977
15978 if (stat (l1_filename, &l1_stat) == -1)
15979 {
15980 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15981
15982 return (-1);
15983 }
15984
15985 if (S_ISREG (l1_stat.st_mode))
15986 {
15987 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15988
15989 dictcnt++;
15990
15991 dictfiles[dictcnt - 1] = strdup (l1_filename);
15992 }
15993 }
15994 }
15995
15996 local_free (dictionary_files);
15997 }
15998 }
15999
16000 if (dictcnt < 1)
16001 {
16002 log_error ("ERROR: No usable dictionary file found.");
16003
16004 return (-1);
16005 }
16006 }
16007 else if (wordlist_mode == WL_MODE_STDIN)
16008 {
16009 dictcnt = 1;
16010 }
16011 }
16012 else if (attack_mode == ATTACK_MODE_COMBI)
16013 {
16014 // display
16015
16016 char *dictfile1 = myargv[optind + 1 + 0];
16017 char *dictfile2 = myargv[optind + 1 + 1];
16018
16019 // find the bigger dictionary and use as base
16020
16021 FILE *fp1 = NULL;
16022 FILE *fp2 = NULL;
16023
16024 struct stat tmp_stat;
16025
16026 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16027 {
16028 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16029
16030 return (-1);
16031 }
16032
16033 if (stat (dictfile1, &tmp_stat) == -1)
16034 {
16035 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16036
16037 fclose (fp1);
16038
16039 return (-1);
16040 }
16041
16042 if (S_ISDIR (tmp_stat.st_mode))
16043 {
16044 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16045
16046 fclose (fp1);
16047
16048 return (-1);
16049 }
16050
16051 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16052 {
16053 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16054
16055 fclose (fp1);
16056
16057 return (-1);
16058 }
16059
16060 if (stat (dictfile2, &tmp_stat) == -1)
16061 {
16062 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16063
16064 fclose (fp1);
16065 fclose (fp2);
16066
16067 return (-1);
16068 }
16069
16070 if (S_ISDIR (tmp_stat.st_mode))
16071 {
16072 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16073
16074 fclose (fp1);
16075 fclose (fp2);
16076
16077 return (-1);
16078 }
16079
16080 data.combs_cnt = 1;
16081
16082 data.quiet = 1;
16083
16084 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16085
16086 data.quiet = quiet;
16087
16088 if (words1_cnt == 0)
16089 {
16090 log_error ("ERROR: %s: empty file", dictfile1);
16091
16092 fclose (fp1);
16093 fclose (fp2);
16094
16095 return (-1);
16096 }
16097
16098 data.combs_cnt = 1;
16099
16100 data.quiet = 1;
16101
16102 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16103
16104 data.quiet = quiet;
16105
16106 if (words2_cnt == 0)
16107 {
16108 log_error ("ERROR: %s: empty file", dictfile2);
16109
16110 fclose (fp1);
16111 fclose (fp2);
16112
16113 return (-1);
16114 }
16115
16116 fclose (fp1);
16117 fclose (fp2);
16118
16119 data.dictfile = dictfile1;
16120 data.dictfile2 = dictfile2;
16121
16122 if (words1_cnt >= words2_cnt)
16123 {
16124 data.combs_cnt = words2_cnt;
16125 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16126
16127 dictfiles = &data.dictfile;
16128
16129 dictcnt = 1;
16130 }
16131 else
16132 {
16133 data.combs_cnt = words1_cnt;
16134 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16135
16136 dictfiles = &data.dictfile2;
16137
16138 dictcnt = 1;
16139
16140 // we also have to switch wordlist related rules!
16141
16142 char *tmpc = data.rule_buf_l;
16143
16144 data.rule_buf_l = data.rule_buf_r;
16145 data.rule_buf_r = tmpc;
16146
16147 int tmpi = data.rule_len_l;
16148
16149 data.rule_len_l = data.rule_len_r;
16150 data.rule_len_r = tmpi;
16151 }
16152 }
16153 else if (attack_mode == ATTACK_MODE_BF)
16154 {
16155 char *mask = NULL;
16156
16157 maskcnt = 0;
16158
16159 if (benchmark == 0)
16160 {
16161 mask = myargv[optind + 1];
16162
16163 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16164
16165 if ((optind + 2) <= myargc)
16166 {
16167 struct stat file_stat;
16168
16169 if (stat (mask, &file_stat) == -1)
16170 {
16171 maskcnt = 1;
16172
16173 masks[maskcnt - 1] = mystrdup (mask);
16174 }
16175 else
16176 {
16177 int wls_left = myargc - (optind + 1);
16178
16179 uint masks_avail = INCR_MASKS;
16180
16181 for (int i = 0; i < wls_left; i++)
16182 {
16183 if (i != 0)
16184 {
16185 mask = myargv[optind + 1 + i];
16186
16187 if (stat (mask, &file_stat) == -1)
16188 {
16189 log_error ("ERROR: %s: %s", mask, strerror (errno));
16190
16191 return (-1);
16192 }
16193 }
16194
16195 uint is_file = S_ISREG (file_stat.st_mode);
16196
16197 if (is_file == 1)
16198 {
16199 FILE *mask_fp;
16200
16201 if ((mask_fp = fopen (mask, "r")) == NULL)
16202 {
16203 log_error ("ERROR: %s: %s", mask, strerror (errno));
16204
16205 return (-1);
16206 }
16207
16208 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16209
16210 while (!feof (mask_fp))
16211 {
16212 memset (line_buf, 0, HCBUFSIZ);
16213
16214 int line_len = fgetl (mask_fp, line_buf);
16215
16216 if (line_len == 0) continue;
16217
16218 if (line_buf[0] == '#') continue;
16219
16220 if (masks_avail == maskcnt)
16221 {
16222 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16223
16224 masks_avail += INCR_MASKS;
16225 }
16226
16227 masks[maskcnt] = mystrdup (line_buf);
16228
16229 maskcnt++;
16230 }
16231
16232 myfree (line_buf);
16233
16234 fclose (mask_fp);
16235 }
16236 else
16237 {
16238 log_error ("ERROR: %s: unsupported file-type", mask);
16239
16240 return (-1);
16241 }
16242 }
16243
16244 mask_from_file = 1;
16245 }
16246 }
16247 else
16248 {
16249 custom_charset_1 = (char *) "?l?d?u";
16250 custom_charset_2 = (char *) "?l?d";
16251 custom_charset_3 = (char *) "?l?d*!$@_";
16252
16253 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16254 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16255 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16256
16257 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16258
16259 wordlist_mode = WL_MODE_MASK;
16260
16261 data.wordlist_mode = wordlist_mode;
16262
16263 increment = 1;
16264
16265 maskcnt = 1;
16266 }
16267 }
16268 else
16269 {
16270 /**
16271 * generate full masks and charsets
16272 */
16273
16274 masks = (char **) mymalloc (sizeof (char *));
16275
16276 switch (hash_mode)
16277 {
16278 case 1731: pw_min = 5;
16279 pw_max = 5;
16280 mask = mystrdup ("?b?b?b?b?b");
16281 break;
16282 case 12500: pw_min = 5;
16283 pw_max = 5;
16284 mask = mystrdup ("?b?b?b?b?b");
16285 break;
16286 default: pw_min = 7;
16287 pw_max = 7;
16288 mask = mystrdup ("?b?b?b?b?b?b?b");
16289 break;
16290 }
16291
16292 maskcnt = 1;
16293
16294 masks[maskcnt - 1] = mystrdup (mask);
16295
16296 wordlist_mode = WL_MODE_MASK;
16297
16298 data.wordlist_mode = wordlist_mode;
16299
16300 increment = 1;
16301 }
16302
16303 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16304
16305 if (increment)
16306 {
16307 if (increment_min > pw_min) pw_min = increment_min;
16308
16309 if (increment_max < pw_max) pw_max = increment_max;
16310 }
16311 }
16312 else if (attack_mode == ATTACK_MODE_HYBRID1)
16313 {
16314 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16315
16316 // display
16317
16318 char *mask = myargv[myargc - 1];
16319
16320 maskcnt = 0;
16321
16322 masks = (char **) mymalloc (1 * sizeof (char *));
16323
16324 // mod
16325
16326 struct stat file_stat;
16327
16328 if (stat (mask, &file_stat) == -1)
16329 {
16330 maskcnt = 1;
16331
16332 masks[maskcnt - 1] = mystrdup (mask);
16333 }
16334 else
16335 {
16336 uint is_file = S_ISREG (file_stat.st_mode);
16337
16338 if (is_file == 1)
16339 {
16340 FILE *mask_fp;
16341
16342 if ((mask_fp = fopen (mask, "r")) == NULL)
16343 {
16344 log_error ("ERROR: %s: %s", mask, strerror (errno));
16345
16346 return (-1);
16347 }
16348
16349 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16350
16351 uint masks_avail = 1;
16352
16353 while (!feof (mask_fp))
16354 {
16355 memset (line_buf, 0, HCBUFSIZ);
16356
16357 int line_len = fgetl (mask_fp, line_buf);
16358
16359 if (line_len == 0) continue;
16360
16361 if (line_buf[0] == '#') continue;
16362
16363 if (masks_avail == maskcnt)
16364 {
16365 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16366
16367 masks_avail += INCR_MASKS;
16368 }
16369
16370 masks[maskcnt] = mystrdup (line_buf);
16371
16372 maskcnt++;
16373 }
16374
16375 myfree (line_buf);
16376
16377 fclose (mask_fp);
16378
16379 mask_from_file = 1;
16380 }
16381 else
16382 {
16383 maskcnt = 1;
16384
16385 masks[maskcnt - 1] = mystrdup (mask);
16386 }
16387 }
16388
16389 // base
16390
16391 int wls_left = myargc - (optind + 2);
16392
16393 for (int i = 0; i < wls_left; i++)
16394 {
16395 char *filename = myargv[optind + 1 + i];
16396
16397 struct stat file_stat;
16398
16399 if (stat (filename, &file_stat) == -1)
16400 {
16401 log_error ("ERROR: %s: %s", filename, strerror (errno));
16402
16403 return (-1);
16404 }
16405
16406 uint is_dir = S_ISDIR (file_stat.st_mode);
16407
16408 if (is_dir == 0)
16409 {
16410 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16411
16412 dictcnt++;
16413
16414 dictfiles[dictcnt - 1] = filename;
16415 }
16416 else
16417 {
16418 // do not allow --keyspace w/ a directory
16419
16420 if (keyspace == 1)
16421 {
16422 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16423
16424 return (-1);
16425 }
16426
16427 char **dictionary_files = NULL;
16428
16429 dictionary_files = scan_directory (filename);
16430
16431 if (dictionary_files != NULL)
16432 {
16433 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16434
16435 for (int d = 0; dictionary_files[d] != NULL; d++)
16436 {
16437 char *l1_filename = dictionary_files[d];
16438
16439 struct stat l1_stat;
16440
16441 if (stat (l1_filename, &l1_stat) == -1)
16442 {
16443 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16444
16445 return (-1);
16446 }
16447
16448 if (S_ISREG (l1_stat.st_mode))
16449 {
16450 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16451
16452 dictcnt++;
16453
16454 dictfiles[dictcnt - 1] = strdup (l1_filename);
16455 }
16456 }
16457 }
16458
16459 local_free (dictionary_files);
16460 }
16461 }
16462
16463 if (dictcnt < 1)
16464 {
16465 log_error ("ERROR: No usable dictionary file found.");
16466
16467 return (-1);
16468 }
16469
16470 if (increment)
16471 {
16472 maskcnt = 0;
16473
16474 uint mask_min = increment_min; // we can't reject smaller masks here
16475 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16476
16477 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16478 {
16479 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16480
16481 if (cur_mask == NULL) break;
16482
16483 masks[maskcnt] = cur_mask;
16484
16485 maskcnt++;
16486
16487 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16488 }
16489 }
16490 }
16491 else if (attack_mode == ATTACK_MODE_HYBRID2)
16492 {
16493 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16494
16495 // display
16496
16497 char *mask = myargv[optind + 1 + 0];
16498
16499 maskcnt = 0;
16500
16501 masks = (char **) mymalloc (1 * sizeof (char *));
16502
16503 // mod
16504
16505 struct stat file_stat;
16506
16507 if (stat (mask, &file_stat) == -1)
16508 {
16509 maskcnt = 1;
16510
16511 masks[maskcnt - 1] = mystrdup (mask);
16512 }
16513 else
16514 {
16515 uint is_file = S_ISREG (file_stat.st_mode);
16516
16517 if (is_file == 1)
16518 {
16519 FILE *mask_fp;
16520
16521 if ((mask_fp = fopen (mask, "r")) == NULL)
16522 {
16523 log_error ("ERROR: %s: %s", mask, strerror (errno));
16524
16525 return (-1);
16526 }
16527
16528 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16529
16530 uint masks_avail = 1;
16531
16532 while (!feof (mask_fp))
16533 {
16534 memset (line_buf, 0, HCBUFSIZ);
16535
16536 int line_len = fgetl (mask_fp, line_buf);
16537
16538 if (line_len == 0) continue;
16539
16540 if (line_buf[0] == '#') continue;
16541
16542 if (masks_avail == maskcnt)
16543 {
16544 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16545
16546 masks_avail += INCR_MASKS;
16547 }
16548
16549 masks[maskcnt] = mystrdup (line_buf);
16550
16551 maskcnt++;
16552 }
16553
16554 myfree (line_buf);
16555
16556 fclose (mask_fp);
16557
16558 mask_from_file = 1;
16559 }
16560 else
16561 {
16562 maskcnt = 1;
16563
16564 masks[maskcnt - 1] = mystrdup (mask);
16565 }
16566 }
16567
16568 // base
16569
16570 int wls_left = myargc - (optind + 2);
16571
16572 for (int i = 0; i < wls_left; i++)
16573 {
16574 char *filename = myargv[optind + 2 + i];
16575
16576 struct stat file_stat;
16577
16578 if (stat (filename, &file_stat) == -1)
16579 {
16580 log_error ("ERROR: %s: %s", filename, strerror (errno));
16581
16582 return (-1);
16583 }
16584
16585 uint is_dir = S_ISDIR (file_stat.st_mode);
16586
16587 if (is_dir == 0)
16588 {
16589 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16590
16591 dictcnt++;
16592
16593 dictfiles[dictcnt - 1] = filename;
16594 }
16595 else
16596 {
16597 // do not allow --keyspace w/ a directory
16598
16599 if (keyspace == 1)
16600 {
16601 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16602
16603 return (-1);
16604 }
16605
16606 char **dictionary_files = NULL;
16607
16608 dictionary_files = scan_directory (filename);
16609
16610 if (dictionary_files != NULL)
16611 {
16612 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16613
16614 for (int d = 0; dictionary_files[d] != NULL; d++)
16615 {
16616 char *l1_filename = dictionary_files[d];
16617
16618 struct stat l1_stat;
16619
16620 if (stat (l1_filename, &l1_stat) == -1)
16621 {
16622 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16623
16624 return (-1);
16625 }
16626
16627 if (S_ISREG (l1_stat.st_mode))
16628 {
16629 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16630
16631 dictcnt++;
16632
16633 dictfiles[dictcnt - 1] = strdup (l1_filename);
16634 }
16635 }
16636 }
16637
16638 local_free (dictionary_files);
16639 }
16640 }
16641
16642 if (dictcnt < 1)
16643 {
16644 log_error ("ERROR: No usable dictionary file found.");
16645
16646 return (-1);
16647 }
16648
16649 if (increment)
16650 {
16651 maskcnt = 0;
16652
16653 uint mask_min = increment_min; // we can't reject smaller masks here
16654 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16655
16656 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16657 {
16658 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16659
16660 if (cur_mask == NULL) break;
16661
16662 masks[maskcnt] = cur_mask;
16663
16664 maskcnt++;
16665
16666 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16667 }
16668 }
16669 }
16670
16671 data.pw_min = pw_min;
16672 data.pw_max = pw_max;
16673
16674 /**
16675 * weak hash check
16676 */
16677
16678 if (weak_hash_threshold >= salts_cnt)
16679 {
16680 hc_device_param_t *device_param = NULL;
16681
16682 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16683 {
16684 device_param = &data.devices_param[device_id];
16685
16686 if (device_param->skipped) continue;
16687
16688 break;
16689 }
16690
16691 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16692
16693 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16694 {
16695 weak_hash_check (device_param, salt_pos);
16696 }
16697
16698 // Display hack, guarantee that there is at least one \r before real start
16699
16700 //if (data.quiet == 0) log_info ("");
16701 }
16702
16703 /**
16704 * status and monitor threads
16705 */
16706
16707 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16708
16709 hc_thread_t i_thread = 0;
16710
16711 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16712 {
16713 hc_thread_create (i_thread, thread_keypress, &benchmark);
16714 }
16715
16716 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16717
16718 uint ni_threads_cnt = 0;
16719
16720 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16721
16722 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16723
16724 ni_threads_cnt++;
16725
16726 /**
16727 * Outfile remove
16728 */
16729
16730 if (keyspace == 0)
16731 {
16732 if (outfile_check_timer != 0)
16733 {
16734 if (data.outfile_check_directory != NULL)
16735 {
16736 if ((hash_mode != 5200) &&
16737 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16738 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16739 (hash_mode != 9000))
16740 {
16741 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16742
16743 ni_threads_cnt++;
16744 }
16745 else
16746 {
16747 outfile_check_timer = 0;
16748 }
16749 }
16750 else
16751 {
16752 outfile_check_timer = 0;
16753 }
16754 }
16755 }
16756
16757 /**
16758 * Inform the user if we got some hashes remove because of the pot file remove feature
16759 */
16760
16761 if (data.quiet == 0)
16762 {
16763 if (potfile_remove_cracks > 0)
16764 {
16765 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16766 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16767 }
16768 }
16769
16770 data.outfile_check_timer = outfile_check_timer;
16771
16772 /**
16773 * main loop
16774 */
16775
16776 char **induction_dictionaries = NULL;
16777
16778 int induction_dictionaries_cnt = 0;
16779
16780 hcstat_table_t *root_table_buf = NULL;
16781 hcstat_table_t *markov_table_buf = NULL;
16782
16783 uint initial_restore_done = 0;
16784
16785 data.maskcnt = maskcnt;
16786
16787 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16788 {
16789 if (data.devices_status == STATUS_CRACKED) break;
16790
16791 data.devices_status = STATUS_INIT;
16792
16793 if (maskpos > rd->maskpos)
16794 {
16795 rd->dictpos = 0;
16796 }
16797
16798 rd->maskpos = maskpos;
16799 data.maskpos = maskpos;
16800
16801 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16802 {
16803 char *mask = masks[maskpos];
16804
16805 if (mask_from_file == 1)
16806 {
16807 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16808
16809 char *str_ptr;
16810 uint str_pos;
16811
16812 uint mask_offset = 0;
16813
16814 uint separator_cnt;
16815
16816 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16817 {
16818 str_ptr = strstr (mask + mask_offset, ",");
16819
16820 if (str_ptr == NULL) break;
16821
16822 str_pos = str_ptr - mask;
16823
16824 // escaped separator, i.e. "\,"
16825
16826 if (str_pos > 0)
16827 {
16828 if (mask[str_pos - 1] == '\\')
16829 {
16830 separator_cnt --;
16831
16832 mask_offset = str_pos + 1;
16833
16834 continue;
16835 }
16836 }
16837
16838 // reset the offset
16839
16840 mask_offset = 0;
16841
16842 mask[str_pos] = '\0';
16843
16844 switch (separator_cnt)
16845 {
16846 case 0:
16847 mp_reset_usr (mp_usr, 0);
16848
16849 custom_charset_1 = mask;
16850 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16851 break;
16852
16853 case 1:
16854 mp_reset_usr (mp_usr, 1);
16855
16856 custom_charset_2 = mask;
16857 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16858 break;
16859
16860 case 2:
16861 mp_reset_usr (mp_usr, 2);
16862
16863 custom_charset_3 = mask;
16864 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16865 break;
16866
16867 case 3:
16868 mp_reset_usr (mp_usr, 3);
16869
16870 custom_charset_4 = mask;
16871 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16872 break;
16873 }
16874
16875 mask = mask + str_pos + 1;
16876 }
16877 }
16878
16879 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16880 {
16881 if (maskpos > 0)
16882 {
16883 local_free (css_buf);
16884 local_free (data.root_css_buf);
16885 local_free (data.markov_css_buf);
16886
16887 local_free (masks[maskpos - 1]);
16888 }
16889
16890 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16891
16892 data.mask = mask;
16893 data.css_cnt = css_cnt;
16894 data.css_buf = css_buf;
16895
16896 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16897
16898 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16899
16900 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16901 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16902
16903 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16904
16905 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16906
16907 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16908 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16909
16910 data.root_css_buf = root_css_buf;
16911 data.markov_css_buf = markov_css_buf;
16912
16913 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16914
16915 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16916
16917 local_free (root_table_buf);
16918 local_free (markov_table_buf);
16919
16920 // args
16921
16922 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16923 {
16924 hc_device_param_t *device_param = &data.devices_param[device_id];
16925
16926 if (device_param->skipped) continue;
16927
16928 device_param->kernel_params_mp[0] = &device_param->d_combs;
16929 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16930 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16931
16932 device_param->kernel_params_mp_buf64[3] = 0;
16933 device_param->kernel_params_mp_buf32[4] = css_cnt;
16934 device_param->kernel_params_mp_buf32[5] = 0;
16935 device_param->kernel_params_mp_buf32[6] = 0;
16936 device_param->kernel_params_mp_buf32[7] = 0;
16937
16938 if (attack_mode == ATTACK_MODE_HYBRID1)
16939 {
16940 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16941 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16942 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16943 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16944 }
16945 else if (attack_mode == ATTACK_MODE_HYBRID2)
16946 {
16947 device_param->kernel_params_mp_buf32[5] = 0;
16948 device_param->kernel_params_mp_buf32[6] = 0;
16949 device_param->kernel_params_mp_buf32[7] = 0;
16950 }
16951
16952 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]);
16953 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]);
16954 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]);
16955
16956 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);
16957 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);
16958 }
16959 }
16960 else if (attack_mode == ATTACK_MODE_BF)
16961 {
16962 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16963
16964 if (increment)
16965 {
16966 for (uint i = 0; i < dictcnt; i++)
16967 {
16968 local_free (dictfiles[i]);
16969 }
16970
16971 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16972 {
16973 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16974
16975 if (l1_filename == NULL) break;
16976
16977 dictcnt++;
16978
16979 dictfiles[dictcnt - 1] = l1_filename;
16980 }
16981 }
16982 else
16983 {
16984 dictcnt++;
16985
16986 dictfiles[dictcnt - 1] = mask;
16987 }
16988
16989 if (dictcnt == 0)
16990 {
16991 log_error ("ERROR: Mask is too small");
16992
16993 return (-1);
16994 }
16995 }
16996 }
16997
16998 free (induction_dictionaries);
16999
17000 // induction_dictionaries_cnt = 0; // implied
17001
17002 if (attack_mode != ATTACK_MODE_BF)
17003 {
17004 if (keyspace == 0)
17005 {
17006 induction_dictionaries = scan_directory (induction_directory);
17007
17008 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17009 }
17010 }
17011
17012 if (induction_dictionaries_cnt)
17013 {
17014 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17015 }
17016
17017 /**
17018 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17019 */
17020 if (keyspace == 1)
17021 {
17022 if ((maskcnt > 1) || (dictcnt > 1))
17023 {
17024 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17025
17026 return (-1);
17027 }
17028 }
17029
17030 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17031 {
17032 char *subid = logfile_generate_subid ();
17033
17034 data.subid = subid;
17035
17036 logfile_sub_msg ("START");
17037
17038 data.devices_status = STATUS_INIT;
17039
17040 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17041 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17042 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17043
17044 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17045
17046 data.cpt_pos = 0;
17047
17048 data.cpt_start = time (NULL);
17049
17050 data.cpt_total = 0;
17051
17052 if (data.restore == 0)
17053 {
17054 rd->words_cur = skip;
17055
17056 skip = 0;
17057
17058 data.skip = 0;
17059 }
17060
17061 data.ms_paused = 0;
17062
17063 data.kernel_power_final = 0;
17064
17065 data.words_cur = rd->words_cur;
17066
17067 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17068 {
17069 hc_device_param_t *device_param = &data.devices_param[device_id];
17070
17071 if (device_param->skipped) continue;
17072
17073 device_param->speed_pos = 0;
17074
17075 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17076 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17077
17078 device_param->exec_pos = 0;
17079
17080 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17081
17082 device_param->outerloop_pos = 0;
17083 device_param->outerloop_left = 0;
17084 device_param->innerloop_pos = 0;
17085 device_param->innerloop_left = 0;
17086
17087 // some more resets:
17088
17089 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17090
17091 device_param->pws_cnt = 0;
17092
17093 device_param->words_off = 0;
17094 device_param->words_done = 0;
17095 }
17096
17097 // figure out some workload
17098
17099 if (attack_mode == ATTACK_MODE_STRAIGHT)
17100 {
17101 if (data.wordlist_mode == WL_MODE_FILE)
17102 {
17103 char *dictfile = NULL;
17104
17105 if (induction_dictionaries_cnt)
17106 {
17107 dictfile = induction_dictionaries[0];
17108 }
17109 else
17110 {
17111 dictfile = dictfiles[dictpos];
17112 }
17113
17114 data.dictfile = dictfile;
17115
17116 logfile_sub_string (dictfile);
17117
17118 for (uint i = 0; i < rp_files_cnt; i++)
17119 {
17120 logfile_sub_var_string ("rulefile", rp_files[i]);
17121 }
17122
17123 FILE *fd2 = fopen (dictfile, "rb");
17124
17125 if (fd2 == NULL)
17126 {
17127 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17128
17129 return (-1);
17130 }
17131
17132 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17133
17134 fclose (fd2);
17135
17136 if (data.words_cnt == 0)
17137 {
17138 if (data.devices_status == STATUS_CRACKED) break;
17139 if (data.devices_status == STATUS_ABORTED) break;
17140
17141 dictpos++;
17142
17143 continue;
17144 }
17145 }
17146 }
17147 else if (attack_mode == ATTACK_MODE_COMBI)
17148 {
17149 char *dictfile = data.dictfile;
17150 char *dictfile2 = data.dictfile2;
17151
17152 logfile_sub_string (dictfile);
17153 logfile_sub_string (dictfile2);
17154
17155 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17156 {
17157 FILE *fd2 = fopen (dictfile, "rb");
17158
17159 if (fd2 == NULL)
17160 {
17161 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17162
17163 return (-1);
17164 }
17165
17166 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17167
17168 fclose (fd2);
17169 }
17170 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17171 {
17172 FILE *fd2 = fopen (dictfile2, "rb");
17173
17174 if (fd2 == NULL)
17175 {
17176 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17177
17178 return (-1);
17179 }
17180
17181 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17182
17183 fclose (fd2);
17184 }
17185
17186 if (data.words_cnt == 0)
17187 {
17188 if (data.devices_status == STATUS_CRACKED) break;
17189 if (data.devices_status == STATUS_ABORTED) break;
17190
17191 dictpos++;
17192
17193 continue;
17194 }
17195 }
17196 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17197 {
17198 char *dictfile = NULL;
17199
17200 if (induction_dictionaries_cnt)
17201 {
17202 dictfile = induction_dictionaries[0];
17203 }
17204 else
17205 {
17206 dictfile = dictfiles[dictpos];
17207 }
17208
17209 data.dictfile = dictfile;
17210
17211 char *mask = data.mask;
17212
17213 logfile_sub_string (dictfile);
17214 logfile_sub_string (mask);
17215
17216 FILE *fd2 = fopen (dictfile, "rb");
17217
17218 if (fd2 == NULL)
17219 {
17220 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17221
17222 return (-1);
17223 }
17224
17225 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17226
17227 fclose (fd2);
17228
17229 if (data.words_cnt == 0)
17230 {
17231 if (data.devices_status == STATUS_CRACKED) break;
17232 if (data.devices_status == STATUS_ABORTED) break;
17233
17234 dictpos++;
17235
17236 continue;
17237 }
17238 }
17239 else if (attack_mode == ATTACK_MODE_BF)
17240 {
17241 local_free (css_buf);
17242 local_free (data.root_css_buf);
17243 local_free (data.markov_css_buf);
17244
17245 char *mask = dictfiles[dictpos];
17246
17247 logfile_sub_string (mask);
17248
17249 // base
17250
17251 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17252
17253 if (opts_type & OPTS_TYPE_PT_UNICODE)
17254 {
17255 uint css_cnt_unicode = css_cnt * 2;
17256
17257 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17258
17259 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17260 {
17261 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17262
17263 css_buf_unicode[j + 1].cs_buf[0] = 0;
17264 css_buf_unicode[j + 1].cs_len = 1;
17265 }
17266
17267 free (css_buf);
17268
17269 css_buf = css_buf_unicode;
17270 css_cnt = css_cnt_unicode;
17271 }
17272
17273 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17274
17275 uint mask_min = pw_min;
17276 uint mask_max = pw_max;
17277
17278 if (opts_type & OPTS_TYPE_PT_UNICODE)
17279 {
17280 mask_min *= 2;
17281 mask_max *= 2;
17282 }
17283
17284 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17285 {
17286 if (css_cnt < mask_min)
17287 {
17288 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17289 }
17290
17291 if (css_cnt > mask_max)
17292 {
17293 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17294 }
17295
17296 // skip to next mask
17297
17298 dictpos++;
17299
17300 rd->dictpos = dictpos;
17301
17302 logfile_sub_msg ("STOP");
17303
17304 continue;
17305 }
17306
17307 uint save_css_cnt = css_cnt;
17308
17309 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17310 {
17311 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17312 {
17313 uint salt_len = (uint) data.salts_buf[0].salt_len;
17314 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17315
17316 uint css_cnt_salt = css_cnt + salt_len;
17317
17318 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17319
17320 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17321
17322 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17323 {
17324 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17325 css_buf_salt[j].cs_len = 1;
17326 }
17327
17328 free (css_buf);
17329
17330 css_buf = css_buf_salt;
17331 css_cnt = css_cnt_salt;
17332 }
17333 }
17334
17335 data.mask = mask;
17336 data.css_cnt = css_cnt;
17337 data.css_buf = css_buf;
17338
17339 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17340
17341 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17342
17343 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17344
17345 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17346 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17347
17348 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17349
17350 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17351
17352 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17353 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17354
17355 data.root_css_buf = root_css_buf;
17356 data.markov_css_buf = markov_css_buf;
17357
17358 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17359
17360 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17361
17362 local_free (root_table_buf);
17363 local_free (markov_table_buf);
17364
17365 // copy + args
17366
17367 uint css_cnt_l = css_cnt;
17368 uint css_cnt_r;
17369
17370 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17371 {
17372 if (save_css_cnt < 6)
17373 {
17374 css_cnt_r = 1;
17375 }
17376 else if (save_css_cnt == 6)
17377 {
17378 css_cnt_r = 2;
17379 }
17380 else
17381 {
17382 if (opts_type & OPTS_TYPE_PT_UNICODE)
17383 {
17384 if (save_css_cnt == 8 || save_css_cnt == 10)
17385 {
17386 css_cnt_r = 2;
17387 }
17388 else
17389 {
17390 css_cnt_r = 4;
17391 }
17392 }
17393 else
17394 {
17395 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17396 {
17397 css_cnt_r = 3;
17398 }
17399 else
17400 {
17401 css_cnt_r = 4;
17402 }
17403 }
17404 }
17405 }
17406 else
17407 {
17408 css_cnt_r = 1;
17409
17410 /* unfinished code?
17411 int sum = css_buf[css_cnt_r - 1].cs_len;
17412
17413 for (uint i = 1; i < 4 && i < css_cnt; i++)
17414 {
17415 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17416
17417 css_cnt_r++;
17418
17419 sum *= css_buf[css_cnt_r - 1].cs_len;
17420 }
17421 */
17422 }
17423
17424 css_cnt_l -= css_cnt_r;
17425
17426 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17427
17428 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17429 {
17430 hc_device_param_t *device_param = &data.devices_param[device_id];
17431
17432 if (device_param->skipped) continue;
17433
17434 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17435 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17436 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17437
17438 device_param->kernel_params_mp_l_buf64[3] = 0;
17439 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17440 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17441 device_param->kernel_params_mp_l_buf32[6] = 0;
17442 device_param->kernel_params_mp_l_buf32[7] = 0;
17443 device_param->kernel_params_mp_l_buf32[8] = 0;
17444
17445 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17446 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17447 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17448 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17449
17450 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17451 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17452 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17453
17454 device_param->kernel_params_mp_r_buf64[3] = 0;
17455 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17456 device_param->kernel_params_mp_r_buf32[5] = 0;
17457 device_param->kernel_params_mp_r_buf32[6] = 0;
17458 device_param->kernel_params_mp_r_buf32[7] = 0;
17459
17460 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]);
17461 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]);
17462 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]);
17463
17464 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]);
17465 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]);
17466 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]);
17467
17468 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);
17469 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);
17470 }
17471 }
17472
17473 u64 words_base = data.words_cnt;
17474
17475 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17476 {
17477 if (data.kernel_rules_cnt)
17478 {
17479 words_base /= data.kernel_rules_cnt;
17480 }
17481 }
17482 else if (data.attack_kern == ATTACK_KERN_COMBI)
17483 {
17484 if (data.combs_cnt)
17485 {
17486 words_base /= data.combs_cnt;
17487 }
17488 }
17489 else if (data.attack_kern == ATTACK_KERN_BF)
17490 {
17491 if (data.bfs_cnt)
17492 {
17493 words_base /= data.bfs_cnt;
17494 }
17495 }
17496
17497 data.words_base = words_base;
17498
17499 if (keyspace == 1)
17500 {
17501 log_info ("%llu", (unsigned long long int) words_base);
17502
17503 return (0);
17504 }
17505
17506 if (data.words_cur > data.words_base)
17507 {
17508 log_error ("ERROR: restore value greater keyspace");
17509
17510 return (-1);
17511 }
17512
17513 if (data.words_cur)
17514 {
17515 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17516 {
17517 for (uint i = 0; i < data.salts_cnt; i++)
17518 {
17519 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17520 }
17521 }
17522 else if (data.attack_kern == ATTACK_KERN_COMBI)
17523 {
17524 for (uint i = 0; i < data.salts_cnt; i++)
17525 {
17526 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17527 }
17528 }
17529 else if (data.attack_kern == ATTACK_KERN_BF)
17530 {
17531 for (uint i = 0; i < data.salts_cnt; i++)
17532 {
17533 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17534 }
17535 }
17536 }
17537
17538 /*
17539 * Update loopback file
17540 */
17541
17542 if (loopback == 1)
17543 {
17544 time_t now;
17545
17546 time (&now);
17547
17548 uint random_num = get_random_num (0, 9999);
17549
17550 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17551
17552 data.loopback_file = loopback_file;
17553 }
17554
17555 /*
17556 * Update dictionary statistic
17557 */
17558
17559 if (keyspace == 0)
17560 {
17561 dictstat_fp = fopen (dictstat, "wb");
17562
17563 if (dictstat_fp)
17564 {
17565 lock_file (dictstat_fp);
17566
17567 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17568
17569 fclose (dictstat_fp);
17570 }
17571 }
17572
17573 /**
17574 * create autotune threads
17575 */
17576
17577 data.devices_status = STATUS_AUTOTUNE;
17578
17579 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17580
17581 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17582 {
17583 hc_device_param_t *device_param = &devices_param[device_id];
17584
17585 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17586 }
17587
17588 hc_thread_wait (data.devices_cnt, c_threads);
17589
17590 /*
17591 * Inform user about possible slow speeds
17592 */
17593
17594 uint hardware_power_all = 0;
17595
17596 uint kernel_power_all = 0;
17597
17598 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17599 {
17600 hc_device_param_t *device_param = &devices_param[device_id];
17601
17602 hardware_power_all += device_param->hardware_power;
17603
17604 kernel_power_all += device_param->kernel_power;
17605 }
17606
17607 data.hardware_power_all = hardware_power_all; // hardware_power_all is the same as kernel_power_all but without the influence of kernel_accel on the devices
17608
17609 data.kernel_power_all = kernel_power_all;
17610
17611 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17612 {
17613 if (data.words_base < kernel_power_all)
17614 {
17615 if (quiet == 0)
17616 {
17617 log_info ("ATTENTION!");
17618 log_info (" The wordlist or mask you are using is too small.");
17619 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17620 log_info (" The cracking speed will drop.");
17621 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17622 log_info ("");
17623 }
17624 }
17625 }
17626
17627 /**
17628 * create cracker threads
17629 */
17630
17631 data.devices_status = STATUS_RUNNING;
17632
17633 if (initial_restore_done == 0)
17634 {
17635 if (data.restore_disable == 0) cycle_restore ();
17636
17637 initial_restore_done = 1;
17638 }
17639
17640 hc_timer_set (&data.timer_running);
17641
17642 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17643 {
17644 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17645 {
17646 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17647 if (quiet == 0) fflush (stdout);
17648 }
17649 }
17650 else if (wordlist_mode == WL_MODE_STDIN)
17651 {
17652 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17653 if (data.quiet == 0) log_info ("");
17654 }
17655
17656 time_t runtime_start;
17657
17658 time (&runtime_start);
17659
17660 data.runtime_start = runtime_start;
17661
17662 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17663 {
17664 hc_device_param_t *device_param = &devices_param[device_id];
17665
17666 if (wordlist_mode == WL_MODE_STDIN)
17667 {
17668 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17669 }
17670 else
17671 {
17672 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17673 }
17674 }
17675
17676 hc_thread_wait (data.devices_cnt, c_threads);
17677
17678 local_free (c_threads);
17679
17680 data.restore = 0;
17681
17682 // finalize task
17683
17684 logfile_sub_var_uint ("status-after-work", data.devices_status);
17685
17686 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17687
17688 if (data.devices_status == STATUS_CRACKED) break;
17689 if (data.devices_status == STATUS_ABORTED) break;
17690
17691 if (data.devices_status == STATUS_BYPASS)
17692 {
17693 data.devices_status = STATUS_RUNNING;
17694 }
17695
17696 if (induction_dictionaries_cnt)
17697 {
17698 unlink (induction_dictionaries[0]);
17699 }
17700
17701 free (induction_dictionaries);
17702
17703 if (attack_mode != ATTACK_MODE_BF)
17704 {
17705 induction_dictionaries = scan_directory (induction_directory);
17706
17707 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17708 }
17709
17710 if (benchmark == 0)
17711 {
17712 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17713 {
17714 if (quiet == 0) clear_prompt ();
17715
17716 if (quiet == 0) log_info ("");
17717
17718 if (status == 1)
17719 {
17720 status_display ();
17721 }
17722 else
17723 {
17724 if (quiet == 0) status_display ();
17725 }
17726
17727 if (quiet == 0) log_info ("");
17728 }
17729 }
17730
17731 if (attack_mode == ATTACK_MODE_BF)
17732 {
17733 dictpos++;
17734
17735 rd->dictpos = dictpos;
17736 }
17737 else
17738 {
17739 if (induction_dictionaries_cnt)
17740 {
17741 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17742 }
17743 else
17744 {
17745 dictpos++;
17746
17747 rd->dictpos = dictpos;
17748 }
17749 }
17750
17751 time_t runtime_stop;
17752
17753 time (&runtime_stop);
17754
17755 data.runtime_stop = runtime_stop;
17756
17757 logfile_sub_uint (runtime_start);
17758 logfile_sub_uint (runtime_stop);
17759
17760 logfile_sub_msg ("STOP");
17761
17762 global_free (subid);
17763 }
17764
17765 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17766
17767 if (data.devices_status == STATUS_CRACKED) break;
17768 if (data.devices_status == STATUS_ABORTED) break;
17769 if (data.devices_status == STATUS_QUIT) break;
17770
17771 if (data.devices_status == STATUS_BYPASS)
17772 {
17773 data.devices_status = STATUS_RUNNING;
17774 }
17775 }
17776
17777 // 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
17778
17779 if (attack_mode == ATTACK_MODE_STRAIGHT)
17780 {
17781 if (data.wordlist_mode == WL_MODE_FILE)
17782 {
17783 if (data.dictfile == NULL)
17784 {
17785 if (dictfiles != NULL)
17786 {
17787 data.dictfile = dictfiles[0];
17788
17789 hc_timer_set (&data.timer_running);
17790 }
17791 }
17792 }
17793 }
17794 // NOTE: combi is okay because it is already set beforehand
17795 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17796 {
17797 if (data.dictfile == NULL)
17798 {
17799 if (dictfiles != NULL)
17800 {
17801 hc_timer_set (&data.timer_running);
17802
17803 data.dictfile = dictfiles[0];
17804 }
17805 }
17806 }
17807 else if (attack_mode == ATTACK_MODE_BF)
17808 {
17809 if (data.mask == NULL)
17810 {
17811 hc_timer_set (&data.timer_running);
17812
17813 data.mask = masks[0];
17814 }
17815 }
17816
17817 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17818 {
17819 data.devices_status = STATUS_EXHAUSTED;
17820 }
17821
17822 // if cracked / aborted remove last induction dictionary
17823
17824 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17825 {
17826 struct stat induct_stat;
17827
17828 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17829 {
17830 unlink (induction_dictionaries[file_pos]);
17831 }
17832 }
17833
17834 // wait for non-interactive threads
17835
17836 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17837 {
17838 hc_thread_wait (1, &ni_threads[thread_idx]);
17839 }
17840
17841 local_free (ni_threads);
17842
17843 // wait for interactive threads
17844
17845 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17846 {
17847 hc_thread_wait (1, &i_thread);
17848 }
17849
17850 // we dont need restore file anymore
17851 if (data.restore_disable == 0)
17852 {
17853 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17854 {
17855 unlink (eff_restore_file);
17856 unlink (new_restore_file);
17857 }
17858 else
17859 {
17860 cycle_restore ();
17861 }
17862 }
17863
17864 // finally save left hashes
17865
17866 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17867 {
17868 save_hash ();
17869 }
17870
17871 /**
17872 * Clean up
17873 */
17874
17875 if (benchmark == 1)
17876 {
17877 status_benchmark ();
17878
17879 if (machine_readable == 0)
17880 {
17881 log_info ("");
17882 }
17883 }
17884 else
17885 {
17886 if (quiet == 0) clear_prompt ();
17887
17888 if (quiet == 0) log_info ("");
17889
17890 if (status == 1)
17891 {
17892 status_display ();
17893 }
17894 else
17895 {
17896 if (quiet == 0) status_display ();
17897 }
17898
17899 if (quiet == 0) log_info ("");
17900 }
17901
17902 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17903 {
17904 hc_device_param_t *device_param = &data.devices_param[device_id];
17905
17906 if (device_param->skipped) continue;
17907
17908 local_free (device_param->combs_buf);
17909
17910 local_free (device_param->hooks_buf);
17911
17912 local_free (device_param->device_name);
17913
17914 local_free (device_param->device_name_chksum);
17915
17916 local_free (device_param->device_version);
17917
17918 local_free (device_param->driver_version);
17919
17920 if (device_param->pws_buf) myfree (device_param->pws_buf);
17921 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17922 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17923 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17924 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17925 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17926 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17927 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17928 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17929 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17930 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17931 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17932 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17933 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17934 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17935 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17936 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17937 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17938 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17939 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17940 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17941 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17942 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17943 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17944 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17945 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17946 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17947 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17948 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17949
17950 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17951 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17952 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17953 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17954 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17955 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17956 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17957 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17958 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17959 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17960 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17961
17962 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17963 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17964 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17965
17966 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17967 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17968 }
17969
17970 // reset default fan speed
17971
17972 #ifdef HAVE_HWMON
17973 if (gpu_temp_disable == 0)
17974 {
17975 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17976 {
17977 hc_thread_mutex_lock (mux_adl);
17978
17979 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17980 {
17981 hc_device_param_t *device_param = &data.devices_param[device_id];
17982
17983 if (device_param->skipped) continue;
17984
17985 if (data.hm_device[device_id].fan_set_supported == 1)
17986 {
17987 int fanspeed = temp_retain_fanspeed_value[device_id];
17988 int fanpolicy = temp_retain_fanpolicy_value[device_id];
17989
17990 if (fanpolicy == 1)
17991 {
17992 int rc = -1;
17993
17994 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17995 {
17996 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
17997 }
17998 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17999 {
18000
18001 }
18002
18003 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18004 }
18005 }
18006 }
18007
18008 hc_thread_mutex_unlock (mux_adl);
18009 }
18010 }
18011
18012 // reset power tuning
18013
18014 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18015 {
18016 hc_thread_mutex_lock (mux_adl);
18017
18018 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18019 {
18020 hc_device_param_t *device_param = &data.devices_param[device_id];
18021
18022 if (device_param->skipped) continue;
18023
18024 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18025 {
18026 if (data.hm_device[device_id].od_version == 6)
18027 {
18028 // check powertune capabilities first, if not available then skip device
18029
18030 int powertune_supported = 0;
18031
18032 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18033 {
18034 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18035
18036 return (-1);
18037 }
18038
18039 if (powertune_supported != 0)
18040 {
18041 // powercontrol settings
18042
18043 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18044 {
18045 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18046
18047 return (-1);
18048 }
18049
18050 // clocks
18051
18052 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18053
18054 performance_state->iNumberOfPerformanceLevels = 2;
18055
18056 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18057 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18058 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18059 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18060
18061 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18062 {
18063 log_info ("ERROR: Failed to restore ADL performance state");
18064
18065 return (-1);
18066 }
18067
18068 local_free (performance_state);
18069 }
18070 }
18071 }
18072
18073 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18074 {
18075 unsigned int limit = nvml_power_limit[device_id];
18076
18077 if (limit > 0)
18078 {
18079 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18080 }
18081 }
18082 }
18083
18084 hc_thread_mutex_unlock (mux_adl);
18085 }
18086
18087 if (gpu_temp_disable == 0)
18088 {
18089 if (data.hm_nvml)
18090 {
18091 hm_NVML_nvmlShutdown (data.hm_nvml);
18092
18093 nvml_close (data.hm_nvml);
18094
18095 data.hm_nvml = NULL;
18096 }
18097
18098 if (data.hm_adl)
18099 {
18100 hm_ADL_Main_Control_Destroy (data.hm_adl);
18101
18102 adl_close (data.hm_adl);
18103
18104 data.hm_adl = NULL;
18105 }
18106 }
18107 #endif // HAVE_HWMON
18108
18109 // free memory
18110
18111 local_free (masks);
18112
18113 local_free (dictstat_base);
18114
18115 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18116 {
18117 pot_t *pot_ptr = &pot[pot_pos];
18118
18119 hash_t *hash = &pot_ptr->hash;
18120
18121 local_free (hash->digest);
18122
18123 if (isSalted)
18124 {
18125 local_free (hash->salt);
18126 }
18127 }
18128
18129 local_free (pot);
18130
18131 local_free (all_kernel_rules_cnt);
18132 local_free (all_kernel_rules_buf);
18133
18134 local_free (wl_data->buf);
18135 local_free (wl_data);
18136
18137 local_free (bitmap_s1_a);
18138 local_free (bitmap_s1_b);
18139 local_free (bitmap_s1_c);
18140 local_free (bitmap_s1_d);
18141 local_free (bitmap_s2_a);
18142 local_free (bitmap_s2_b);
18143 local_free (bitmap_s2_c);
18144 local_free (bitmap_s2_d);
18145
18146 #ifdef HAVE_HWMON
18147 local_free (temp_retain_fanspeed_value);
18148 local_free (od_clock_mem_status);
18149 local_free (od_power_control_status);
18150 local_free (nvml_power_limit);
18151 #endif
18152
18153 global_free (devices_param);
18154
18155 global_free (kernel_rules_buf);
18156
18157 global_free (root_css_buf);
18158 global_free (markov_css_buf);
18159
18160 global_free (digests_buf);
18161 global_free (digests_shown);
18162 global_free (digests_shown_tmp);
18163
18164 global_free (salts_buf);
18165 global_free (salts_shown);
18166
18167 global_free (esalts_buf);
18168
18169 global_free (words_progress_done);
18170 global_free (words_progress_rejected);
18171 global_free (words_progress_restored);
18172
18173 if (pot_fp) fclose (pot_fp);
18174
18175 if (data.devices_status == STATUS_QUIT) break;
18176 }
18177
18178 // destroy others mutex
18179
18180 hc_thread_mutex_delete (mux_dispatcher);
18181 hc_thread_mutex_delete (mux_counter);
18182 hc_thread_mutex_delete (mux_display);
18183 hc_thread_mutex_delete (mux_adl);
18184
18185 // free memory
18186
18187 local_free (eff_restore_file);
18188 local_free (new_restore_file);
18189
18190 local_free (rd);
18191
18192 // tuning db
18193
18194 tuning_db_destroy (tuning_db);
18195
18196 // loopback
18197
18198 local_free (loopback_file);
18199
18200 if (loopback == 1) unlink (loopback_file);
18201
18202 // induction directory
18203
18204 if (induction_dir == NULL)
18205 {
18206 if (attack_mode != ATTACK_MODE_BF)
18207 {
18208 if (rmdir (induction_directory) == -1)
18209 {
18210 if (errno == ENOENT)
18211 {
18212 // good, we can ignore
18213 }
18214 else if (errno == ENOTEMPTY)
18215 {
18216 // good, we can ignore
18217 }
18218 else
18219 {
18220 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18221
18222 return (-1);
18223 }
18224 }
18225
18226 local_free (induction_directory);
18227 }
18228 }
18229
18230 // outfile-check directory
18231
18232 if (outfile_check_dir == NULL)
18233 {
18234 if (rmdir (outfile_check_directory) == -1)
18235 {
18236 if (errno == ENOENT)
18237 {
18238 // good, we can ignore
18239 }
18240 else if (errno == ENOTEMPTY)
18241 {
18242 // good, we can ignore
18243 }
18244 else
18245 {
18246 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18247
18248 return (-1);
18249 }
18250 }
18251
18252 local_free (outfile_check_directory);
18253 }
18254
18255 time_t proc_stop;
18256
18257 time (&proc_stop);
18258
18259 logfile_top_uint (proc_start);
18260 logfile_top_uint (proc_stop);
18261
18262 logfile_top_msg ("STOP");
18263
18264 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18265 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18266
18267 if (data.ocl) ocl_close (data.ocl);
18268
18269 if (data.devices_status == STATUS_ABORTED) return 2;
18270 if (data.devices_status == STATUS_QUIT) return 2;
18271 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18272 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18273 if (data.devices_status == STATUS_CRACKED) return 0;
18274
18275 return -1;
18276 }
18277
Hashcat additions to support pwdhash