projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix calling conventions for external libraries (mingw doesn't handle it alone); Fix...
[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 " 8100 | Citrix Netscaler | Operating-Systems",
580 " 8500 | RACF | Operating-Systems",
581 " 7200 | GRUB 2 | Operating-Systems",
582 " 9900 | Radmin2 | Operating-Systems",
583 " 125 | ArubaOS | Operating-Systems",
584 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
585 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
586 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
587 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
588 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
589 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
590 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
591 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
592 " 11600 | 7-Zip | Archives",
593 " 12500 | RAR3-hp | Archives",
594 " 13000 | RAR5 | Archives",
595 " 13200 | AxCrypt | Archives",
596 " 13300 | AxCrypt in memory SHA1 | Archives",
597 " 13600 | WinZip | Archives",
598 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
599 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
600 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
601 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
602 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
603 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
604 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
605 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
606 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
607 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
608 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
609 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
610 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
612 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
613 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
614 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
615 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
616 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
617 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
618 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
619 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
620 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
621 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
622 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
623 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
624 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
625 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
626 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
627 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
628 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
629 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
630 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
632 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
633 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
634 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
635 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
636 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
637 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
638 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
639 " 9400 | MS Office 2007 | Documents",
640 " 9500 | MS Office 2010 | Documents",
641 " 9600 | MS Office 2013 | Documents",
642 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
643 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
644 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
645 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
646 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
647 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
648 " 9000 | Password Safe v2 | Password Managers",
649 " 5200 | Password Safe v3 | Password Managers",
650 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
651 " 6600 | 1Password, agilekeychain | Password Managers",
652 " 8200 | 1Password, cloudkeychain | Password Managers",
653 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
654 " 12700 | Blockchain, My Wallet | Password Managers",
655 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
656 "",
657 "- [ Outfile Formats ] -",
658 "",
659 " # | Format",
660 " ===+========",
661 " 1 | hash[:salt]",
662 " 2 | plain",
663 " 3 | hash[:salt]:plain",
664 " 4 | hex_plain",
665 " 5 | hash[:salt]:hex_plain",
666 " 6 | plain:hex_plain",
667 " 7 | hash[:salt]:plain:hex_plain",
668 " 8 | crackpos",
669 " 9 | hash[:salt]:crack_pos",
670 " 10 | plain:crack_pos",
671 " 11 | hash[:salt]:plain:crack_pos",
672 " 12 | hex_plain:crack_pos",
673 " 13 | hash[:salt]:hex_plain:crack_pos",
674 " 14 | plain:hex_plain:crack_pos",
675 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
676 "",
677 "- [ Rule Debugging Modes ] -",
678 "",
679 " # | Format",
680 " ===+========",
681 " 1 | Finding-Rule",
682 " 2 | Original-Word",
683 " 3 | Original-Word:Finding-Rule",
684 " 4 | Original-Word:Finding-Rule:Processed-Word",
685 "",
686 "- [ Attack Modes ] -",
687 "",
688 " # | Mode",
689 " ===+======",
690 " 0 | Straight",
691 " 1 | Combination",
692 " 3 | Brute-force",
693 " 6 | Hybrid Wordlist + Mask",
694 " 7 | Hybrid Mask + Wordlist",
695 "",
696 "- [ Built-in Charsets ] -",
697 "",
698 " ? | Charset",
699 " ===+=========",
700 " l | abcdefghijklmnopqrstuvwxyz",
701 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
702 " d | 0123456789",
703 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
704 " a | ?l?u?d?s",
705 " b | 0x00 - 0xff",
706 "",
707 "- [ OpenCL Device Types ] -",
708 "",
709 " # | Device Type",
710 " ===+=============",
711 " 1 | CPU",
712 " 2 | GPU",
713 " 3 | FPGA, DSP, Co-Processor",
714 "",
715 "- [ Workload Profiles ] -",
716 "",
717 " # | Performance | Runtime | Power Consumption | Desktop Impact",
718 " ===+=============+=========+===================+=================",
719 " 1 | Low | 2 ms | Low | Minimal",
720 " 2 | Default | 12 ms | Economic | Noticeable",
721 " 3 | High | 96 ms | High | Unresponsive",
722 " 4 | Nightmare | 480 ms | Insane | Headless",
723 "",
724 "If you have no idea what just happened then visit the following pages:",
725 "",
726 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
727 "* https://hashcat.net/wiki/#frequently_asked_questions",
728 "",
729 NULL
730 };
731
732 /**
733 * hashcat specific functions
734 */
735
736 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
737 {
738 int exec_pos = (int) device_param->exec_pos - last_num_entries;
739
740 if (exec_pos < 0) exec_pos += EXEC_CACHE;
741
742 double exec_ms_sum = 0;
743
744 int exec_ms_cnt = 0;
745
746 for (int i = 0; i < last_num_entries; i++)
747 {
748 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
749
750 if (exec_ms)
751 {
752 exec_ms_sum += exec_ms;
753
754 exec_ms_cnt++;
755 }
756 }
757
758 if (exec_ms_cnt == 0) return 0;
759
760 return exec_ms_sum / exec_ms_cnt;
761 }
762
763 void status_display_machine_readable ()
764 {
765 FILE *out = stdout;
766
767 fprintf (out, "STATUS\t%u\t", data.devices_status);
768
769 /**
770 * speed new
771 */
772
773 fprintf (out, "SPEED\t");
774
775 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
776 {
777 hc_device_param_t *device_param = &data.devices_param[device_id];
778
779 if (device_param->skipped) continue;
780
781 u64 speed_cnt = 0;
782 double speed_ms = 0;
783
784 for (int i = 0; i < SPEED_CACHE; i++)
785 {
786 speed_cnt += device_param->speed_cnt[i];
787 speed_ms += device_param->speed_ms[i];
788 }
789
790 speed_cnt /= SPEED_CACHE;
791 speed_ms /= SPEED_CACHE;
792
793 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
794 }
795
796 /**
797 * exec time
798 */
799
800 fprintf (out, "EXEC_RUNTIME\t");
801
802 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
803 {
804 hc_device_param_t *device_param = &data.devices_param[device_id];
805
806 if (device_param->skipped) continue;
807
808 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
809
810 fprintf (out, "%f\t", exec_ms_avg);
811 }
812
813 /**
814 * words_cur
815 */
816
817 u64 words_cur = get_lowest_words_done ();
818
819 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
820
821 /**
822 * counter
823 */
824
825 u64 progress_total = data.words_cnt * data.salts_cnt;
826
827 u64 all_done = 0;
828 u64 all_rejected = 0;
829 u64 all_restored = 0;
830
831 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
832 {
833 all_done += data.words_progress_done[salt_pos];
834 all_rejected += data.words_progress_rejected[salt_pos];
835 all_restored += data.words_progress_restored[salt_pos];
836 }
837
838 u64 progress_cur = all_restored + all_done + all_rejected;
839 u64 progress_end = progress_total;
840
841 u64 progress_skip = 0;
842
843 if (data.skip)
844 {
845 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
846
847 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
848 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
849 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
850 }
851
852 if (data.limit)
853 {
854 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
855
856 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
857 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
858 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
859 }
860
861 u64 progress_cur_relative_skip = progress_cur - progress_skip;
862 u64 progress_end_relative_skip = progress_end - progress_skip;
863
864 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
865
866 /**
867 * cracks
868 */
869
870 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
871 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
872
873 /**
874 * temperature
875 */
876
877 #ifdef HAVE_HWMON
878 if (data.gpu_temp_disable == 0)
879 {
880 fprintf (out, "TEMP\t");
881
882 hc_thread_mutex_lock (mux_adl);
883
884 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
885 {
886 hc_device_param_t *device_param = &data.devices_param[device_id];
887
888 if (device_param->skipped) continue;
889
890 int temp = hm_get_temperature_with_device_id (device_id);
891
892 fprintf (out, "%d\t", temp);
893 }
894
895 hc_thread_mutex_unlock (mux_adl);
896 }
897 #endif // HAVE_HWMON
898
899 /**
900 * flush
901 */
902
903 #ifdef _WIN
904 fputc ('\r', out);
905 fputc ('\n', out);
906 #endif
907
908 #ifdef _POSIX
909 fputc ('\n', out);
910 #endif
911
912 fflush (out);
913 }
914
915 void status_display ()
916 {
917 if (data.devices_status == STATUS_INIT) return;
918 if (data.devices_status == STATUS_STARTING) return;
919 if (data.devices_status == STATUS_BYPASS) return;
920
921 if (data.machine_readable == 1)
922 {
923 status_display_machine_readable ();
924
925 return;
926 }
927
928 char tmp_buf[1000] = { 0 };
929
930 uint tmp_len = 0;
931
932 log_info ("Session.Name...: %s", data.session);
933
934 char *status_type = strstatus (data.devices_status);
935
936 uint hash_mode = data.hash_mode;
937
938 char *hash_type = strhashtype (hash_mode); // not a bug
939
940 log_info ("Status.........: %s", status_type);
941
942 /**
943 * show rules
944 */
945
946 if (data.rp_files_cnt)
947 {
948 uint i;
949
950 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
951 {
952 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
953 }
954
955 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
956
957 log_info ("Rules.Type.....: %s", tmp_buf);
958
959 tmp_len = 0;
960 }
961
962 if (data.rp_gen)
963 {
964 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
965
966 if (data.rp_gen_seed)
967 {
968 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
969 }
970 }
971
972 /**
973 * show input
974 */
975
976 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
977 {
978 if (data.wordlist_mode == WL_MODE_FILE)
979 {
980 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
981 }
982 else if (data.wordlist_mode == WL_MODE_STDIN)
983 {
984 log_info ("Input.Mode.....: Pipe");
985 }
986 }
987 else if (data.attack_mode == ATTACK_MODE_COMBI)
988 {
989 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
990 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
991 }
992 else if (data.attack_mode == ATTACK_MODE_BF)
993 {
994 char *mask = data.mask;
995
996 if (mask != NULL)
997 {
998 uint mask_len = data.css_cnt;
999
1000 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1001
1002 if (mask_len > 0)
1003 {
1004 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1005 {
1006 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1007 {
1008 mask_len -= data.salts_buf[0].salt_len;
1009 }
1010 }
1011
1012 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1013
1014 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1015 }
1016
1017 if (data.maskcnt > 1)
1018 {
1019 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1020
1021 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1022 }
1023
1024 log_info ("Input.Mode.....: %s", tmp_buf);
1025 }
1026
1027 tmp_len = 0;
1028 }
1029 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1030 {
1031 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1032 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1033 }
1034 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1035 {
1036 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1037 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1038 }
1039
1040 if (data.digests_cnt == 1)
1041 {
1042 if (data.hash_mode == 2500)
1043 {
1044 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1045
1046 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1047 (char *) data.salts_buf[0].salt_buf,
1048 wpa->orig_mac1[0],
1049 wpa->orig_mac1[1],
1050 wpa->orig_mac1[2],
1051 wpa->orig_mac1[3],
1052 wpa->orig_mac1[4],
1053 wpa->orig_mac1[5],
1054 wpa->orig_mac2[0],
1055 wpa->orig_mac2[1],
1056 wpa->orig_mac2[2],
1057 wpa->orig_mac2[3],
1058 wpa->orig_mac2[4],
1059 wpa->orig_mac2[5]);
1060 }
1061 else if (data.hash_mode == 5200)
1062 {
1063 log_info ("Hash.Target....: File (%s)", data.hashfile);
1064 }
1065 else if (data.hash_mode == 9000)
1066 {
1067 log_info ("Hash.Target....: File (%s)", data.hashfile);
1068 }
1069 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1070 {
1071 log_info ("Hash.Target....: File (%s)", data.hashfile);
1072 }
1073 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1074 {
1075 log_info ("Hash.Target....: File (%s)", data.hashfile);
1076 }
1077 else
1078 {
1079 char out_buf[HCBUFSIZ] = { 0 };
1080
1081 ascii_digest (out_buf, 0, 0);
1082
1083 // limit length
1084 if (strlen (out_buf) > 40)
1085 {
1086 out_buf[41] = '.';
1087 out_buf[42] = '.';
1088 out_buf[43] = '.';
1089 out_buf[44] = 0;
1090 }
1091
1092 log_info ("Hash.Target....: %s", out_buf);
1093 }
1094 }
1095 else
1096 {
1097 if (data.hash_mode == 3000)
1098 {
1099 char out_buf1[32] = { 0 };
1100 char out_buf2[32] = { 0 };
1101
1102 ascii_digest (out_buf1, 0, 0);
1103 ascii_digest (out_buf2, 0, 1);
1104
1105 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1106 }
1107 else
1108 {
1109 log_info ("Hash.Target....: File (%s)", data.hashfile);
1110 }
1111 }
1112
1113 log_info ("Hash.Type......: %s", hash_type);
1114
1115 /**
1116 * speed new
1117 */
1118
1119 u64 speed_cnt[DEVICES_MAX] = { 0 };
1120 double speed_ms[DEVICES_MAX] = { 0 };
1121
1122 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1123 {
1124 hc_device_param_t *device_param = &data.devices_param[device_id];
1125
1126 if (device_param->skipped) continue;
1127
1128 speed_cnt[device_id] = 0;
1129 speed_ms[device_id] = 0;
1130
1131 for (int i = 0; i < SPEED_CACHE; i++)
1132 {
1133 speed_cnt[device_id] += device_param->speed_cnt[i];
1134 speed_ms[device_id] += device_param->speed_ms[i];
1135 }
1136
1137 speed_cnt[device_id] /= SPEED_CACHE;
1138 speed_ms[device_id] /= SPEED_CACHE;
1139 }
1140
1141 double hashes_all_ms = 0;
1142
1143 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1144
1145 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1146 {
1147 hc_device_param_t *device_param = &data.devices_param[device_id];
1148
1149 if (device_param->skipped) continue;
1150
1151 hashes_dev_ms[device_id] = 0;
1152
1153 if (speed_ms[device_id])
1154 {
1155 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1156
1157 hashes_all_ms += hashes_dev_ms[device_id];
1158 }
1159 }
1160
1161 /**
1162 * exec time
1163 */
1164
1165 double exec_all_ms[DEVICES_MAX] = { 0 };
1166
1167 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1168 {
1169 hc_device_param_t *device_param = &data.devices_param[device_id];
1170
1171 if (device_param->skipped) continue;
1172
1173 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1174
1175 exec_all_ms[device_id] = exec_ms_avg;
1176 }
1177
1178 /**
1179 * timers
1180 */
1181
1182 double ms_running = 0;
1183
1184 hc_timer_get (data.timer_running, ms_running);
1185
1186 double ms_paused = data.ms_paused;
1187
1188 if (data.devices_status == STATUS_PAUSED)
1189 {
1190 double ms_paused_tmp = 0;
1191
1192 hc_timer_get (data.timer_paused, ms_paused_tmp);
1193
1194 ms_paused += ms_paused_tmp;
1195 }
1196
1197 #ifdef WIN
1198
1199 __time64_t sec_run = ms_running / 1000;
1200
1201 #else
1202
1203 time_t sec_run = ms_running / 1000;
1204
1205 #endif
1206
1207 if (sec_run)
1208 {
1209 char display_run[32] = { 0 };
1210
1211 struct tm tm_run;
1212
1213 struct tm *tmp = NULL;
1214
1215 #ifdef WIN
1216
1217 tmp = _gmtime64 (&sec_run);
1218
1219 #else
1220
1221 tmp = gmtime (&sec_run);
1222
1223 #endif
1224
1225 if (tmp != NULL)
1226 {
1227 memset (&tm_run, 0, sizeof (tm_run));
1228
1229 memcpy (&tm_run, tmp, sizeof (tm_run));
1230
1231 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1232
1233 char *start = ctime (&data.proc_start);
1234
1235 size_t start_len = strlen (start);
1236
1237 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1238 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1239
1240 log_info ("Time.Started...: %s (%s)", start, display_run);
1241 }
1242 }
1243 else
1244 {
1245 log_info ("Time.Started...: 0 secs");
1246 }
1247
1248 /**
1249 * counters
1250 */
1251
1252 u64 progress_total = data.words_cnt * data.salts_cnt;
1253
1254 u64 all_done = 0;
1255 u64 all_rejected = 0;
1256 u64 all_restored = 0;
1257
1258 u64 progress_noneed = 0;
1259
1260 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1261 {
1262 all_done += data.words_progress_done[salt_pos];
1263 all_rejected += data.words_progress_rejected[salt_pos];
1264 all_restored += data.words_progress_restored[salt_pos];
1265
1266 // Important for ETA only
1267
1268 if (data.salts_shown[salt_pos] == 1)
1269 {
1270 const u64 all = data.words_progress_done[salt_pos]
1271 + data.words_progress_rejected[salt_pos]
1272 + data.words_progress_restored[salt_pos];
1273
1274 const u64 left = data.words_cnt - all;
1275
1276 progress_noneed += left;
1277 }
1278 }
1279
1280 u64 progress_cur = all_restored + all_done + all_rejected;
1281 u64 progress_end = progress_total;
1282
1283 u64 progress_skip = 0;
1284
1285 if (data.skip)
1286 {
1287 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1288
1289 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1290 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1291 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1292 }
1293
1294 if (data.limit)
1295 {
1296 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1297
1298 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1299 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1300 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1301 }
1302
1303 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1304 u64 progress_end_relative_skip = progress_end - progress_skip;
1305
1306 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1307 {
1308 if (data.devices_status != STATUS_CRACKED)
1309 {
1310 #ifdef WIN
1311 __time64_t sec_etc = 0;
1312 #else
1313 time_t sec_etc = 0;
1314 #endif
1315
1316 if (hashes_all_ms)
1317 {
1318 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1319
1320 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1321
1322 sec_etc = ms_left / 1000;
1323 }
1324
1325 if (sec_etc == 0)
1326 {
1327 //log_info ("Time.Estimated.: 0 secs");
1328 }
1329 else if ((u64) sec_etc > ETC_MAX)
1330 {
1331 log_info ("Time.Estimated.: > 10 Years");
1332 }
1333 else
1334 {
1335 char display_etc[32] = { 0 };
1336
1337 struct tm tm_etc;
1338
1339 struct tm *tmp = NULL;
1340
1341 #ifdef WIN
1342
1343 tmp = _gmtime64 (&sec_etc);
1344
1345 #else
1346
1347 tmp = gmtime (&sec_etc);
1348
1349 #endif
1350
1351 if (tmp != NULL)
1352 {
1353 memset (&tm_etc, 0, sizeof (tm_etc));
1354
1355 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1356
1357 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1358
1359 time_t now;
1360
1361 time (&now);
1362
1363 now += sec_etc;
1364
1365 char *etc = ctime (&now);
1366
1367 size_t etc_len = strlen (etc);
1368
1369 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1370 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1371
1372 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1373 }
1374 }
1375 }
1376 }
1377
1378 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1379 {
1380 hc_device_param_t *device_param = &data.devices_param[device_id];
1381
1382 if (device_param->skipped) continue;
1383
1384 char display_dev_cur[16] = { 0 };
1385
1386 strncpy (display_dev_cur, "0.00", 4);
1387
1388 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1389
1390 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1391 }
1392
1393 char display_all_cur[16] = { 0 };
1394
1395 strncpy (display_all_cur, "0.00", 4);
1396
1397 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1398
1399 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1400
1401 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1402 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1403
1404 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);
1405
1406 // crack-per-time
1407
1408 if (data.digests_cnt > 100)
1409 {
1410 time_t now = time (NULL);
1411
1412 int cpt_cur_min = 0;
1413 int cpt_cur_hour = 0;
1414 int cpt_cur_day = 0;
1415
1416 for (int i = 0; i < CPT_BUF; i++)
1417 {
1418 const uint cracked = data.cpt_buf[i].cracked;
1419 const time_t timestamp = data.cpt_buf[i].timestamp;
1420
1421 if ((timestamp + 60) > now)
1422 {
1423 cpt_cur_min += cracked;
1424 }
1425
1426 if ((timestamp + 3600) > now)
1427 {
1428 cpt_cur_hour += cracked;
1429 }
1430
1431 if ((timestamp + 86400) > now)
1432 {
1433 cpt_cur_day += cracked;
1434 }
1435 }
1436
1437 double ms_real = ms_running - ms_paused;
1438
1439 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1440 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1441 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1442
1443 if ((data.cpt_start + 86400) < now)
1444 {
1445 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1446 cpt_cur_min,
1447 cpt_cur_hour,
1448 cpt_cur_day,
1449 cpt_avg_min,
1450 cpt_avg_hour,
1451 cpt_avg_day);
1452 }
1453 else if ((data.cpt_start + 3600) < now)
1454 {
1455 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1456 cpt_cur_min,
1457 cpt_cur_hour,
1458 cpt_avg_min,
1459 cpt_avg_hour,
1460 cpt_avg_day);
1461 }
1462 else if ((data.cpt_start + 60) < now)
1463 {
1464 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1465 cpt_cur_min,
1466 cpt_avg_min,
1467 cpt_avg_hour,
1468 cpt_avg_day);
1469 }
1470 else
1471 {
1472 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1473 cpt_avg_min,
1474 cpt_avg_hour,
1475 cpt_avg_day);
1476 }
1477 }
1478
1479 // Restore point
1480
1481 u64 restore_point = get_lowest_words_done ();
1482
1483 u64 restore_total = data.words_base;
1484
1485 float percent_restore = 0;
1486
1487 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1488
1489 if (progress_end_relative_skip)
1490 {
1491 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1492 {
1493 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1494 float percent_rejected = 0.0;
1495
1496 if (progress_cur)
1497 {
1498 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1499 }
1500
1501 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);
1502 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1503
1504 if (data.restore_disable == 0)
1505 {
1506 if (percent_finished != 1)
1507 {
1508 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1509 }
1510 }
1511 }
1512 }
1513 else
1514 {
1515 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1516 {
1517 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1518 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1519
1520 if (data.restore_disable == 0)
1521 {
1522 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1523 }
1524 }
1525 else
1526 {
1527 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1528 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1529
1530 // --restore not allowed if stdin is used -- really? why?
1531
1532 //if (data.restore_disable == 0)
1533 //{
1534 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1535 //}
1536 }
1537 }
1538
1539 #ifdef HAVE_HWMON
1540 if (data.gpu_temp_disable == 0)
1541 {
1542 hc_thread_mutex_lock (mux_adl);
1543
1544 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1545 {
1546 hc_device_param_t *device_param = &data.devices_param[device_id];
1547
1548 if (device_param->skipped) continue;
1549
1550 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1551 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1552 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1553 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1554 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1555 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1556 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1557
1558 char output_buf[256] = { 0 };
1559
1560 int output_len = 0;
1561
1562 if (num_temperature >= 0)
1563 {
1564 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1565
1566 output_len = strlen (output_buf);
1567 }
1568
1569 if (num_fanspeed >= 0)
1570 {
1571 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1572
1573 output_len = strlen (output_buf);
1574 }
1575
1576 if (num_utilization >= 0)
1577 {
1578 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1579
1580 output_len = strlen (output_buf);
1581 }
1582
1583 if (num_corespeed >= 0)
1584 {
1585 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1586
1587 output_len = strlen (output_buf);
1588 }
1589
1590 if (num_memoryspeed >= 0)
1591 {
1592 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1593
1594 output_len = strlen (output_buf);
1595 }
1596
1597 if (num_buslanes >= 0)
1598 {
1599 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1600
1601 output_len = strlen (output_buf);
1602 }
1603
1604 if (num_throttle == 1)
1605 {
1606 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1607
1608 output_len = strlen (output_buf);
1609 }
1610
1611 if (output_len == 0)
1612 {
1613 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1614
1615 output_len = strlen (output_buf);
1616 }
1617
1618 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1619 }
1620
1621 hc_thread_mutex_unlock (mux_adl);
1622 }
1623 #endif // HAVE_HWMON
1624 }
1625
1626 static void status_benchmark_automate ()
1627 {
1628 u64 speed_cnt[DEVICES_MAX] = { 0 };
1629 double speed_ms[DEVICES_MAX] = { 0 };
1630
1631 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1632 {
1633 hc_device_param_t *device_param = &data.devices_param[device_id];
1634
1635 if (device_param->skipped) continue;
1636
1637 speed_cnt[device_id] = device_param->speed_cnt[0];
1638 speed_ms[device_id] = device_param->speed_ms[0];
1639 }
1640
1641 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1642
1643 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1644 {
1645 hc_device_param_t *device_param = &data.devices_param[device_id];
1646
1647 if (device_param->skipped) continue;
1648
1649 hashes_dev_ms[device_id] = 0;
1650
1651 if (speed_ms[device_id])
1652 {
1653 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1654 }
1655 }
1656
1657 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1658 {
1659 hc_device_param_t *device_param = &data.devices_param[device_id];
1660
1661 if (device_param->skipped) continue;
1662
1663 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1664 }
1665 }
1666
1667 static void status_benchmark ()
1668 {
1669 if (data.devices_status == STATUS_INIT) return;
1670 if (data.devices_status == STATUS_STARTING) return;
1671 if (data.devices_status == STATUS_BYPASS) return;
1672
1673 if (data.machine_readable == 1)
1674 {
1675 status_benchmark_automate ();
1676
1677 return;
1678 }
1679
1680 u64 speed_cnt[DEVICES_MAX] = { 0 };
1681 double speed_ms[DEVICES_MAX] = { 0 };
1682
1683 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1684 {
1685 hc_device_param_t *device_param = &data.devices_param[device_id];
1686
1687 if (device_param->skipped) continue;
1688
1689 speed_cnt[device_id] = device_param->speed_cnt[0];
1690 speed_ms[device_id] = device_param->speed_ms[0];
1691 }
1692
1693 double hashes_all_ms = 0;
1694
1695 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1696
1697 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1698 {
1699 hc_device_param_t *device_param = &data.devices_param[device_id];
1700
1701 if (device_param->skipped) continue;
1702
1703 hashes_dev_ms[device_id] = 0;
1704
1705 if (speed_ms[device_id])
1706 {
1707 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1708
1709 hashes_all_ms += hashes_dev_ms[device_id];
1710 }
1711 }
1712
1713 /**
1714 * exec time
1715 */
1716
1717 double exec_all_ms[DEVICES_MAX] = { 0 };
1718
1719 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1720 {
1721 hc_device_param_t *device_param = &data.devices_param[device_id];
1722
1723 if (device_param->skipped) continue;
1724
1725 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1726
1727 exec_all_ms[device_id] = exec_ms_avg;
1728 }
1729
1730 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1731 {
1732 hc_device_param_t *device_param = &data.devices_param[device_id];
1733
1734 if (device_param->skipped) continue;
1735
1736 char display_dev_cur[16] = { 0 };
1737
1738 strncpy (display_dev_cur, "0.00", 4);
1739
1740 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1741
1742 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1743 }
1744
1745 char display_all_cur[16] = { 0 };
1746
1747 strncpy (display_all_cur, "0.00", 4);
1748
1749 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1750
1751 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1752 }
1753
1754 /**
1755 * hashcat -only- functions
1756 */
1757
1758 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1759 {
1760 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1761 {
1762 if (attack_kern == ATTACK_KERN_STRAIGHT)
1763 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1764 else if (attack_kern == ATTACK_KERN_COMBI)
1765 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1766 else if (attack_kern == ATTACK_KERN_BF)
1767 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1768 }
1769 else
1770 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1771 }
1772
1773 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)
1774 {
1775 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1776 {
1777 if (attack_kern == ATTACK_KERN_STRAIGHT)
1778 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1779 else if (attack_kern == ATTACK_KERN_COMBI)
1780 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1781 else if (attack_kern == ATTACK_KERN_BF)
1782 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1783 }
1784 else
1785 {
1786 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1787 }
1788 }
1789
1790 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1791 {
1792 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1793 {
1794 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1795 }
1796 else
1797 {
1798 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1799 }
1800 }
1801
1802 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)
1803 {
1804 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1805 {
1806 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1807 }
1808 else
1809 {
1810 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1811 }
1812 }
1813
1814 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1815 {
1816 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1817 }
1818
1819 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1820 {
1821 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1822 }
1823
1824 static uint convert_from_hex (char *line_buf, const uint line_len)
1825 {
1826 if (line_len & 1) return (line_len); // not in hex
1827
1828 if (data.hex_wordlist == 1)
1829 {
1830 uint i;
1831 uint j;
1832
1833 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1834 {
1835 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1836 }
1837
1838 memset (line_buf + i, 0, line_len - i);
1839
1840 return (i);
1841 }
1842 else if (line_len >= 6) // $HEX[] = 6
1843 {
1844 if (line_buf[0] != '$') return (line_len);
1845 if (line_buf[1] != 'H') return (line_len);
1846 if (line_buf[2] != 'E') return (line_len);
1847 if (line_buf[3] != 'X') return (line_len);
1848 if (line_buf[4] != '[') return (line_len);
1849 if (line_buf[line_len - 1] != ']') return (line_len);
1850
1851 uint i;
1852 uint j;
1853
1854 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1855 {
1856 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1857 }
1858
1859 memset (line_buf + i, 0, line_len - i);
1860
1861 return (i);
1862 }
1863
1864 return (line_len);
1865 }
1866
1867 static void clear_prompt ()
1868 {
1869 fputc ('\r', stdout);
1870
1871 for (size_t i = 0; i < strlen (PROMPT); i++)
1872 {
1873 fputc (' ', stdout);
1874 }
1875
1876 fputc ('\r', stdout);
1877
1878 fflush (stdout);
1879 }
1880
1881 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1882 {
1883 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);
1884 }
1885
1886 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1887 {
1888 char *outfile = data.outfile;
1889 uint quiet = data.quiet;
1890 FILE *pot_fp = data.pot_fp;
1891 uint loopback = data.loopback;
1892 uint debug_mode = data.debug_mode;
1893 char *debug_file = data.debug_file;
1894
1895 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1896 int debug_rule_len = 0; // -1 error
1897 uint debug_plain_len = 0;
1898
1899 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1900
1901 // hash
1902
1903 char out_buf[HCBUFSIZ] = { 0 };
1904
1905 const u32 salt_pos = plain->salt_pos;
1906 const u32 digest_pos = plain->digest_pos; // relative
1907 const u32 gidvid = plain->gidvid;
1908 const u32 il_pos = plain->il_pos;
1909
1910 ascii_digest (out_buf, salt_pos, digest_pos);
1911
1912 // plain
1913
1914 u64 crackpos = device_param->words_off;
1915
1916 uint plain_buf[16] = { 0 };
1917
1918 u8 *plain_ptr = (u8 *) plain_buf;
1919
1920 unsigned int plain_len = 0;
1921
1922 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1923 {
1924 pw_t pw;
1925
1926 gidd_to_pw_t (device_param, gidvid, &pw);
1927
1928 for (int i = 0; i < 16; i++)
1929 {
1930 plain_buf[i] = pw.i[i];
1931 }
1932
1933 plain_len = pw.pw_len;
1934
1935 const uint off = device_param->innerloop_pos + il_pos;
1936
1937 if (debug_mode > 0)
1938 {
1939 debug_rule_len = 0;
1940
1941 // save rule
1942 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1943 {
1944 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1945
1946 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1947 }
1948
1949 // save plain
1950 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1951 {
1952 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1953
1954 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1955
1956 debug_plain_len = plain_len;
1957 }
1958 }
1959
1960 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1961
1962 crackpos += gidvid;
1963 crackpos *= data.kernel_rules_cnt;
1964 crackpos += device_param->innerloop_pos + il_pos;
1965
1966 if (plain_len > data.pw_max) plain_len = data.pw_max;
1967 }
1968 else if (data.attack_mode == ATTACK_MODE_COMBI)
1969 {
1970 pw_t pw;
1971
1972 gidd_to_pw_t (device_param, gidvid, &pw);
1973
1974 for (int i = 0; i < 16; i++)
1975 {
1976 plain_buf[i] = pw.i[i];
1977 }
1978
1979 plain_len = pw.pw_len;
1980
1981 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1982 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1983
1984 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1985 {
1986 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1987 }
1988 else
1989 {
1990 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1991
1992 memcpy (plain_ptr, comb_buf, comb_len);
1993 }
1994
1995 plain_len += comb_len;
1996
1997 crackpos += gidvid;
1998 crackpos *= data.combs_cnt;
1999 crackpos += device_param->innerloop_pos + il_pos;
2000
2001 if (data.pw_max != PW_DICTMAX1)
2002 {
2003 if (plain_len > data.pw_max) plain_len = data.pw_max;
2004 }
2005 }
2006 else if (data.attack_mode == ATTACK_MODE_BF)
2007 {
2008 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2009 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2010
2011 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2012 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2013
2014 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2015 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2016
2017 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2018 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2019
2020 plain_len = data.css_cnt;
2021
2022 crackpos += gidvid;
2023 crackpos *= data.bfs_cnt;
2024 crackpos += device_param->innerloop_pos + il_pos;
2025 }
2026 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2027 {
2028 pw_t pw;
2029
2030 gidd_to_pw_t (device_param, gidvid, &pw);
2031
2032 for (int i = 0; i < 16; i++)
2033 {
2034 plain_buf[i] = pw.i[i];
2035 }
2036
2037 plain_len = pw.pw_len;
2038
2039 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2040
2041 uint start = 0;
2042 uint stop = device_param->kernel_params_mp_buf32[4];
2043
2044 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2045
2046 plain_len += start + stop;
2047
2048 crackpos += gidvid;
2049 crackpos *= data.combs_cnt;
2050 crackpos += device_param->innerloop_pos + il_pos;
2051
2052 if (data.pw_max != PW_DICTMAX1)
2053 {
2054 if (plain_len > data.pw_max) plain_len = data.pw_max;
2055 }
2056 }
2057 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2058 {
2059 pw_t pw;
2060
2061 gidd_to_pw_t (device_param, gidvid, &pw);
2062
2063 for (int i = 0; i < 16; i++)
2064 {
2065 plain_buf[i] = pw.i[i];
2066 }
2067
2068 plain_len = pw.pw_len;
2069
2070 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2071
2072 uint start = 0;
2073 uint stop = device_param->kernel_params_mp_buf32[4];
2074
2075 memmove (plain_ptr + stop, plain_ptr, plain_len);
2076
2077 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2078
2079 plain_len += start + stop;
2080
2081 crackpos += gidvid;
2082 crackpos *= data.combs_cnt;
2083 crackpos += device_param->innerloop_pos + il_pos;
2084
2085 if (data.pw_max != PW_DICTMAX1)
2086 {
2087 if (plain_len > data.pw_max) plain_len = data.pw_max;
2088 }
2089 }
2090
2091 if (data.attack_mode == ATTACK_MODE_BF)
2092 {
2093 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2094 {
2095 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2096 {
2097 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2098 {
2099 plain_len = plain_len - data.salts_buf[0].salt_len;
2100 }
2101 }
2102
2103 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2104 {
2105 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2106 {
2107 plain_ptr[j] = plain_ptr[i];
2108 }
2109
2110 plain_len = plain_len / 2;
2111 }
2112 }
2113 }
2114
2115 // if enabled, update also the potfile
2116
2117 if (pot_fp)
2118 {
2119 lock_file (pot_fp);
2120
2121 fprintf (pot_fp, "%s:", out_buf);
2122
2123 format_plain (pot_fp, plain_ptr, plain_len, 1);
2124
2125 fputc ('\n', pot_fp);
2126
2127 fflush (pot_fp);
2128
2129 unlock_file (pot_fp);
2130 }
2131
2132 // outfile
2133
2134 FILE *out_fp = NULL;
2135
2136 if (outfile != NULL)
2137 {
2138 if ((out_fp = fopen (outfile, "ab")) == NULL)
2139 {
2140 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2141
2142 out_fp = stdout;
2143 }
2144
2145 lock_file (out_fp);
2146 }
2147 else
2148 {
2149 out_fp = stdout;
2150
2151 if (quiet == 0) clear_prompt ();
2152 }
2153
2154 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2155
2156 if (outfile != NULL)
2157 {
2158 if (out_fp != stdout)
2159 {
2160 fclose (out_fp);
2161 }
2162 }
2163 else
2164 {
2165 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2166 {
2167 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2168 {
2169 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2170 if (quiet == 0) fflush (stdout);
2171 }
2172 }
2173 }
2174
2175 // loopback
2176
2177 if (loopback)
2178 {
2179 char *loopback_file = data.loopback_file;
2180
2181 FILE *fb_fp = NULL;
2182
2183 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2184 {
2185 lock_file (fb_fp);
2186
2187 format_plain (fb_fp, plain_ptr, plain_len, 1);
2188
2189 fputc ('\n', fb_fp);
2190
2191 fclose (fb_fp);
2192 }
2193 }
2194
2195 // (rule) debug mode
2196
2197 // the next check implies that:
2198 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2199 // - debug_mode > 0
2200
2201 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2202 {
2203 if (debug_rule_len < 0) debug_rule_len = 0;
2204
2205 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2206
2207 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2208
2209 if ((quiet == 0) && (debug_file == NULL))
2210 {
2211 fprintf (stdout, "%s", PROMPT);
2212
2213 fflush (stdout);
2214 }
2215 }
2216 }
2217
2218 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2219 {
2220 salt_t *salt_buf = &data.salts_buf[salt_pos];
2221
2222 u32 num_cracked;
2223
2224 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2225
2226 if (num_cracked)
2227 {
2228 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2229
2230 log_info_nn ("");
2231
2232 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2233
2234 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);
2235
2236 uint cpt_cracked = 0;
2237
2238 for (uint i = 0; i < num_cracked; i++)
2239 {
2240 const uint hash_pos = cracked[i].hash_pos;
2241
2242 if (data.digests_shown[hash_pos] == 1) continue;
2243
2244 hc_thread_mutex_lock (mux_display);
2245
2246 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2247 {
2248 data.digests_shown[hash_pos] = 1;
2249
2250 data.digests_done++;
2251
2252 cpt_cracked++;
2253
2254 salt_buf->digests_done++;
2255
2256 if (salt_buf->digests_done == salt_buf->digests_cnt)
2257 {
2258 data.salts_shown[salt_pos] = 1;
2259
2260 data.salts_done++;
2261 }
2262 }
2263
2264 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2265
2266 hc_thread_mutex_unlock (mux_display);
2267
2268 check_hash (device_param, &cracked[i]);
2269 }
2270
2271 myfree (cracked);
2272
2273 if (cpt_cracked > 0)
2274 {
2275 hc_thread_mutex_lock (mux_display);
2276
2277 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2278 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2279
2280 data.cpt_pos++;
2281
2282 data.cpt_total += cpt_cracked;
2283
2284 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2285
2286 hc_thread_mutex_unlock (mux_display);
2287 }
2288
2289 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2290 {
2291 // we need to reset cracked state on the device
2292 // otherwise host thinks again and again the hash was cracked
2293 // and returns invalid password each time
2294
2295 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2296
2297 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);
2298 }
2299
2300 num_cracked = 0;
2301
2302 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2303 }
2304 }
2305
2306 static void save_hash ()
2307 {
2308 char *hashfile = data.hashfile;
2309
2310 char new_hashfile[256] = { 0 };
2311 char old_hashfile[256] = { 0 };
2312
2313 snprintf (new_hashfile, 255, "%s.new", hashfile);
2314 snprintf (old_hashfile, 255, "%s.old", hashfile);
2315
2316 unlink (new_hashfile);
2317
2318 char separator = data.separator;
2319
2320 FILE *fp = fopen (new_hashfile, "wb");
2321
2322 if (fp == NULL)
2323 {
2324 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2325
2326 exit (-1);
2327 }
2328
2329 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2330 {
2331 if (data.salts_shown[salt_pos] == 1) continue;
2332
2333 salt_t *salt_buf = &data.salts_buf[salt_pos];
2334
2335 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2336 {
2337 uint idx = salt_buf->digests_offset + digest_pos;
2338
2339 if (data.digests_shown[idx] == 1) continue;
2340
2341 if (data.hash_mode != 2500)
2342 {
2343 char out_buf[HCBUFSIZ] = { 0 };
2344
2345 if (data.username == 1)
2346 {
2347 user_t *user = data.hash_info[idx]->user;
2348
2349 uint i;
2350
2351 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2352
2353 fputc (separator, fp);
2354 }
2355
2356 ascii_digest (out_buf, salt_pos, digest_pos);
2357
2358 fputs (out_buf, fp);
2359
2360 log_out (fp, "");
2361 }
2362 else
2363 {
2364 hccap_t hccap;
2365
2366 to_hccap_t (&hccap, salt_pos, digest_pos);
2367
2368 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2369 }
2370 }
2371 }
2372
2373 fflush (fp);
2374
2375 fclose (fp);
2376
2377 unlink (old_hashfile);
2378
2379 if (rename (hashfile, old_hashfile) != 0)
2380 {
2381 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2382
2383 exit (-1);
2384 }
2385
2386 unlink (hashfile);
2387
2388 if (rename (new_hashfile, hashfile) != 0)
2389 {
2390 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2391
2392 exit (-1);
2393 }
2394
2395 unlink (old_hashfile);
2396 }
2397
2398 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2399 {
2400 // function called only in case kernel_power_all > words_left
2401
2402 float kernel_power_div = (float) (total_left) / kernel_power_all;
2403
2404 kernel_power_div += kernel_power_div / 100;
2405
2406 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2407
2408 while (kernel_power_new < total_left)
2409 {
2410 kernel_power_div += kernel_power_div / 100;
2411
2412 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2413 }
2414
2415 if (data.quiet == 0)
2416 {
2417 clear_prompt ();
2418
2419 //log_info ("");
2420
2421 log_info ("INFO: approaching final keyspace, workload adjusted");
2422 log_info ("");
2423
2424 fprintf (stdout, "%s", PROMPT);
2425
2426 fflush (stdout);
2427 }
2428
2429 //if ((kernel_power_all * kernel_power_div) < 8) return 1;
2430
2431 return kernel_power_div;
2432 }
2433
2434 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2435 {
2436 uint num_elements = num;
2437
2438 device_param->kernel_params_buf32[30] = data.combs_mode;
2439 device_param->kernel_params_buf32[31] = num;
2440
2441 uint kernel_threads = device_param->kernel_threads;
2442
2443 while (num_elements % kernel_threads) num_elements++;
2444
2445 cl_kernel kernel = NULL;
2446
2447 switch (kern_run)
2448 {
2449 case KERN_RUN_1: kernel = device_param->kernel1; break;
2450 case KERN_RUN_12: kernel = device_param->kernel12; break;
2451 case KERN_RUN_2: kernel = device_param->kernel2; break;
2452 case KERN_RUN_23: kernel = device_param->kernel23; break;
2453 case KERN_RUN_3: kernel = device_param->kernel3; break;
2454 }
2455
2456 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2457 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2458 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2459 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2460 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2461 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2462 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2463 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2464 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2465 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2466 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2467
2468 cl_event event;
2469
2470 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2471 {
2472 const size_t global_work_size[3] = { num_elements, 32, 1 };
2473 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2474
2475 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2476 }
2477 else
2478 {
2479 if (kern_run == KERN_RUN_2)
2480 {
2481 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2482 {
2483 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2484 }
2485 }
2486
2487 while (num_elements % kernel_threads) num_elements++;
2488
2489 const size_t global_work_size[3] = { num_elements, 1, 1 };
2490 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2491
2492 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2493 }
2494
2495 hc_clFlush (data.ocl, device_param->command_queue);
2496
2497 hc_clWaitForEvents (data.ocl, 1, &event);
2498
2499 if (event_update)
2500 {
2501 cl_ulong time_start;
2502 cl_ulong time_end;
2503
2504 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2505 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2506
2507 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2508
2509 uint exec_pos = device_param->exec_pos;
2510
2511 device_param->exec_ms[exec_pos] = exec_time;
2512
2513 exec_pos++;
2514
2515 if (exec_pos == EXEC_CACHE)
2516 {
2517 exec_pos = 0;
2518 }
2519
2520 device_param->exec_pos = exec_pos;
2521 }
2522
2523 hc_clReleaseEvent (data.ocl, event);
2524
2525 hc_clFinish (data.ocl, device_param->command_queue);
2526 }
2527
2528 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2529 {
2530 uint num_elements = num;
2531
2532 switch (kern_run)
2533 {
2534 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2535 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2536 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2537 }
2538
2539 // causes problems with special threads like in bcrypt
2540 // const uint kernel_threads = device_param->kernel_threads;
2541
2542 uint kernel_threads = device_param->kernel_threads;
2543
2544 while (num_elements % kernel_threads) num_elements++;
2545
2546 cl_kernel kernel = NULL;
2547
2548 switch (kern_run)
2549 {
2550 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2551 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2552 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2553 }
2554
2555 switch (kern_run)
2556 {
2557 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2558 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2559 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2560 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2561 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2562 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2563 break;
2564 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2565 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2566 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2567 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2568 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2569 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2570 break;
2571 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2572 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2573 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2574 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2575 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2576 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2577 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2578 break;
2579 }
2580
2581 const size_t global_work_size[3] = { num_elements, 1, 1 };
2582 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2583
2584 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2585
2586 hc_clFlush (data.ocl, device_param->command_queue);
2587
2588 hc_clFinish (data.ocl, device_param->command_queue);
2589 }
2590
2591 static void run_kernel_tm (hc_device_param_t *device_param)
2592 {
2593 const uint num_elements = 1024; // fixed
2594
2595 uint kernel_threads = 32;
2596
2597 cl_kernel kernel = device_param->kernel_tm;
2598
2599 const size_t global_work_size[3] = { num_elements, 1, 1 };
2600 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2601
2602 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2603
2604 hc_clFlush (data.ocl, device_param->command_queue);
2605
2606 hc_clFinish (data.ocl, device_param->command_queue);
2607 }
2608
2609 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2610 {
2611 uint num_elements = num;
2612
2613 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2614 device_param->kernel_params_amp_buf32[6] = num_elements;
2615
2616 // causes problems with special threads like in bcrypt
2617 // const uint kernel_threads = device_param->kernel_threads;
2618
2619 uint kernel_threads = device_param->kernel_threads;
2620
2621 while (num_elements % kernel_threads) num_elements++;
2622
2623 cl_kernel kernel = device_param->kernel_amp;
2624
2625 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2626 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2627
2628 const size_t global_work_size[3] = { num_elements, 1, 1 };
2629 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2630
2631 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2632
2633 hc_clFlush (data.ocl, device_param->command_queue);
2634
2635 hc_clFinish (data.ocl, device_param->command_queue);
2636 }
2637
2638 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2639 {
2640 const u32 num16d = num / 16;
2641 const u32 num16m = num % 16;
2642
2643 if (num16d)
2644 {
2645 device_param->kernel_params_memset_buf32[1] = value;
2646 device_param->kernel_params_memset_buf32[2] = num16d;
2647
2648 uint kernel_threads = device_param->kernel_threads;
2649
2650 uint num_elements = num16d;
2651
2652 while (num_elements % kernel_threads) num_elements++;
2653
2654 cl_kernel kernel = device_param->kernel_memset;
2655
2656 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2657 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2658 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2659
2660 const size_t global_work_size[3] = { num_elements, 1, 1 };
2661 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2662
2663 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2664
2665 hc_clFlush (data.ocl, device_param->command_queue);
2666
2667 hc_clFinish (data.ocl, device_param->command_queue);
2668 }
2669
2670 if (num16m)
2671 {
2672 u32 tmp[4];
2673
2674 tmp[0] = value;
2675 tmp[1] = value;
2676 tmp[2] = value;
2677 tmp[3] = value;
2678
2679 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2680 }
2681 }
2682
2683 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2684 {
2685 run_kernel_memset (device_param, buf, 0, size);
2686
2687 /*
2688 int rc = -1;
2689
2690 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2691 {
2692 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2693
2694 const cl_uchar zero = 0;
2695
2696 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2697 }
2698
2699 if (rc != 0)
2700 {
2701 // NOTE: clEnqueueFillBuffer () always fails with -59
2702 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2703 // How's that possible, OpenCL 1.2 support is advertised??
2704 // We need to workaround...
2705
2706 #define FILLSZ 0x100000
2707
2708 char *tmp = (char *) mymalloc (FILLSZ);
2709
2710 for (size_t i = 0; i < size; i += FILLSZ)
2711 {
2712 const size_t left = size - i;
2713
2714 const size_t fillsz = MIN (FILLSZ, left);
2715
2716 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2717 }
2718
2719 myfree (tmp);
2720 }
2721 */
2722 }
2723
2724 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)
2725 {
2726 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2727 {
2728 if (attack_mode == ATTACK_MODE_BF)
2729 {
2730 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2731 {
2732 const uint size_tm = 32 * sizeof (bs_word_t);
2733
2734 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2735
2736 run_kernel_tm (device_param);
2737
2738 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);
2739 }
2740 }
2741
2742 if (highest_pw_len < 16)
2743 {
2744 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2745 }
2746 else if (highest_pw_len < 32)
2747 {
2748 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2749 }
2750 else
2751 {
2752 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2753 }
2754 }
2755 else
2756 {
2757 run_kernel_amp (device_param, pws_cnt);
2758
2759 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2760
2761 if (opts_type & OPTS_TYPE_HOOK12)
2762 {
2763 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2764 }
2765
2766 uint iter = salt_buf->salt_iter;
2767
2768 uint loop_step = device_param->kernel_loops;
2769
2770 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2771 {
2772 uint loop_left = iter - loop_pos;
2773
2774 loop_left = MIN (loop_left, loop_step);
2775
2776 device_param->kernel_params_buf32[25] = loop_pos;
2777 device_param->kernel_params_buf32[26] = loop_left;
2778
2779 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2780
2781 if (data.devices_status == STATUS_CRACKED) break;
2782 if (data.devices_status == STATUS_ABORTED) break;
2783 if (data.devices_status == STATUS_QUIT) break;
2784
2785 /**
2786 * speed
2787 */
2788
2789 const float iter_part = (float) (loop_pos + loop_left) / iter;
2790
2791 const u64 perf_sum_all = pws_cnt * iter_part;
2792
2793 double speed_ms;
2794
2795 hc_timer_get (device_param->timer_speed, speed_ms);
2796
2797 const u32 speed_pos = device_param->speed_pos;
2798
2799 device_param->speed_cnt[speed_pos] = perf_sum_all;
2800
2801 device_param->speed_ms[speed_pos] = speed_ms;
2802
2803 if (data.benchmark == 1)
2804 {
2805 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2806 }
2807 }
2808
2809 if (opts_type & OPTS_TYPE_HOOK23)
2810 {
2811 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2812
2813 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);
2814
2815 // do something with data
2816
2817 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);
2818 }
2819
2820 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2821 }
2822 }
2823
2824 static int run_rule_engine (const int rule_len, const char *rule_buf)
2825 {
2826 if (rule_len == 0)
2827 {
2828 return 0;
2829 }
2830 else if (rule_len == 1)
2831 {
2832 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2833 }
2834
2835 return 1;
2836 }
2837
2838 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2839 {
2840 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2841 {
2842 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);
2843 }
2844 else if (data.attack_kern == ATTACK_KERN_COMBI)
2845 {
2846 if (data.attack_mode == ATTACK_MODE_COMBI)
2847 {
2848 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2849 {
2850 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2851 {
2852 for (u32 i = 0; i < pws_cnt; i++)
2853 {
2854 const u32 pw_len = device_param->pws_buf[i].pw_len;
2855
2856 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2857
2858 ptr[pw_len] = 0x01;
2859 }
2860 }
2861 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2862 {
2863 for (u32 i = 0; i < pws_cnt; i++)
2864 {
2865 const u32 pw_len = device_param->pws_buf[i].pw_len;
2866
2867 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2868
2869 ptr[pw_len] = 0x80;
2870 }
2871 }
2872 }
2873 }
2874 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2875 {
2876 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2877 {
2878 for (u32 i = 0; i < pws_cnt; i++)
2879 {
2880 const u32 pw_len = device_param->pws_buf[i].pw_len;
2881
2882 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2883
2884 ptr[pw_len] = 0x01;
2885 }
2886 }
2887 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2888 {
2889 for (u32 i = 0; i < pws_cnt; i++)
2890 {
2891 const u32 pw_len = device_param->pws_buf[i].pw_len;
2892
2893 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2894
2895 ptr[pw_len] = 0x80;
2896 }
2897 }
2898 }
2899
2900 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);
2901 }
2902 else if (data.attack_kern == ATTACK_KERN_BF)
2903 {
2904 const u64 off = device_param->words_off;
2905
2906 device_param->kernel_params_mp_l_buf64[3] = off;
2907
2908 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2909 }
2910 }
2911
2912 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2913 {
2914 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2915
2916 device_param->kernel_params_buf32[25] = 0;
2917 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2918 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2919
2920 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2921 {
2922 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true);
2923 }
2924 else
2925 {
2926 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true);
2927 }
2928
2929 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2930
2931 return exec_ms_prev;
2932 }
2933
2934 static void autotune (hc_device_param_t *device_param)
2935 {
2936 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2937
2938 const u32 kernel_accel_min = device_param->kernel_accel_min;
2939 const u32 kernel_accel_max = device_param->kernel_accel_max;
2940
2941 const u32 kernel_loops_min = device_param->kernel_loops_min;
2942 const u32 kernel_loops_max = device_param->kernel_loops_max;
2943
2944 u32 kernel_accel = kernel_accel_min;
2945 u32 kernel_loops = kernel_loops_min;
2946
2947 // in this case the user specified a fixed -u and -n on the commandline
2948 // no way to tune anything
2949 // but we need to run a few caching rounds
2950
2951 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2952 {
2953 try_run (device_param, kernel_accel, kernel_loops);
2954 try_run (device_param, kernel_accel, kernel_loops);
2955 try_run (device_param, kernel_accel, kernel_loops);
2956 try_run (device_param, kernel_accel, kernel_loops);
2957
2958 device_param->kernel_accel = kernel_accel;
2959 device_param->kernel_loops = kernel_loops;
2960
2961 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2962
2963 device_param->kernel_power = kernel_power;
2964
2965 return;
2966 }
2967
2968 // from here it's clear we are allowed to autotune
2969 // so let's init some fake words
2970
2971 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2972
2973 if (data.attack_kern == ATTACK_KERN_BF)
2974 {
2975 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2976 }
2977 else
2978 {
2979 for (u32 i = 0; i < kernel_power_max; i++)
2980 {
2981 device_param->pws_buf[i].i[0] = i;
2982 device_param->pws_buf[i].i[1] = 0x01234567;
2983 device_param->pws_buf[i].pw_len = 7 + (i & 7);
2984 }
2985
2986 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);
2987 }
2988
2989 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2990 {
2991 if (data.kernel_rules_cnt > 1)
2992 {
2993 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);
2994 }
2995 }
2996 else
2997 {
2998 run_kernel_amp (device_param, kernel_power_max);
2999 }
3000
3001 #define VERIFIER_CNT 1
3002
3003 // first find out highest kernel-loops that stays below target_ms
3004
3005 if (kernel_loops_min < kernel_loops_max)
3006 {
3007 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3008 {
3009 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3010
3011 for (int i = 0; i < VERIFIER_CNT; i++)
3012 {
3013 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3014
3015 exec_ms = MIN (exec_ms, exec_ms_v);
3016 }
3017
3018 if (exec_ms < target_ms) break;
3019 }
3020 }
3021
3022 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3023
3024 #define STEPS_CNT 10
3025
3026 if (kernel_accel_min < kernel_accel_max)
3027 {
3028 for (int i = 0; i < STEPS_CNT; i++)
3029 {
3030 const u32 kernel_accel_try = 1 << i;
3031
3032 if (kernel_accel_try < kernel_accel_min) continue;
3033 if (kernel_accel_try > kernel_accel_max) break;
3034
3035 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3036
3037 for (int i = 0; i < VERIFIER_CNT; i++)
3038 {
3039 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3040
3041 exec_ms = MIN (exec_ms, exec_ms_v);
3042 }
3043
3044 if (exec_ms > target_ms) break;
3045
3046 kernel_accel = kernel_accel_try;
3047 }
3048 }
3049
3050 // at this point we want to know the actual runtime for the following reason:
3051 // we need a reference for the balancing loop following up, and this
3052 // the balancing loop can have an effect that the creates a new opportunity, for example:
3053 // if the target is 95 ms and the current runtime is 48ms the above loop
3054 // stopped the execution because the previous exec_ms was > 95ms
3055 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3056 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3057
3058 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3059
3060 for (int i = 0; i < VERIFIER_CNT; i++)
3061 {
3062 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3063
3064 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3065 }
3066
3067 u32 diff = kernel_loops - kernel_accel;
3068
3069 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3070 {
3071 u32 kernel_accel_orig = kernel_accel;
3072 u32 kernel_loops_orig = kernel_loops;
3073
3074 for (u32 f = 1; f < 1024; f++)
3075 {
3076 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3077 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3078
3079 if (kernel_accel_try > kernel_accel_max) break;
3080 if (kernel_loops_try < kernel_loops_min) break;
3081
3082 u32 diff_new = kernel_loops_try - kernel_accel_try;
3083
3084 if (diff_new > diff) break;
3085
3086 diff_new = diff;
3087
3088 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3089
3090 for (int i = 0; i < VERIFIER_CNT; i++)
3091 {
3092 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3093
3094 exec_ms = MIN (exec_ms, exec_ms_v);
3095 }
3096
3097 if (exec_ms < exec_ms_pre_final)
3098 {
3099 exec_ms_pre_final = exec_ms;
3100
3101 kernel_accel = kernel_accel_try;
3102 kernel_loops = kernel_loops_try;
3103 }
3104 }
3105 }
3106
3107 const double exec_left = target_ms / exec_ms_pre_final;
3108
3109 const double accel_left = kernel_accel_max / kernel_accel;
3110
3111 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3112
3113 if (exec_accel_min >= 1.0)
3114 {
3115 // this is safe to not overflow kernel_accel_max because of accel_left
3116
3117 kernel_accel = (double) kernel_accel * exec_accel_min;
3118 }
3119
3120 // reset them fake words
3121
3122 /*
3123 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3124
3125 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);
3126 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);
3127 */
3128
3129 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3130
3131 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3132 {
3133 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3134 }
3135
3136 // reset timer
3137
3138 device_param->exec_pos = 0;
3139
3140 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3141
3142 // store
3143
3144 device_param->kernel_accel = kernel_accel;
3145 device_param->kernel_loops = kernel_loops;
3146
3147 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3148
3149 device_param->kernel_power = kernel_power;
3150
3151 #ifdef DEBUG
3152
3153 if (data.quiet == 0)
3154 {
3155 clear_prompt ();
3156
3157 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3158 "Device #%u: autotuned kernel-loops to %u\n",
3159 device_param->device_id + 1, kernel_accel,
3160 device_param->device_id + 1, kernel_loops);
3161
3162 fprintf (stdout, "%s", PROMPT);
3163
3164 fflush (stdout);
3165 }
3166
3167 #endif
3168 }
3169
3170 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3171 {
3172 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3173
3174 // init speed timer
3175
3176 uint speed_pos = device_param->speed_pos;
3177
3178 #ifdef _POSIX
3179 if (device_param->timer_speed.tv_sec == 0)
3180 {
3181 hc_timer_set (&device_param->timer_speed);
3182 }
3183 #endif
3184
3185 #ifdef _WIN
3186 if (device_param->timer_speed.QuadPart == 0)
3187 {
3188 hc_timer_set (&device_param->timer_speed);
3189 }
3190 #endif
3191
3192 // find higest password length, this is for optimization stuff
3193
3194 uint highest_pw_len = 0;
3195
3196 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3197 {
3198 }
3199 else if (data.attack_kern == ATTACK_KERN_COMBI)
3200 {
3201 }
3202 else if (data.attack_kern == ATTACK_KERN_BF)
3203 {
3204 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3205 + device_param->kernel_params_mp_l_buf32[5];
3206 }
3207
3208 // iteration type
3209
3210 uint innerloop_step = 0;
3211 uint innerloop_cnt = 0;
3212
3213 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3214 else innerloop_step = 1;
3215
3216 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3217 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3218 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3219
3220 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3221
3222 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3223 {
3224 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3225
3226 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3227
3228 if (data.devices_status == STATUS_CRACKED) break;
3229 if (data.devices_status == STATUS_ABORTED) break;
3230 if (data.devices_status == STATUS_QUIT) break;
3231 if (data.devices_status == STATUS_BYPASS) break;
3232
3233 salt_t *salt_buf = &data.salts_buf[salt_pos];
3234
3235 device_param->kernel_params_buf32[24] = salt_pos;
3236 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3237 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3238
3239 FILE *combs_fp = device_param->combs_fp;
3240
3241 if (data.attack_mode == ATTACK_MODE_COMBI)
3242 {
3243 rewind (combs_fp);
3244 }
3245
3246 // innerloops
3247
3248 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3249 {
3250 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3251
3252 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3253
3254 if (data.devices_status == STATUS_CRACKED) break;
3255 if (data.devices_status == STATUS_ABORTED) break;
3256 if (data.devices_status == STATUS_QUIT) break;
3257 if (data.devices_status == STATUS_BYPASS) break;
3258
3259 uint innerloop_left = innerloop_cnt - innerloop_pos;
3260
3261 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3262
3263 device_param->innerloop_pos = innerloop_pos;
3264 device_param->innerloop_left = innerloop_left;
3265
3266 device_param->kernel_params_buf32[27] = innerloop_left;
3267
3268 // i think we can get rid of this
3269 if (innerloop_left == 0)
3270 {
3271 puts ("bug, how should this happen????\n");
3272
3273 continue;
3274 }
3275
3276 if (data.salts_shown[salt_pos] == 1)
3277 {
3278 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3279
3280 continue;
3281 }
3282
3283 // initialize amplifiers
3284
3285 if (data.attack_mode == ATTACK_MODE_COMBI)
3286 {
3287 uint i = 0;
3288
3289 while (i < innerloop_left)
3290 {
3291 if (feof (combs_fp)) break;
3292
3293 int line_len = fgetl (combs_fp, line_buf);
3294
3295 if (line_len >= PW_MAX1) continue;
3296
3297 line_len = convert_from_hex (line_buf, line_len);
3298
3299 char *line_buf_new = line_buf;
3300
3301 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3302 {
3303 char rule_buf_out[BLOCK_SIZE] = { 0 };
3304
3305 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3306
3307 if (rule_len_out < 0)
3308 {
3309 data.words_progress_rejected[salt_pos] += pws_cnt;
3310
3311 continue;
3312 }
3313
3314 line_len = rule_len_out;
3315
3316 line_buf_new = rule_buf_out;
3317 }
3318
3319 line_len = MIN (line_len, PW_DICTMAX);
3320
3321 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3322
3323 memcpy (ptr, line_buf_new, line_len);
3324
3325 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3326
3327 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3328 {
3329 uppercase (ptr, line_len);
3330 }
3331
3332 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3333 {
3334 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3335 {
3336 ptr[line_len] = 0x80;
3337 }
3338
3339 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3340 {
3341 ptr[line_len] = 0x01;
3342 }
3343 }
3344
3345 device_param->combs_buf[i].pw_len = line_len;
3346
3347 i++;
3348 }
3349
3350 for (uint j = i; j < innerloop_left; j++)
3351 {
3352 device_param->combs_buf[j].i[0] = 0;
3353 device_param->combs_buf[j].i[1] = 0;
3354 device_param->combs_buf[j].i[2] = 0;
3355 device_param->combs_buf[j].i[3] = 0;
3356 device_param->combs_buf[j].i[4] = 0;
3357 device_param->combs_buf[j].i[5] = 0;
3358 device_param->combs_buf[j].i[6] = 0;
3359 device_param->combs_buf[j].i[7] = 0;
3360
3361 device_param->combs_buf[j].pw_len = 0;
3362 }
3363
3364 innerloop_left = i;
3365 }
3366 else if (data.attack_mode == ATTACK_MODE_BF)
3367 {
3368 u64 off = innerloop_pos;
3369
3370 device_param->kernel_params_mp_r_buf64[3] = off;
3371
3372 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3373 }
3374 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3375 {
3376 u64 off = innerloop_pos;
3377
3378 device_param->kernel_params_mp_buf64[3] = off;
3379
3380 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3381 }
3382 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3383 {
3384 u64 off = innerloop_pos;
3385
3386 device_param->kernel_params_mp_buf64[3] = off;
3387
3388 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3389 }
3390
3391 // copy amplifiers
3392
3393 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3394 {
3395 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);
3396 }
3397 else if (data.attack_mode == ATTACK_MODE_COMBI)
3398 {
3399 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);
3400 }
3401 else if (data.attack_mode == ATTACK_MODE_BF)
3402 {
3403 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);
3404 }
3405 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3406 {
3407 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);
3408 }
3409 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3410 {
3411 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);
3412 }
3413
3414 if (data.benchmark == 1)
3415 {
3416 hc_timer_set (&device_param->timer_speed);
3417 }
3418
3419 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3420
3421 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3422
3423 if (data.devices_status == STATUS_CRACKED) break;
3424 if (data.devices_status == STATUS_ABORTED) break;
3425 if (data.devices_status == STATUS_QUIT) break;
3426
3427 /**
3428 * result
3429 */
3430
3431 check_cracked (device_param, salt_pos);
3432
3433 /**
3434 * progress
3435 */
3436
3437 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3438
3439 hc_thread_mutex_lock (mux_counter);
3440
3441 data.words_progress_done[salt_pos] += perf_sum_all;
3442
3443 hc_thread_mutex_unlock (mux_counter);
3444
3445 /**
3446 * speed
3447 */
3448
3449 double speed_ms;
3450
3451 hc_timer_get (device_param->timer_speed, speed_ms);
3452
3453 hc_timer_set (&device_param->timer_speed);
3454
3455 // current speed
3456
3457 //hc_thread_mutex_lock (mux_display);
3458
3459 device_param->speed_cnt[speed_pos] = perf_sum_all;
3460
3461 device_param->speed_ms[speed_pos] = speed_ms;
3462
3463 //hc_thread_mutex_unlock (mux_display);
3464
3465 speed_pos++;
3466
3467 if (speed_pos == SPEED_CACHE)
3468 {
3469 speed_pos = 0;
3470 }
3471
3472 /**
3473 * benchmark
3474 */
3475
3476 if (data.benchmark == 1) break;
3477 }
3478 }
3479
3480 device_param->speed_pos = speed_pos;
3481
3482 myfree (line_buf);
3483 }
3484
3485 static void load_segment (wl_data_t *wl_data, FILE *fd)
3486 {
3487 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3488
3489 wl_data->pos = 0;
3490
3491 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3492
3493 wl_data->buf[wl_data->cnt] = 0;
3494
3495 if (wl_data->cnt == 0) return;
3496
3497 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3498
3499 while (!feof (fd))
3500 {
3501 if (wl_data->cnt == wl_data->avail)
3502 {
3503 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3504
3505 wl_data->avail += wl_data->incr;
3506 }
3507
3508 const int c = fgetc (fd);
3509
3510 if (c == EOF) break;
3511
3512 wl_data->buf[wl_data->cnt] = (char) c;
3513
3514 wl_data->cnt++;
3515
3516 if (c == '\n') break;
3517 }
3518
3519 // ensure stream ends with a newline
3520
3521 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3522 {
3523 wl_data->cnt++;
3524
3525 wl_data->buf[wl_data->cnt - 1] = '\n';
3526 }
3527
3528 return;
3529 }
3530
3531 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3532 {
3533 char *ptr = buf;
3534
3535 for (u32 i = 0; i < sz; i++, ptr++)
3536 {
3537 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3538
3539 if (i == 7)
3540 {
3541 *off = i;
3542 *len = i;
3543
3544 return;
3545 }
3546
3547 if (*ptr != '\n') continue;
3548
3549 *off = i + 1;
3550
3551 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3552
3553 *len = i;
3554
3555 return;
3556 }
3557
3558 *off = sz;
3559 *len = sz;
3560 }
3561
3562 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3563 {
3564 char *ptr = buf;
3565
3566 for (u32 i = 0; i < sz; i++, ptr++)
3567 {
3568 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3569
3570 if (*ptr != '\n') continue;
3571
3572 *off = i + 1;
3573
3574 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3575
3576 *len = i;
3577
3578 return;
3579 }
3580
3581 *off = sz;
3582 *len = sz;
3583 }
3584
3585 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3586 {
3587 char *ptr = buf;
3588
3589 for (u32 i = 0; i < sz; i++, ptr++)
3590 {
3591 if (*ptr != '\n') continue;
3592
3593 *off = i + 1;
3594
3595 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3596
3597 *len = i;
3598
3599 return;
3600 }
3601
3602 *off = sz;
3603 *len = sz;
3604 }
3605
3606 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3607 {
3608 while (wl_data->pos < wl_data->cnt)
3609 {
3610 uint off;
3611 uint len;
3612
3613 char *ptr = wl_data->buf + wl_data->pos;
3614
3615 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3616
3617 wl_data->pos += off;
3618
3619 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3620 {
3621 char rule_buf_out[BLOCK_SIZE] = { 0 };
3622
3623 int rule_len_out = -1;
3624
3625 if (len < BLOCK_SIZE)
3626 {
3627 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3628 }
3629
3630 if (rule_len_out < 0)
3631 {
3632 continue;
3633 }
3634
3635 if (rule_len_out > PW_MAX)
3636 {
3637 continue;
3638 }
3639 }
3640 else
3641 {
3642 if (len > PW_MAX)
3643 {
3644 continue;
3645 }
3646 }
3647
3648 *out_buf = ptr;
3649 *out_len = len;
3650
3651 return;
3652 }
3653
3654 if (feof (fd))
3655 {
3656 fprintf (stderr, "BUG feof()!!\n");
3657
3658 return;
3659 }
3660
3661 load_segment (wl_data, fd);
3662
3663 get_next_word (wl_data, fd, out_buf, out_len);
3664 }
3665
3666 #ifdef _POSIX
3667 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3668 #endif
3669
3670 #ifdef _WIN
3671 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3672 #endif
3673 {
3674 hc_signal (NULL);
3675
3676 dictstat_t d;
3677
3678 d.cnt = 0;
3679
3680 #ifdef _POSIX
3681 fstat (fileno (fd), &d.stat);
3682 #endif
3683
3684 #ifdef _WIN
3685 _fstat64 (fileno (fd), &d.stat);
3686 #endif
3687
3688 d.stat.st_mode = 0;
3689 d.stat.st_nlink = 0;
3690 d.stat.st_uid = 0;
3691 d.stat.st_gid = 0;
3692 d.stat.st_rdev = 0;
3693 d.stat.st_atime = 0;
3694
3695 #ifdef _POSIX
3696 d.stat.st_blksize = 0;
3697 d.stat.st_blocks = 0;
3698 #endif
3699
3700 if (d.stat.st_size == 0) return 0;
3701
3702 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3703
3704 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3705 {
3706 if (d_cache)
3707 {
3708 u64 cnt = d_cache->cnt;
3709
3710 u64 keyspace = cnt;
3711
3712 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3713 {
3714 keyspace *= data.kernel_rules_cnt;
3715 }
3716 else if (data.attack_kern == ATTACK_KERN_COMBI)
3717 {
3718 keyspace *= data.combs_cnt;
3719 }
3720
3721 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);
3722 if (data.quiet == 0) log_info ("");
3723
3724 hc_signal (sigHandler_default);
3725
3726 return (keyspace);
3727 }
3728 }
3729
3730 time_t now = 0;
3731 time_t prev = 0;
3732
3733 u64 comp = 0;
3734 u64 cnt = 0;
3735 u64 cnt2 = 0;
3736
3737 while (!feof (fd))
3738 {
3739 load_segment (wl_data, fd);
3740
3741 comp += wl_data->cnt;
3742
3743 u32 i = 0;
3744
3745 while (i < wl_data->cnt)
3746 {
3747 u32 len;
3748 u32 off;
3749
3750 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3751
3752 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3753 {
3754 char rule_buf_out[BLOCK_SIZE] = { 0 };
3755
3756 int rule_len_out = -1;
3757
3758 if (len < BLOCK_SIZE)
3759 {
3760 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3761 }
3762
3763 if (rule_len_out < 0)
3764 {
3765 len = PW_MAX1;
3766 }
3767 else
3768 {
3769 len = rule_len_out;
3770 }
3771 }
3772
3773 if (len < PW_MAX1)
3774 {
3775 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3776 {
3777 cnt += data.kernel_rules_cnt;
3778 }
3779 else if (data.attack_kern == ATTACK_KERN_COMBI)
3780 {
3781 cnt += data.combs_cnt;
3782 }
3783
3784 d.cnt++;
3785 }
3786
3787 i += off;
3788
3789 cnt2++;
3790 }
3791
3792 time (&now);
3793
3794 if ((now - prev) == 0) continue;
3795
3796 float percent = (float) comp / (float) d.stat.st_size;
3797
3798 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);
3799
3800 time (&prev);
3801 }
3802
3803 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);
3804 if (data.quiet == 0) log_info ("");
3805
3806 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3807
3808 hc_signal (sigHandler_default);
3809
3810 return (cnt);
3811 }
3812
3813 static void *thread_monitor (void *p)
3814 {
3815 uint runtime_check = 0;
3816 uint remove_check = 0;
3817 uint status_check = 0;
3818 uint restore_check = 0;
3819
3820 uint restore_left = data.restore_timer;
3821 uint remove_left = data.remove_timer;
3822 uint status_left = data.status_timer;
3823
3824 #ifdef HAVE_HWMON
3825 uint hwmon_check = 0;
3826
3827 int slowdown_warnings = 0;
3828
3829 // these variables are mainly used for fan control
3830
3831 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3832
3833 // temperature controller "loopback" values
3834
3835 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3836 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3837
3838 int temp_threshold = 1; // degrees celcius
3839
3840 int fan_speed_min = 15; // in percentage
3841 int fan_speed_max = 100;
3842
3843 time_t last_temp_check_time;
3844 #endif // HAVE_HWMON
3845
3846 uint sleep_time = 1;
3847
3848 if (data.runtime)
3849 {
3850 runtime_check = 1;
3851 }
3852
3853 if (data.restore_timer)
3854 {
3855 restore_check = 1;
3856 }
3857
3858 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3859 {
3860 remove_check = 1;
3861 }
3862
3863 if (data.status == 1)
3864 {
3865 status_check = 1;
3866 }
3867
3868 #ifdef HAVE_HWMON
3869 if (data.gpu_temp_disable == 0)
3870 {
3871 time (&last_temp_check_time);
3872
3873 hwmon_check = 1;
3874 }
3875 #endif
3876
3877 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3878 {
3879 #ifdef HAVE_HWMON
3880 if (hwmon_check == 0)
3881 #endif
3882 return (p);
3883 }
3884
3885 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3886 {
3887 hc_sleep (sleep_time);
3888
3889 if (data.devices_status != STATUS_RUNNING) continue;
3890
3891 #ifdef HAVE_HWMON
3892
3893 if (hwmon_check == 1)
3894 {
3895 hc_thread_mutex_lock (mux_adl);
3896
3897 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3898 {
3899 hc_device_param_t *device_param = &data.devices_param[device_id];
3900
3901 if (device_param->skipped) continue;
3902
3903 if (device_param->device_vendor_id == VENDOR_ID_NV)
3904 {
3905 if (data.hm_nvapi)
3906 {
3907 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
3908 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
3909
3910 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
3911 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
3912
3913 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
3914
3915 perfPolicies_status.info_value = perfPolicies_info.info_value;
3916
3917 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
3918
3919 if (perfPolicies_status.throttle & 2)
3920 {
3921 if (slowdown_warnings < 3)
3922 {
3923 if (data.quiet == 0) clear_prompt ();
3924
3925 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
3926
3927 if (slowdown_warnings == 2)
3928 {
3929 log_info ("");
3930 }
3931
3932 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3933 if (data.quiet == 0) fflush (stdout);
3934
3935 slowdown_warnings++;
3936 }
3937 }
3938 else
3939 {
3940 slowdown_warnings = 0;
3941 }
3942 }
3943 }
3944 }
3945
3946 hc_thread_mutex_unlock (mux_adl);
3947 }
3948
3949 if (hwmon_check == 1)
3950 {
3951 hc_thread_mutex_lock (mux_adl);
3952
3953 time_t temp_check_time;
3954
3955 time (&temp_check_time);
3956
3957 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3958
3959 if (Ta == 0) Ta = 1;
3960
3961 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3962 {
3963 hc_device_param_t *device_param = &data.devices_param[device_id];
3964
3965 if (device_param->skipped) continue;
3966
3967 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3968
3969 const int temperature = hm_get_temperature_with_device_id (device_id);
3970
3971 if (temperature > (int) data.gpu_temp_abort)
3972 {
3973 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3974
3975 if (data.devices_status != STATUS_QUIT) myabort ();
3976
3977 break;
3978 }
3979
3980 const int gpu_temp_retain = data.gpu_temp_retain;
3981
3982 if (gpu_temp_retain)
3983 {
3984 if (data.hm_device[device_id].fan_set_supported == 1)
3985 {
3986 int temp_cur = temperature;
3987
3988 int temp_diff_new = gpu_temp_retain - temp_cur;
3989
3990 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3991
3992 // calculate Ta value (time difference in seconds between the last check and this check)
3993
3994 last_temp_check_time = temp_check_time;
3995
3996 float Kp = 1.8;
3997 float Ki = 0.005;
3998 float Kd = 6;
3999
4000 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4001
4002 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);
4003
4004 if (abs (fan_diff_required) >= temp_threshold)
4005 {
4006 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4007
4008 int fan_speed_level = fan_speed_cur;
4009
4010 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4011
4012 int fan_speed_new = fan_speed_level - fan_diff_required;
4013
4014 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4015 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4016
4017 if (fan_speed_new != fan_speed_cur)
4018 {
4019 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4020 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4021
4022 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4023 {
4024 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4025 {
4026 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4027 }
4028 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4029 {
4030
4031 }
4032
4033 fan_speed_chgd[device_id] = 1;
4034 }
4035
4036 temp_diff_old[device_id] = temp_diff_new;
4037 }
4038 }
4039 }
4040 }
4041 }
4042
4043 hc_thread_mutex_unlock (mux_adl);
4044 }
4045 #endif // HAVE_HWMON
4046
4047 if (restore_check == 1)
4048 {
4049 restore_left--;
4050
4051 if (restore_left == 0)
4052 {
4053 if (data.restore_disable == 0) cycle_restore ();
4054
4055 restore_left = data.restore_timer;
4056 }
4057 }
4058
4059 if ((runtime_check == 1) && (data.runtime_start > 0))
4060 {
4061 time_t runtime_cur;
4062
4063 time (&runtime_cur);
4064
4065 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4066
4067 if (runtime_left <= 0)
4068 {
4069 if (data.benchmark == 0)
4070 {
4071 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4072 }
4073
4074 if (data.devices_status != STATUS_QUIT) myabort ();
4075 }
4076 }
4077
4078 if (remove_check == 1)
4079 {
4080 remove_left--;
4081
4082 if (remove_left == 0)
4083 {
4084 if (data.digests_saved != data.digests_done)
4085 {
4086 data.digests_saved = data.digests_done;
4087
4088 save_hash ();
4089 }
4090
4091 remove_left = data.remove_timer;
4092 }
4093 }
4094
4095 if (status_check == 1)
4096 {
4097 status_left--;
4098
4099 if (status_left == 0)
4100 {
4101 //hc_thread_mutex_lock (mux_display);
4102
4103 if (data.quiet == 0) clear_prompt ();
4104
4105 if (data.quiet == 0) log_info ("");
4106
4107 status_display ();
4108
4109 if (data.quiet == 0) log_info ("");
4110
4111 //hc_thread_mutex_unlock (mux_display);
4112
4113 status_left = data.status_timer;
4114 }
4115 }
4116 }
4117
4118 #ifdef HAVE_HWMON
4119 myfree (fan_speed_chgd);
4120
4121 myfree (temp_diff_old);
4122 myfree (temp_diff_sum);
4123 #endif
4124
4125 p = NULL;
4126
4127 return (p);
4128 }
4129
4130 static void *thread_outfile_remove (void *p)
4131 {
4132 // some hash-dependent constants
4133 char *outfile_dir = data.outfile_check_directory;
4134 uint dgst_size = data.dgst_size;
4135 uint isSalted = data.isSalted;
4136 uint esalt_size = data.esalt_size;
4137 uint hash_mode = data.hash_mode;
4138
4139 uint outfile_check_timer = data.outfile_check_timer;
4140
4141 char separator = data.separator;
4142
4143 // some hash-dependent functions
4144 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4145 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4146
4147 // buffers
4148 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4149
4150 hash_buf.digest = mymalloc (dgst_size);
4151
4152 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4153
4154 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4155
4156 uint digest_buf[64] = { 0 };
4157
4158 outfile_data_t *out_info = NULL;
4159
4160 char **out_files = NULL;
4161
4162 time_t folder_mtime = 0;
4163
4164 int out_cnt = 0;
4165
4166 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4167
4168 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4169 {
4170 hc_sleep (1);
4171
4172 if (data.devices_status != STATUS_RUNNING) continue;
4173
4174 check_left--;
4175
4176 if (check_left == 0)
4177 {
4178 struct stat outfile_check_stat;
4179
4180 if (stat (outfile_dir, &outfile_check_stat) == 0)
4181 {
4182 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4183
4184 if (is_dir == 1)
4185 {
4186 if (outfile_check_stat.st_mtime > folder_mtime)
4187 {
4188 char **out_files_new = scan_directory (outfile_dir);
4189
4190 int out_cnt_new = count_dictionaries (out_files_new);
4191
4192 outfile_data_t *out_info_new = NULL;
4193
4194 if (out_cnt_new > 0)
4195 {
4196 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4197
4198 for (int i = 0; i < out_cnt_new; i++)
4199 {
4200 out_info_new[i].file_name = out_files_new[i];
4201
4202 // check if there are files that we have seen/checked before (and not changed)
4203
4204 for (int j = 0; j < out_cnt; j++)
4205 {
4206 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4207 {
4208 struct stat outfile_stat;
4209
4210 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4211 {
4212 if (outfile_stat.st_ctime == out_info[j].ctime)
4213 {
4214 out_info_new[i].ctime = out_info[j].ctime;
4215 out_info_new[i].seek = out_info[j].seek;
4216 }
4217 }
4218 }
4219 }
4220 }
4221 }
4222
4223 local_free (out_info);
4224 local_free (out_files);
4225
4226 out_files = out_files_new;
4227 out_cnt = out_cnt_new;
4228 out_info = out_info_new;
4229
4230 folder_mtime = outfile_check_stat.st_mtime;
4231 }
4232
4233 for (int j = 0; j < out_cnt; j++)
4234 {
4235 FILE *fp = fopen (out_info[j].file_name, "rb");
4236
4237 if (fp != NULL)
4238 {
4239 //hc_thread_mutex_lock (mux_display);
4240
4241 #ifdef _POSIX
4242 struct stat outfile_stat;
4243
4244 fstat (fileno (fp), &outfile_stat);
4245 #endif
4246
4247 #ifdef _WIN
4248 struct stat64 outfile_stat;
4249
4250 _fstat64 (fileno (fp), &outfile_stat);
4251 #endif
4252
4253 if (outfile_stat.st_ctime > out_info[j].ctime)
4254 {
4255 out_info[j].ctime = outfile_stat.st_ctime;
4256 out_info[j].seek = 0;
4257 }
4258
4259 fseek (fp, out_info[j].seek, SEEK_SET);
4260
4261 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4262
4263 while (!feof (fp))
4264 {
4265 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4266
4267 if (ptr == NULL) break;
4268
4269 int line_len = strlen (line_buf);
4270
4271 if (line_len <= 0) continue;
4272
4273 int iter = MAX_CUT_TRIES;
4274
4275 for (uint i = line_len - 1; i && iter; i--, line_len--)
4276 {
4277 if (line_buf[i] != separator) continue;
4278
4279 int parser_status = PARSER_OK;
4280
4281 if ((hash_mode != 2500) && (hash_mode != 6800))
4282 {
4283 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4284 }
4285
4286 uint found = 0;
4287
4288 if (parser_status == PARSER_OK)
4289 {
4290 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4291 {
4292 if (data.salts_shown[salt_pos] == 1) continue;
4293
4294 salt_t *salt_buf = &data.salts_buf[salt_pos];
4295
4296 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4297 {
4298 uint idx = salt_buf->digests_offset + digest_pos;
4299
4300 if (data.digests_shown[idx] == 1) continue;
4301
4302 uint cracked = 0;
4303
4304 if (hash_mode == 6800)
4305 {
4306 if (i == salt_buf->salt_len)
4307 {
4308 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4309 }
4310 }
4311 else if (hash_mode == 2500)
4312 {
4313 // BSSID : MAC1 : MAC2 (:plain)
4314 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4315 {
4316 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4317
4318 if (!cracked) continue;
4319
4320 // now compare MAC1 and MAC2 too, since we have this additional info
4321 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4322 char *mac2_pos = mac1_pos + 12 + 1;
4323
4324 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4325 wpa_t *wpa = &wpas[salt_pos];
4326
4327 // compare hex string(s) vs binary MAC address(es)
4328
4329 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4330 {
4331 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4332 {
4333 cracked = 0;
4334
4335 break;
4336 }
4337 }
4338
4339 // early skip ;)
4340 if (!cracked) continue;
4341
4342 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4343 {
4344 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4345 {
4346 cracked = 0;
4347
4348 break;
4349 }
4350 }
4351 }
4352 }
4353 else
4354 {
4355 char *digests_buf_ptr = (char *) data.digests_buf;
4356
4357 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4358
4359 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4360 }
4361
4362 if (cracked == 1)
4363 {
4364 found = 1;
4365
4366 data.digests_shown[idx] = 1;
4367
4368 data.digests_done++;
4369
4370 salt_buf->digests_done++;
4371
4372 if (salt_buf->digests_done == salt_buf->digests_cnt)
4373 {
4374 data.salts_shown[salt_pos] = 1;
4375
4376 data.salts_done++;
4377
4378 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4379 }
4380 }
4381 }
4382
4383 if (data.devices_status == STATUS_CRACKED) break;
4384 }
4385 }
4386
4387 if (found) break;
4388
4389 if (data.devices_status == STATUS_CRACKED) break;
4390
4391 iter--;
4392 }
4393
4394 if (data.devices_status == STATUS_CRACKED) break;
4395 }
4396
4397 myfree (line_buf);
4398
4399 out_info[j].seek = ftell (fp);
4400
4401 //hc_thread_mutex_unlock (mux_display);
4402
4403 fclose (fp);
4404 }
4405 }
4406 }
4407 }
4408
4409 check_left = outfile_check_timer;
4410 }
4411 }
4412
4413 if (esalt_size) local_free (hash_buf.esalt);
4414
4415 if (isSalted) local_free (hash_buf.salt);
4416
4417 local_free (hash_buf.digest);
4418
4419 local_free (out_info);
4420
4421 local_free (out_files);
4422
4423 p = NULL;
4424
4425 return (p);
4426 }
4427
4428 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4429 {
4430 //if (device_param->pws_cnt < device_param->kernel_power)
4431 //{
4432 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4433
4434 u8 *ptr = (u8 *) pw->i;
4435
4436 memcpy (ptr, pw_buf, pw_len);
4437
4438 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4439
4440 pw->pw_len = pw_len;
4441
4442 device_param->pws_cnt++;
4443 //}
4444 //else
4445 //{
4446 // fprintf (stderr, "BUG pw_add()!!\n");
4447 //
4448 // return;
4449 //}
4450 }
4451
4452 static u32 get_power (const u32 kernel_power)
4453 {
4454 if (data.kernel_power_div)
4455 {
4456 return (float) kernel_power * data.kernel_power_div;
4457 }
4458
4459 return kernel_power;
4460 }
4461
4462 static uint get_work (hc_device_param_t *device_param, const u64 max)
4463 {
4464 hc_thread_mutex_lock (mux_dispatcher);
4465
4466 const u64 words_cur = data.words_cur;
4467 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4468
4469 device_param->words_off = words_cur;
4470
4471 const u64 words_left = words_base - words_cur;
4472
4473 if (data.kernel_power_all > words_left)
4474 {
4475 if (data.kernel_power_div == 0)
4476 {
4477 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4478 }
4479 }
4480
4481 const u32 kernel_power = get_power (device_param->kernel_power);
4482
4483 uint work = MIN (words_left, kernel_power);
4484
4485 work = MIN (work, max);
4486
4487 data.words_cur += work;
4488
4489 hc_thread_mutex_unlock (mux_dispatcher);
4490
4491 return work;
4492 }
4493
4494 static void *thread_autotune (void *p)
4495 {
4496 hc_device_param_t *device_param = (hc_device_param_t *) p;
4497
4498 if (device_param->skipped) return NULL;
4499
4500 autotune (device_param);
4501
4502 return NULL;
4503 }
4504
4505 static void *thread_calc_stdin (void *p)
4506 {
4507 hc_device_param_t *device_param = (hc_device_param_t *) p;
4508
4509 if (device_param->skipped) return NULL;
4510
4511 char *buf = (char *) mymalloc (HCBUFSIZ);
4512
4513 const uint attack_kern = data.attack_kern;
4514
4515 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4516 {
4517 hc_thread_mutex_lock (mux_dispatcher);
4518
4519 if (feof (stdin) != 0)
4520 {
4521 hc_thread_mutex_unlock (mux_dispatcher);
4522
4523 break;
4524 }
4525
4526 uint words_cur = 0;
4527
4528 while (words_cur < get_power (device_param->kernel_power))
4529 {
4530 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4531
4532 if (line_buf == NULL) break;
4533
4534 uint line_len = in_superchop (line_buf);
4535
4536 line_len = convert_from_hex (line_buf, line_len);
4537
4538 // post-process rule engine
4539
4540 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4541 {
4542 char rule_buf_out[BLOCK_SIZE] = { 0 };
4543
4544 int rule_len_out = -1;
4545
4546 if (line_len < BLOCK_SIZE)
4547 {
4548 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4549 }
4550
4551 if (rule_len_out < 0) continue;
4552
4553 line_buf = rule_buf_out;
4554 line_len = rule_len_out;
4555 }
4556
4557 if (line_len > PW_MAX)
4558 {
4559 continue;
4560 }
4561
4562 if (attack_kern == ATTACK_KERN_STRAIGHT)
4563 {
4564 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4565 {
4566 hc_thread_mutex_lock (mux_counter);
4567
4568 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4569 {
4570 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4571 }
4572
4573 hc_thread_mutex_unlock (mux_counter);
4574
4575 continue;
4576 }
4577 }
4578 else if (attack_kern == ATTACK_KERN_COMBI)
4579 {
4580 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4581 // since we still need to combine the plains
4582
4583 if (line_len > data.pw_max)
4584 {
4585 hc_thread_mutex_lock (mux_counter);
4586
4587 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4588 {
4589 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4590 }
4591
4592 hc_thread_mutex_unlock (mux_counter);
4593
4594 continue;
4595 }
4596 }
4597
4598 pw_add (device_param, (u8 *) line_buf, line_len);
4599
4600 words_cur++;
4601
4602 if (data.devices_status == STATUS_CRACKED) break;
4603 if (data.devices_status == STATUS_ABORTED) break;
4604 if (data.devices_status == STATUS_QUIT) break;
4605 if (data.devices_status == STATUS_BYPASS) break;
4606 }
4607
4608 hc_thread_mutex_unlock (mux_dispatcher);
4609
4610 if (data.devices_status == STATUS_CRACKED) break;
4611 if (data.devices_status == STATUS_ABORTED) break;
4612 if (data.devices_status == STATUS_QUIT) break;
4613 if (data.devices_status == STATUS_BYPASS) break;
4614
4615 // flush
4616
4617 const uint pws_cnt = device_param->pws_cnt;
4618
4619 if (pws_cnt)
4620 {
4621 run_copy (device_param, pws_cnt);
4622
4623 run_cracker (device_param, pws_cnt);
4624
4625 device_param->pws_cnt = 0;
4626
4627 /*
4628 still required?
4629 if (attack_kern == ATTACK_KERN_STRAIGHT)
4630 {
4631 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4632 }
4633 else if (attack_kern == ATTACK_KERN_COMBI)
4634 {
4635 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4636 }
4637 */
4638 }
4639 }
4640
4641 device_param->kernel_accel = 0;
4642 device_param->kernel_loops = 0;
4643
4644 myfree (buf);
4645
4646 return NULL;
4647 }
4648
4649 static void *thread_calc (void *p)
4650 {
4651 hc_device_param_t *device_param = (hc_device_param_t *) p;
4652
4653 if (device_param->skipped) return NULL;
4654
4655 const uint attack_mode = data.attack_mode;
4656 const uint attack_kern = data.attack_kern;
4657
4658 if (attack_mode == ATTACK_MODE_BF)
4659 {
4660 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4661 {
4662 const uint work = get_work (device_param, -1);
4663
4664 if (work == 0) break;
4665
4666 const u64 words_off = device_param->words_off;
4667 const u64 words_fin = words_off + work;
4668
4669 const uint pws_cnt = work;
4670
4671 device_param->pws_cnt = pws_cnt;
4672
4673 if (pws_cnt)
4674 {
4675 run_copy (device_param, pws_cnt);
4676
4677 run_cracker (device_param, pws_cnt);
4678
4679 device_param->pws_cnt = 0;
4680
4681 /*
4682 still required?
4683 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4684 */
4685 }
4686
4687 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4688
4689 if (data.devices_status == STATUS_CRACKED) break;
4690 if (data.devices_status == STATUS_ABORTED) break;
4691 if (data.devices_status == STATUS_QUIT) break;
4692 if (data.devices_status == STATUS_BYPASS) break;
4693
4694 if (data.benchmark == 1) break;
4695
4696 device_param->words_done = words_fin;
4697 }
4698 }
4699 else
4700 {
4701 const uint segment_size = data.segment_size;
4702
4703 char *dictfile = data.dictfile;
4704
4705 if (attack_mode == ATTACK_MODE_COMBI)
4706 {
4707 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4708 {
4709 dictfile = data.dictfile2;
4710 }
4711 }
4712
4713 FILE *fd = fopen (dictfile, "rb");
4714
4715 if (fd == NULL)
4716 {
4717 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4718
4719 return NULL;
4720 }
4721
4722 if (attack_mode == ATTACK_MODE_COMBI)
4723 {
4724 const uint combs_mode = data.combs_mode;
4725
4726 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4727 {
4728 const char *dictfilec = data.dictfile2;
4729
4730 FILE *combs_fp = fopen (dictfilec, "rb");
4731
4732 if (combs_fp == NULL)
4733 {
4734 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4735
4736 fclose (fd);
4737
4738 return NULL;
4739 }
4740
4741 device_param->combs_fp = combs_fp;
4742 }
4743 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4744 {
4745 const char *dictfilec = data.dictfile;
4746
4747 FILE *combs_fp = fopen (dictfilec, "rb");
4748
4749 if (combs_fp == NULL)
4750 {
4751 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4752
4753 fclose (fd);
4754
4755 return NULL;
4756 }
4757
4758 device_param->combs_fp = combs_fp;
4759 }
4760 }
4761
4762 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4763
4764 wl_data->buf = (char *) mymalloc (segment_size);
4765 wl_data->avail = segment_size;
4766 wl_data->incr = segment_size;
4767 wl_data->cnt = 0;
4768 wl_data->pos = 0;
4769
4770 u64 words_cur = 0;
4771
4772 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4773 {
4774 u64 words_off = 0;
4775 u64 words_fin = 0;
4776
4777 u64 max = -1;
4778
4779 while (max)
4780 {
4781 const uint work = get_work (device_param, max);
4782
4783 if (work == 0) break;
4784
4785 max = 0;
4786
4787 words_off = device_param->words_off;
4788 words_fin = words_off + work;
4789
4790 char *line_buf;
4791 uint line_len;
4792
4793 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4794
4795 for ( ; words_cur < words_fin; words_cur++)
4796 {
4797 get_next_word (wl_data, fd, &line_buf, &line_len);
4798
4799 line_len = convert_from_hex (line_buf, line_len);
4800
4801 // post-process rule engine
4802
4803 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4804 {
4805 char rule_buf_out[BLOCK_SIZE] = { 0 };
4806
4807 int rule_len_out = -1;
4808
4809 if (line_len < BLOCK_SIZE)
4810 {
4811 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4812 }
4813
4814 if (rule_len_out < 0) continue;
4815
4816 line_buf = rule_buf_out;
4817 line_len = rule_len_out;
4818 }
4819
4820 if (attack_kern == ATTACK_KERN_STRAIGHT)
4821 {
4822 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4823 {
4824 max++;
4825
4826 hc_thread_mutex_lock (mux_counter);
4827
4828 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4829 {
4830 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4831 }
4832
4833 hc_thread_mutex_unlock (mux_counter);
4834
4835 continue;
4836 }
4837 }
4838 else if (attack_kern == ATTACK_KERN_COMBI)
4839 {
4840 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4841 // since we still need to combine the plains
4842
4843 if (line_len > data.pw_max)
4844 {
4845 max++;
4846
4847 hc_thread_mutex_lock (mux_counter);
4848
4849 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4850 {
4851 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4852 }
4853
4854 hc_thread_mutex_unlock (mux_counter);
4855
4856 continue;
4857 }
4858 }
4859
4860 pw_add (device_param, (u8 *) line_buf, line_len);
4861
4862 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4863
4864 if (data.devices_status == STATUS_CRACKED) break;
4865 if (data.devices_status == STATUS_ABORTED) break;
4866 if (data.devices_status == STATUS_QUIT) break;
4867 if (data.devices_status == STATUS_BYPASS) break;
4868 }
4869
4870 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4871
4872 if (data.devices_status == STATUS_CRACKED) break;
4873 if (data.devices_status == STATUS_ABORTED) break;
4874 if (data.devices_status == STATUS_QUIT) break;
4875 if (data.devices_status == STATUS_BYPASS) break;
4876 }
4877
4878 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4879
4880 if (data.devices_status == STATUS_CRACKED) break;
4881 if (data.devices_status == STATUS_ABORTED) break;
4882 if (data.devices_status == STATUS_QUIT) break;
4883 if (data.devices_status == STATUS_BYPASS) break;
4884
4885 //
4886 // flush
4887 //
4888
4889 const uint pws_cnt = device_param->pws_cnt;
4890
4891 if (pws_cnt)
4892 {
4893 run_copy (device_param, pws_cnt);
4894
4895 run_cracker (device_param, pws_cnt);
4896
4897 device_param->pws_cnt = 0;
4898
4899 /*
4900 still required?
4901 if (attack_kern == ATTACK_KERN_STRAIGHT)
4902 {
4903 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4904 }
4905 else if (attack_kern == ATTACK_KERN_COMBI)
4906 {
4907 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4908 }
4909 */
4910 }
4911
4912 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4913
4914 if (data.devices_status == STATUS_CRACKED) break;
4915 if (data.devices_status == STATUS_ABORTED) break;
4916 if (data.devices_status == STATUS_QUIT) break;
4917 if (data.devices_status == STATUS_BYPASS) break;
4918
4919 if (words_fin == 0) break;
4920
4921 device_param->words_done = words_fin;
4922 }
4923
4924 if (attack_mode == ATTACK_MODE_COMBI)
4925 {
4926 fclose (device_param->combs_fp);
4927 }
4928
4929 free (wl_data->buf);
4930 free (wl_data);
4931
4932 fclose (fd);
4933 }
4934
4935 device_param->kernel_accel = 0;
4936 device_param->kernel_loops = 0;
4937
4938 return NULL;
4939 }
4940
4941 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4942 {
4943 if (!device_param)
4944 {
4945 log_error ("ERROR: %s : Invalid argument", __func__);
4946
4947 exit (-1);
4948 }
4949
4950 salt_t *salt_buf = &data.salts_buf[salt_pos];
4951
4952 device_param->kernel_params_buf32[24] = salt_pos;
4953 device_param->kernel_params_buf32[27] = 1;
4954 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4955 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4956 device_param->kernel_params_buf32[30] = 0;
4957 device_param->kernel_params_buf32[31] = 1;
4958
4959 char *dictfile_old = data.dictfile;
4960
4961 const char *weak_hash_check = "weak-hash-check";
4962
4963 data.dictfile = (char *) weak_hash_check;
4964
4965 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4966
4967 data.kernel_rules_buf[0].cmds[0] = 0;
4968
4969 /**
4970 * run the kernel
4971 */
4972
4973 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4974 {
4975 run_kernel (KERN_RUN_1, device_param, 1, false);
4976 }
4977 else
4978 {
4979 run_kernel (KERN_RUN_1, device_param, 1, false);
4980
4981 uint loop_step = 16;
4982
4983 const uint iter = salt_buf->salt_iter;
4984
4985 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4986 {
4987 uint loop_left = iter - loop_pos;
4988
4989 loop_left = MIN (loop_left, loop_step);
4990
4991 device_param->kernel_params_buf32[25] = loop_pos;
4992 device_param->kernel_params_buf32[26] = loop_left;
4993
4994 run_kernel (KERN_RUN_2, device_param, 1, false);
4995 }
4996
4997 run_kernel (KERN_RUN_3, device_param, 1, false);
4998 }
4999
5000 /**
5001 * result
5002 */
5003
5004 check_cracked (device_param, salt_pos);
5005
5006 /**
5007 * cleanup
5008 */
5009
5010 device_param->kernel_params_buf32[24] = 0;
5011 device_param->kernel_params_buf32[25] = 0;
5012 device_param->kernel_params_buf32[26] = 0;
5013 device_param->kernel_params_buf32[27] = 0;
5014 device_param->kernel_params_buf32[28] = 0;
5015 device_param->kernel_params_buf32[29] = 0;
5016 device_param->kernel_params_buf32[30] = 0;
5017 device_param->kernel_params_buf32[31] = 0;
5018
5019 data.dictfile = dictfile_old;
5020
5021 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5022 }
5023
5024 // hlfmt hashcat
5025
5026 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5027 {
5028 if (data.username == 0)
5029 {
5030 *hashbuf_pos = line_buf;
5031 *hashbuf_len = line_len;
5032 }
5033 else
5034 {
5035 char *pos = line_buf;
5036 int len = line_len;
5037
5038 for (int i = 0; i < line_len; i++, pos++, len--)
5039 {
5040 if (line_buf[i] == data.separator)
5041 {
5042 pos++;
5043
5044 len--;
5045
5046 break;
5047 }
5048 }
5049
5050 *hashbuf_pos = pos;
5051 *hashbuf_len = len;
5052 }
5053 }
5054
5055 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5056 {
5057 char *pos = NULL;
5058 int len = 0;
5059
5060 int sep_cnt = 0;
5061
5062 for (int i = 0; i < line_len; i++)
5063 {
5064 if (line_buf[i] == data.separator)
5065 {
5066 sep_cnt++;
5067
5068 continue;
5069 }
5070
5071 if (sep_cnt == 0)
5072 {
5073 if (pos == NULL) pos = line_buf + i;
5074
5075 len++;
5076 }
5077 }
5078
5079 *userbuf_pos = pos;
5080 *userbuf_len = len;
5081 }
5082
5083 // hlfmt pwdump
5084
5085 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5086 {
5087 int sep_cnt = 0;
5088
5089 int sep2_len = 0;
5090 int sep3_len = 0;
5091
5092 for (int i = 0; i < line_len; i++)
5093 {
5094 if (line_buf[i] == ':')
5095 {
5096 sep_cnt++;
5097
5098 continue;
5099 }
5100
5101 if (sep_cnt == 2) sep2_len++;
5102 if (sep_cnt == 3) sep3_len++;
5103 }
5104
5105 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5106
5107 return 0;
5108 }
5109
5110 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5111 {
5112 char *pos = NULL;
5113 int len = 0;
5114
5115 int sep_cnt = 0;
5116
5117 for (int i = 0; i < line_len; i++)
5118 {
5119 if (line_buf[i] == ':')
5120 {
5121 sep_cnt++;
5122
5123 continue;
5124 }
5125
5126 if (data.hash_mode == 1000)
5127 {
5128 if (sep_cnt == 3)
5129 {
5130 if (pos == NULL) pos = line_buf + i;
5131
5132 len++;
5133 }
5134 }
5135 else if (data.hash_mode == 3000)
5136 {
5137 if (sep_cnt == 2)
5138 {
5139 if (pos == NULL) pos = line_buf + i;
5140
5141 len++;
5142 }
5143 }
5144 }
5145
5146 *hashbuf_pos = pos;
5147 *hashbuf_len = len;
5148 }
5149
5150 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5151 {
5152 char *pos = NULL;
5153 int len = 0;
5154
5155 int sep_cnt = 0;
5156
5157 for (int i = 0; i < line_len; i++)
5158 {
5159 if (line_buf[i] == ':')
5160 {
5161 sep_cnt++;
5162
5163 continue;
5164 }
5165
5166 if (sep_cnt == 0)
5167 {
5168 if (pos == NULL) pos = line_buf + i;
5169
5170 len++;
5171 }
5172 }
5173
5174 *userbuf_pos = pos;
5175 *userbuf_len = len;
5176 }
5177
5178 // hlfmt passwd
5179
5180 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5181 {
5182 int sep_cnt = 0;
5183
5184 char sep5_first = 0;
5185 char sep6_first = 0;
5186
5187 for (int i = 0; i < line_len; i++)
5188 {
5189 if (line_buf[i] == ':')
5190 {
5191 sep_cnt++;
5192
5193 continue;
5194 }
5195
5196 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5197 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5198 }
5199
5200 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5201
5202 return 0;
5203 }
5204
5205 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5206 {
5207 char *pos = NULL;
5208 int len = 0;
5209
5210 int sep_cnt = 0;
5211
5212 for (int i = 0; i < line_len; i++)
5213 {
5214 if (line_buf[i] == ':')
5215 {
5216 sep_cnt++;
5217
5218 continue;
5219 }
5220
5221 if (sep_cnt == 1)
5222 {
5223 if (pos == NULL) pos = line_buf + i;
5224
5225 len++;
5226 }
5227 }
5228
5229 *hashbuf_pos = pos;
5230 *hashbuf_len = len;
5231 }
5232
5233 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5234 {
5235 char *pos = NULL;
5236 int len = 0;
5237
5238 int sep_cnt = 0;
5239
5240 for (int i = 0; i < line_len; i++)
5241 {
5242 if (line_buf[i] == ':')
5243 {
5244 sep_cnt++;
5245
5246 continue;
5247 }
5248
5249 if (sep_cnt == 0)
5250 {
5251 if (pos == NULL) pos = line_buf + i;
5252
5253 len++;
5254 }
5255 }
5256
5257 *userbuf_pos = pos;
5258 *userbuf_len = len;
5259 }
5260
5261 // hlfmt shadow
5262
5263 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5264 {
5265 int sep_cnt = 0;
5266
5267 for (int i = 0; i < line_len; i++)
5268 {
5269 if (line_buf[i] == ':') sep_cnt++;
5270 }
5271
5272 if (sep_cnt == 8) return 1;
5273
5274 return 0;
5275 }
5276
5277 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5278 {
5279 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5280 }
5281
5282 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5283 {
5284 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5285 }
5286
5287 // hlfmt main
5288
5289 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5290 {
5291 switch (hashfile_format)
5292 {
5293 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5294 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5295 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5296 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5297 }
5298 }
5299
5300 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5301 {
5302 switch (hashfile_format)
5303 {
5304 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5305 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5306 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5307 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5308 }
5309 }
5310
5311 char *strhlfmt (const uint hashfile_format)
5312 {
5313 switch (hashfile_format)
5314 {
5315 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5316 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5317 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5318 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5319 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5320 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5321 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5322 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5323 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5324 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5325 }
5326
5327 return ((char *) "Unknown");
5328 }
5329
5330 static uint hlfmt_detect (FILE *fp, uint max_check)
5331 {
5332 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5333
5334 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5335 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5336
5337 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5338
5339 uint num_check = 0;
5340
5341 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5342
5343 while (!feof (fp))
5344 {
5345 int line_len = fgetl (fp, line_buf);
5346
5347 if (line_len == 0) continue;
5348
5349 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5350 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5351 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5352
5353 if (num_check == max_check) break;
5354
5355 num_check++;
5356 }
5357
5358 myfree (line_buf);
5359
5360 uint hashlist_format = HLFMT_HASHCAT;
5361
5362 for (int i = 1; i < HLFMTS_CNT; i++)
5363 {
5364 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5365
5366 hashlist_format = i;
5367 }
5368
5369 free (formats_cnt);
5370
5371 return hashlist_format;
5372 }
5373
5374 /**
5375 * some further helper function
5376 */
5377
5378 // wrapper around mymalloc for ADL
5379
5380 #if defined(HAVE_HWMON)
5381 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5382 {
5383 return mymalloc (iSize);
5384 }
5385 #endif
5386
5387 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)
5388 {
5389 u64 collisions = 0;
5390
5391 const uint dgst_pos0 = data.dgst_pos0;
5392 const uint dgst_pos1 = data.dgst_pos1;
5393 const uint dgst_pos2 = data.dgst_pos2;
5394 const uint dgst_pos3 = data.dgst_pos3;
5395
5396 memset (bitmap_a, 0, bitmap_size);
5397 memset (bitmap_b, 0, bitmap_size);
5398 memset (bitmap_c, 0, bitmap_size);
5399 memset (bitmap_d, 0, bitmap_size);
5400
5401 for (uint i = 0; i < digests_cnt; i++)
5402 {
5403 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5404
5405 uint *digest_ptr = (uint *) digests_buf_ptr;
5406
5407 digests_buf_ptr += dgst_size;
5408
5409 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5410 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5411 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5412 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5413
5414 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5415 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5416 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5417 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5418
5419 if (bitmap_a[idx0] & val0) collisions++;
5420 if (bitmap_b[idx1] & val1) collisions++;
5421 if (bitmap_c[idx2] & val2) collisions++;
5422 if (bitmap_d[idx3] & val3) collisions++;
5423
5424 bitmap_a[idx0] |= val0;
5425 bitmap_b[idx1] |= val1;
5426 bitmap_c[idx2] |= val2;
5427 bitmap_d[idx3] |= val3;
5428
5429 if (collisions >= collisions_max) return 0x7fffffff;
5430 }
5431
5432 return collisions;
5433 }
5434
5435 /**
5436 * main
5437 */
5438
5439 #ifdef _WIN
5440 void SetConsoleWindowSize (const int x)
5441 {
5442 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5443
5444 if (h == INVALID_HANDLE_VALUE) return;
5445
5446 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5447
5448 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5449
5450 SMALL_RECT *sr = &bufferInfo.srWindow;
5451
5452 sr->Right = MAX (sr->Right, x - 1);
5453
5454 COORD co;
5455
5456 co.X = sr->Right + 1;
5457 co.Y = 9999;
5458
5459 if (!SetConsoleScreenBufferSize (h, co)) return;
5460
5461 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5462 }
5463 #endif
5464
5465 int main (int argc, char **argv)
5466 {
5467 #ifdef _WIN
5468 SetConsoleWindowSize (132);
5469 #endif
5470
5471 /**
5472 * To help users a bit
5473 */
5474
5475 char *compute = getenv ("COMPUTE");
5476
5477 if (compute)
5478 {
5479 static char display[100];
5480
5481 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5482
5483 putenv (display);
5484 }
5485 else
5486 {
5487 if (getenv ("DISPLAY") == NULL)
5488 putenv ((char *) "DISPLAY=:0");
5489 }
5490
5491 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5492 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5493
5494 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5495 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5496
5497 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5498 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5499
5500 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5501 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5502
5503 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5504 putenv ((char *) "POCL_KERNEL_CACHE=0");
5505
5506 umask (077);
5507
5508 /**
5509 * Real init
5510 */
5511
5512 memset (&data, 0, sizeof (hc_global_data_t));
5513
5514 time_t proc_start;
5515
5516 time (&proc_start);
5517
5518 data.proc_start = proc_start;
5519
5520 int myargc = argc;
5521 char **myargv = argv;
5522
5523 hc_thread_mutex_init (mux_dispatcher);
5524 hc_thread_mutex_init (mux_counter);
5525 hc_thread_mutex_init (mux_display);
5526 hc_thread_mutex_init (mux_adl);
5527
5528 /**
5529 * commandline parameters
5530 */
5531
5532 uint usage = USAGE;
5533 uint version = VERSION;
5534 uint quiet = QUIET;
5535 uint benchmark = BENCHMARK;
5536 uint show = SHOW;
5537 uint left = LEFT;
5538 uint username = USERNAME;
5539 uint remove = REMOVE;
5540 uint remove_timer = REMOVE_TIMER;
5541 u64 skip = SKIP;
5542 u64 limit = LIMIT;
5543 uint keyspace = KEYSPACE;
5544 uint potfile_disable = POTFILE_DISABLE;
5545 char *potfile_path = NULL;
5546 uint debug_mode = DEBUG_MODE;
5547 char *debug_file = NULL;
5548 char *induction_dir = NULL;
5549 char *outfile_check_dir = NULL;
5550 uint force = FORCE;
5551 uint runtime = RUNTIME;
5552 uint hash_mode = HASH_MODE;
5553 uint attack_mode = ATTACK_MODE;
5554 uint markov_disable = MARKOV_DISABLE;
5555 uint markov_classic = MARKOV_CLASSIC;
5556 uint markov_threshold = MARKOV_THRESHOLD;
5557 char *markov_hcstat = NULL;
5558 char *outfile = NULL;
5559 uint outfile_format = OUTFILE_FORMAT;
5560 uint outfile_autohex = OUTFILE_AUTOHEX;
5561 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5562 uint restore = RESTORE;
5563 uint restore_timer = RESTORE_TIMER;
5564 uint restore_disable = RESTORE_DISABLE;
5565 uint status = STATUS;
5566 uint status_timer = STATUS_TIMER;
5567 uint machine_readable = MACHINE_READABLE;
5568 uint loopback = LOOPBACK;
5569 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5570 char *session = NULL;
5571 uint hex_charset = HEX_CHARSET;
5572 uint hex_salt = HEX_SALT;
5573 uint hex_wordlist = HEX_WORDLIST;
5574 uint rp_gen = RP_GEN;
5575 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5576 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5577 uint rp_gen_seed = RP_GEN_SEED;
5578 char *rule_buf_l = (char *) RULE_BUF_L;
5579 char *rule_buf_r = (char *) RULE_BUF_R;
5580 uint increment = INCREMENT;
5581 uint increment_min = INCREMENT_MIN;
5582 uint increment_max = INCREMENT_MAX;
5583 char *cpu_affinity = NULL;
5584 OCL_PTR *ocl = NULL;
5585 char *opencl_devices = NULL;
5586 char *opencl_platforms = NULL;
5587 char *opencl_device_types = NULL;
5588 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5589 char *truecrypt_keyfiles = NULL;
5590 char *veracrypt_keyfiles = NULL;
5591 uint veracrypt_pim = 0;
5592 uint workload_profile = WORKLOAD_PROFILE;
5593 uint kernel_accel = KERNEL_ACCEL;
5594 uint kernel_loops = KERNEL_LOOPS;
5595 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5596 #ifdef HAVE_HWMON
5597 uint gpu_temp_abort = GPU_TEMP_ABORT;
5598 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5599 uint powertune_enable = POWERTUNE_ENABLE;
5600 #endif
5601 uint logfile_disable = LOGFILE_DISABLE;
5602 uint segment_size = SEGMENT_SIZE;
5603 uint scrypt_tmto = SCRYPT_TMTO;
5604 char separator = SEPARATOR;
5605 uint bitmap_min = BITMAP_MIN;
5606 uint bitmap_max = BITMAP_MAX;
5607 char *custom_charset_1 = NULL;
5608 char *custom_charset_2 = NULL;
5609 char *custom_charset_3 = NULL;
5610 char *custom_charset_4 = NULL;
5611
5612 #define IDX_HELP 'h'
5613 #define IDX_VERSION 'V'
5614 #define IDX_VERSION_LOWER 'v'
5615 #define IDX_QUIET 0xff02
5616 #define IDX_SHOW 0xff03
5617 #define IDX_LEFT 0xff04
5618 #define IDX_REMOVE 0xff05
5619 #define IDX_REMOVE_TIMER 0xff37
5620 #define IDX_SKIP 's'
5621 #define IDX_LIMIT 'l'
5622 #define IDX_KEYSPACE 0xff35
5623 #define IDX_POTFILE_DISABLE 0xff06
5624 #define IDX_POTFILE_PATH 0xffe0
5625 #define IDX_DEBUG_MODE 0xff43
5626 #define IDX_DEBUG_FILE 0xff44
5627 #define IDX_INDUCTION_DIR 0xff46
5628 #define IDX_OUTFILE_CHECK_DIR 0xff47
5629 #define IDX_USERNAME 0xff07
5630 #define IDX_FORCE 0xff08
5631 #define IDX_RUNTIME 0xff09
5632 #define IDX_BENCHMARK 'b'
5633 #define IDX_HASH_MODE 'm'
5634 #define IDX_ATTACK_MODE 'a'
5635 #define IDX_RP_FILE 'r'
5636 #define IDX_RP_GEN 'g'
5637 #define IDX_RP_GEN_FUNC_MIN 0xff10
5638 #define IDX_RP_GEN_FUNC_MAX 0xff11
5639 #define IDX_RP_GEN_SEED 0xff34
5640 #define IDX_RULE_BUF_L 'j'
5641 #define IDX_RULE_BUF_R 'k'
5642 #define IDX_INCREMENT 'i'
5643 #define IDX_INCREMENT_MIN 0xff12
5644 #define IDX_INCREMENT_MAX 0xff13
5645 #define IDX_OUTFILE 'o'
5646 #define IDX_OUTFILE_FORMAT 0xff14
5647 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5648 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5649 #define IDX_RESTORE 0xff15
5650 #define IDX_RESTORE_DISABLE 0xff27
5651 #define IDX_STATUS 0xff17
5652 #define IDX_STATUS_TIMER 0xff18
5653 #define IDX_MACHINE_READABLE 0xff50
5654 #define IDX_LOOPBACK 0xff38
5655 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5656 #define IDX_SESSION 0xff19
5657 #define IDX_HEX_CHARSET 0xff20
5658 #define IDX_HEX_SALT 0xff21
5659 #define IDX_HEX_WORDLIST 0xff40
5660 #define IDX_MARKOV_DISABLE 0xff22
5661 #define IDX_MARKOV_CLASSIC 0xff23
5662 #define IDX_MARKOV_THRESHOLD 't'
5663 #define IDX_MARKOV_HCSTAT 0xff24
5664 #define IDX_CPU_AFFINITY 0xff25
5665 #define IDX_OPENCL_DEVICES 'd'
5666 #define IDX_OPENCL_PLATFORMS 0xff72
5667 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5668 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5669 #define IDX_WORKLOAD_PROFILE 'w'
5670 #define IDX_KERNEL_ACCEL 'n'
5671 #define IDX_KERNEL_LOOPS 'u'
5672 #define IDX_GPU_TEMP_DISABLE 0xff29
5673 #define IDX_GPU_TEMP_ABORT 0xff30
5674 #define IDX_GPU_TEMP_RETAIN 0xff31
5675 #define IDX_POWERTUNE_ENABLE 0xff41
5676 #define IDX_LOGFILE_DISABLE 0xff51
5677 #define IDX_TRUECRYPT_KEYFILES 0xff52
5678 #define IDX_VERACRYPT_KEYFILES 0xff53
5679 #define IDX_VERACRYPT_PIM 0xff54
5680 #define IDX_SCRYPT_TMTO 0xff61
5681 #define IDX_SEGMENT_SIZE 'c'
5682 #define IDX_SEPARATOR 'p'
5683 #define IDX_BITMAP_MIN 0xff70
5684 #define IDX_BITMAP_MAX 0xff71
5685 #define IDX_CUSTOM_CHARSET_1 '1'
5686 #define IDX_CUSTOM_CHARSET_2 '2'
5687 #define IDX_CUSTOM_CHARSET_3 '3'
5688 #define IDX_CUSTOM_CHARSET_4 '4'
5689
5690 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5691
5692 struct option long_options[] =
5693 {
5694 {"help", no_argument, 0, IDX_HELP},
5695 {"version", no_argument, 0, IDX_VERSION},
5696 {"quiet", no_argument, 0, IDX_QUIET},
5697 {"show", no_argument, 0, IDX_SHOW},
5698 {"left", no_argument, 0, IDX_LEFT},
5699 {"username", no_argument, 0, IDX_USERNAME},
5700 {"remove", no_argument, 0, IDX_REMOVE},
5701 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5702 {"skip", required_argument, 0, IDX_SKIP},
5703 {"limit", required_argument, 0, IDX_LIMIT},
5704 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5705 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5706 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5707 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5708 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5709 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5710 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5711 {"force", no_argument, 0, IDX_FORCE},
5712 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5713 {"restore", no_argument, 0, IDX_RESTORE},
5714 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5715 {"status", no_argument, 0, IDX_STATUS},
5716 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5717 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5718 {"loopback", no_argument, 0, IDX_LOOPBACK},
5719 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5720 {"session", required_argument, 0, IDX_SESSION},
5721 {"runtime", required_argument, 0, IDX_RUNTIME},
5722 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5723 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5724 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5725 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5726 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5727 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5728 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5729 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5730 {"rules-file", required_argument, 0, IDX_RP_FILE},
5731 {"outfile", required_argument, 0, IDX_OUTFILE},
5732 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5733 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5734 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5735 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5736 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5737 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5738 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5739 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5740 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5741 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5742 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5743 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5744 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5745 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5746 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5747 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5748 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5749 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5750 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5751 #ifdef HAVE_HWMON
5752 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5753 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5754 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5755 #endif // HAVE_HWMON
5756 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5757 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5758 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5759 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5760 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5761 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5762 {"seperator", required_argument, 0, IDX_SEPARATOR},
5763 {"separator", required_argument, 0, IDX_SEPARATOR},
5764 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5765 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5766 {"increment", no_argument, 0, IDX_INCREMENT},
5767 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5768 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5769 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5770 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5771 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5772 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5773 {0, 0, 0, 0}
5774 };
5775
5776 uint rp_files_cnt = 0;
5777
5778 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5779
5780 int option_index = 0;
5781 int c = -1;
5782
5783 optind = 1;
5784 optopt = 0;
5785
5786 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5787 {
5788 switch (c)
5789 {
5790 case IDX_HELP: usage = 1; break;
5791 case IDX_VERSION:
5792 case IDX_VERSION_LOWER: version = 1; break;
5793 case IDX_RESTORE: restore = 1; break;
5794 case IDX_SESSION: session = optarg; break;
5795 case IDX_SHOW: show = 1; break;
5796 case IDX_LEFT: left = 1; break;
5797 case '?': return (-1);
5798 }
5799 }
5800
5801 if (optopt != 0)
5802 {
5803 log_error ("ERROR: Invalid argument specified");
5804
5805 return (-1);
5806 }
5807
5808 /**
5809 * exit functions
5810 */
5811
5812 if (version)
5813 {
5814 log_info ("%s", VERSION_TAG);
5815
5816 return (0);
5817 }
5818
5819 if (usage)
5820 {
5821 usage_big_print (PROGNAME);
5822
5823 return (0);
5824 }
5825
5826 /**
5827 * session needs to be set, always!
5828 */
5829
5830 if (session == NULL) session = (char *) PROGNAME;
5831
5832 /**
5833 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5834 */
5835
5836 char *exec_path = get_exec_path ();
5837
5838 #ifdef LINUX
5839
5840 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5841 char *resolved_exec_path = realpath (exec_path, NULL);
5842
5843 char *install_dir = get_install_dir (resolved_exec_path);
5844 char *profile_dir = NULL;
5845 char *session_dir = NULL;
5846 char *shared_dir = NULL;
5847
5848 if (strcmp (install_dir, resolved_install_folder) == 0)
5849 {
5850 struct passwd *pw = getpwuid (getuid ());
5851
5852 const char *homedir = pw->pw_dir;
5853
5854 profile_dir = get_profile_dir (homedir);
5855 session_dir = get_session_dir (profile_dir);
5856 shared_dir = strdup (SHARED_FOLDER);
5857
5858 mkdir (profile_dir, 0700);
5859 mkdir (session_dir, 0700);
5860 }
5861 else
5862 {
5863 profile_dir = install_dir;
5864 session_dir = install_dir;
5865 shared_dir = install_dir;
5866 }
5867
5868 myfree (resolved_install_folder);
5869 myfree (resolved_exec_path);
5870
5871 #else
5872
5873 char *install_dir = get_install_dir (exec_path);
5874 char *profile_dir = install_dir;
5875 char *session_dir = install_dir;
5876 char *shared_dir = install_dir;
5877
5878 #endif
5879
5880 data.install_dir = install_dir;
5881 data.profile_dir = profile_dir;
5882 data.session_dir = session_dir;
5883 data.shared_dir = shared_dir;
5884
5885 myfree (exec_path);
5886
5887 /**
5888 * kernel cache, we need to make sure folder exist
5889 */
5890
5891 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5892
5893 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5894
5895 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5896
5897 mkdir (kernels_folder, 0700);
5898
5899 myfree (kernels_folder);
5900
5901 /**
5902 * session
5903 */
5904
5905 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5906
5907 data.session = session;
5908
5909 char *eff_restore_file = (char *) mymalloc (session_size);
5910 char *new_restore_file = (char *) mymalloc (session_size);
5911
5912 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5913 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5914
5915 data.eff_restore_file = eff_restore_file;
5916 data.new_restore_file = new_restore_file;
5917
5918 if (((show == 1) || (left == 1)) && (restore == 1))
5919 {
5920 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5921 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5922
5923 return (-1);
5924 }
5925
5926 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5927 if ((show == 1) || (left == 1))
5928 {
5929 restore_disable = 1;
5930
5931 restore = 0;
5932 }
5933
5934 data.restore_disable = restore_disable;
5935
5936 restore_data_t *rd = init_restore (argc, argv);
5937
5938 data.rd = rd;
5939
5940 /**
5941 * restore file
5942 */
5943
5944 if (restore == 1)
5945 {
5946 read_restore (eff_restore_file, rd);
5947
5948 if (rd->version_bin < RESTORE_MIN)
5949 {
5950 log_error ("ERROR: Incompatible restore-file version");
5951
5952 return (-1);
5953 }
5954
5955 myargc = rd->argc;
5956 myargv = rd->argv;
5957
5958 #ifdef _POSIX
5959 rd->pid = getpid ();
5960 #elif _WIN
5961 rd->pid = GetCurrentProcessId ();
5962 #endif
5963 }
5964
5965 uint hash_mode_chgd = 0;
5966 uint runtime_chgd = 0;
5967 uint kernel_loops_chgd = 0;
5968 uint kernel_accel_chgd = 0;
5969 uint attack_mode_chgd = 0;
5970 uint outfile_format_chgd = 0;
5971 uint rp_gen_seed_chgd = 0;
5972 uint remove_timer_chgd = 0;
5973 uint increment_min_chgd = 0;
5974 uint increment_max_chgd = 0;
5975 uint workload_profile_chgd = 0;
5976 uint opencl_vector_width_chgd = 0;
5977
5978 optind = 1;
5979 optopt = 0;
5980 option_index = 0;
5981
5982 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5983 {
5984 switch (c)
5985 {
5986 //case IDX_HELP: usage = 1; break;
5987 //case IDX_VERSION: version = 1; break;
5988 //case IDX_RESTORE: restore = 1; break;
5989 case IDX_QUIET: quiet = 1; break;
5990 //case IDX_SHOW: show = 1; break;
5991 case IDX_SHOW: break;
5992 //case IDX_LEFT: left = 1; break;
5993 case IDX_LEFT: break;
5994 case IDX_USERNAME: username = 1; break;
5995 case IDX_REMOVE: remove = 1; break;
5996 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5997 remove_timer_chgd = 1; break;
5998 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5999 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6000 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6001 case IDX_DEBUG_FILE: debug_file = optarg; break;
6002 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6003 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6004 case IDX_FORCE: force = 1; break;
6005 case IDX_SKIP: skip = atoll (optarg); break;
6006 case IDX_LIMIT: limit = atoll (optarg); break;
6007 case IDX_KEYSPACE: keyspace = 1; break;
6008 case IDX_BENCHMARK: benchmark = 1; break;
6009 case IDX_RESTORE: break;
6010 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6011 case IDX_STATUS: status = 1; break;
6012 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6013 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6014 case IDX_LOOPBACK: loopback = 1; break;
6015 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6016 //case IDX_SESSION: session = optarg; break;
6017 case IDX_SESSION: break;
6018 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6019 hash_mode_chgd = 1; break;
6020 case IDX_RUNTIME: runtime = atoi (optarg);
6021 runtime_chgd = 1; break;
6022 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6023 attack_mode_chgd = 1; break;
6024 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6025 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6026 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6027 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6028 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6029 rp_gen_seed_chgd = 1; break;
6030 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6031 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6032 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6033 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6034 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6035 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6036 case IDX_OUTFILE: outfile = optarg; break;
6037 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6038 outfile_format_chgd = 1; break;
6039 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6040 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6041 case IDX_HEX_CHARSET: hex_charset = 1; break;
6042 case IDX_HEX_SALT: hex_salt = 1; break;
6043 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6044 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6045 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6046 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6047 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6048 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6049 opencl_vector_width_chgd = 1; break;
6050 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6051 workload_profile_chgd = 1; break;
6052 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6053 kernel_accel_chgd = 1; break;
6054 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6055 kernel_loops_chgd = 1; break;
6056 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6057 #ifdef HAVE_HWMON
6058 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6059 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6060 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6061 #endif // HAVE_HWMON
6062 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6063 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6064 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6065 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6066 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6067 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6068 case IDX_SEPARATOR: separator = optarg[0]; break;
6069 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6070 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6071 case IDX_INCREMENT: increment = 1; break;
6072 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6073 increment_min_chgd = 1; break;
6074 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6075 increment_max_chgd = 1; break;
6076 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6077 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6078 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6079 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6080
6081 default:
6082 log_error ("ERROR: Invalid argument specified");
6083 return (-1);
6084 }
6085 }
6086
6087 if (optopt != 0)
6088 {
6089 log_error ("ERROR: Invalid argument specified");
6090
6091 return (-1);
6092 }
6093
6094 /**
6095 * Inform user things getting started,
6096 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6097 * - we do not need to check algorithm_pos
6098 */
6099
6100 if (quiet == 0)
6101 {
6102 if (benchmark == 1)
6103 {
6104 if (machine_readable == 0)
6105 {
6106 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6107 log_info ("");
6108 }
6109 else
6110 {
6111 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6112 }
6113 }
6114 else if (restore == 1)
6115 {
6116 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6117 log_info ("");
6118 }
6119 else
6120 {
6121 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6122 log_info ("");
6123 }
6124 }
6125
6126 /**
6127 * sanity check
6128 */
6129
6130 if (attack_mode > 7)
6131 {
6132 log_error ("ERROR: Invalid attack-mode specified");
6133
6134 return (-1);
6135 }
6136
6137 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6138 {
6139 log_error ("ERROR: Invalid runtime specified");
6140
6141 return (-1);
6142 }
6143
6144 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6145 {
6146 log_error ("ERROR: Invalid hash-type specified");
6147
6148 return (-1);
6149 }
6150
6151 // renamed hash modes
6152
6153 if (hash_mode_chgd)
6154 {
6155 int n = -1;
6156
6157 switch (hash_mode)
6158 {
6159 case 123: n = 124;
6160 break;
6161 }
6162
6163 if (n >= 0)
6164 {
6165 log_error ("Old -m specified, use -m %d instead", n);
6166
6167 return (-1);
6168 }
6169 }
6170
6171 if (username == 1)
6172 {
6173 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6174 {
6175 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6176
6177 return (-1);
6178 }
6179 }
6180
6181 if (outfile_format > 16)
6182 {
6183 log_error ("ERROR: Invalid outfile-format specified");
6184
6185 return (-1);
6186 }
6187
6188 if (left == 1)
6189 {
6190 if (outfile_format_chgd == 1)
6191 {
6192 if (outfile_format > 1)
6193 {
6194 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6195
6196 return (-1);
6197 }
6198 }
6199 else
6200 {
6201 outfile_format = OUTFILE_FMT_HASH;
6202 }
6203 }
6204
6205 if (show == 1)
6206 {
6207 if (outfile_format_chgd == 1)
6208 {
6209 if ((outfile_format > 7) && (outfile_format < 16))
6210 {
6211 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6212
6213 return (-1);
6214 }
6215 }
6216 }
6217
6218 if (increment_min < INCREMENT_MIN)
6219 {
6220 log_error ("ERROR: Invalid increment-min specified");
6221
6222 return (-1);
6223 }
6224
6225 if (increment_max > INCREMENT_MAX)
6226 {
6227 log_error ("ERROR: Invalid increment-max specified");
6228
6229 return (-1);
6230 }
6231
6232 if (increment_min > increment_max)
6233 {
6234 log_error ("ERROR: Invalid increment-min specified");
6235
6236 return (-1);
6237 }
6238
6239 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6240 {
6241 log_error ("ERROR: increment is not allowed in attack-mode 0");
6242
6243 return (-1);
6244 }
6245
6246 if ((increment == 0) && (increment_min_chgd == 1))
6247 {
6248 log_error ("ERROR: increment-min is only supported together with increment switch");
6249
6250 return (-1);
6251 }
6252
6253 if ((increment == 0) && (increment_max_chgd == 1))
6254 {
6255 log_error ("ERROR: increment-max is only supported together with increment switch");
6256
6257 return (-1);
6258 }
6259
6260 if (rp_files_cnt && rp_gen)
6261 {
6262 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6263
6264 return (-1);
6265 }
6266
6267 if (rp_files_cnt || rp_gen)
6268 {
6269 if (attack_mode != ATTACK_MODE_STRAIGHT)
6270 {
6271 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6272
6273 return (-1);
6274 }
6275 }
6276
6277 if (rp_gen_func_min > rp_gen_func_max)
6278 {
6279 log_error ("ERROR: Invalid rp-gen-func-min specified");
6280
6281 return (-1);
6282 }
6283
6284 if (kernel_accel_chgd == 1)
6285 {
6286 if (force == 0)
6287 {
6288 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6289 log_info ("Please consider using the option -w instead");
6290 log_info ("You can use --force to override this but do not post error reports if you do so");
6291 log_info ("");
6292
6293 return (-1);
6294 }
6295
6296 if (kernel_accel < 1)
6297 {
6298 log_error ("ERROR: Invalid kernel-accel specified");
6299
6300 return (-1);
6301 }
6302
6303 if (kernel_accel > 1024)
6304 {
6305 log_error ("ERROR: Invalid kernel-accel specified");
6306
6307 return (-1);
6308 }
6309 }
6310
6311 if (kernel_loops_chgd == 1)
6312 {
6313 if (force == 0)
6314 {
6315 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6316 log_info ("Please consider using the option -w instead");
6317 log_info ("You can use --force to override this but do not post error reports if you do so");
6318 log_info ("");
6319
6320 return (-1);
6321 }
6322
6323 if (kernel_loops < 1)
6324 {
6325 log_error ("ERROR: Invalid kernel-loops specified");
6326
6327 return (-1);
6328 }
6329
6330 if (kernel_loops > 1024)
6331 {
6332 log_error ("ERROR: Invalid kernel-loops specified");
6333
6334 return (-1);
6335 }
6336 }
6337
6338 if ((workload_profile < 1) || (workload_profile > 4))
6339 {
6340 log_error ("ERROR: workload-profile %i not available", workload_profile);
6341
6342 return (-1);
6343 }
6344
6345 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6346 {
6347 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6348
6349 return (-1);
6350 }
6351
6352 if (show == 1 || left == 1)
6353 {
6354 attack_mode = ATTACK_MODE_NONE;
6355
6356 if (remove == 1)
6357 {
6358 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6359
6360 return (-1);
6361 }
6362
6363 if (potfile_disable == 1)
6364 {
6365 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6366
6367 return (-1);
6368 }
6369 }
6370
6371 uint attack_kern = ATTACK_KERN_NONE;
6372
6373 switch (attack_mode)
6374 {
6375 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6376 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6377 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6378 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6379 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6380 }
6381
6382 if (benchmark == 0)
6383 {
6384 if (keyspace == 1)
6385 {
6386 int num_additional_params = 1;
6387
6388 if (attack_kern == ATTACK_KERN_COMBI)
6389 {
6390 num_additional_params = 2;
6391 }
6392
6393 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6394
6395 if (keyspace_wordlist_specified == 0) optind--;
6396 }
6397
6398 if (attack_kern == ATTACK_KERN_NONE)
6399 {
6400 if ((optind + 1) != myargc)
6401 {
6402 usage_mini_print (myargv[0]);
6403
6404 return (-1);
6405 }
6406 }
6407 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6408 {
6409 if ((optind + 1) > myargc)
6410 {
6411 usage_mini_print (myargv[0]);
6412
6413 return (-1);
6414 }
6415 }
6416 else if (attack_kern == ATTACK_KERN_COMBI)
6417 {
6418 if ((optind + 3) != myargc)
6419 {
6420 usage_mini_print (myargv[0]);
6421
6422 return (-1);
6423 }
6424 }
6425 else if (attack_kern == ATTACK_KERN_BF)
6426 {
6427 if ((optind + 1) > myargc)
6428 {
6429 usage_mini_print (myargv[0]);
6430
6431 return (-1);
6432 }
6433 }
6434 else
6435 {
6436 usage_mini_print (myargv[0]);
6437
6438 return (-1);
6439 }
6440 }
6441 else
6442 {
6443 if (myargv[optind] != 0)
6444 {
6445 log_error ("ERROR: Invalid argument for benchmark mode specified");
6446
6447 return (-1);
6448 }
6449
6450 if (attack_mode_chgd == 1)
6451 {
6452 if (attack_mode != ATTACK_MODE_BF)
6453 {
6454 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6455
6456 return (-1);
6457 }
6458 }
6459 }
6460
6461 if (skip != 0 && limit != 0)
6462 {
6463 limit += skip;
6464 }
6465
6466 if (keyspace == 1)
6467 {
6468 if (show == 1)
6469 {
6470 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6471
6472 return (-1);
6473 }
6474 else if (left == 1)
6475 {
6476 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6477
6478 return (-1);
6479 }
6480
6481 potfile_disable = 1;
6482
6483 restore_disable = 1;
6484
6485 restore = 0;
6486
6487 weak_hash_threshold = 0;
6488
6489 quiet = 1;
6490 }
6491
6492 if (remove_timer_chgd == 1)
6493 {
6494 if (remove == 0)
6495 {
6496 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6497
6498 return (-1);
6499 }
6500
6501 if (remove_timer < 1)
6502 {
6503 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6504
6505 return (-1);
6506 }
6507 }
6508
6509 if (loopback == 1)
6510 {
6511 if (attack_mode == ATTACK_MODE_STRAIGHT)
6512 {
6513 if ((rp_files_cnt == 0) && (rp_gen == 0))
6514 {
6515 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6516
6517 return (-1);
6518 }
6519 }
6520 else
6521 {
6522 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6523
6524 return (-1);
6525 }
6526 }
6527
6528 if (debug_mode > 0)
6529 {
6530 if (attack_mode != ATTACK_MODE_STRAIGHT)
6531 {
6532 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6533
6534 return (-1);
6535 }
6536
6537 if ((rp_files_cnt == 0) && (rp_gen == 0))
6538 {
6539 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6540
6541 return (-1);
6542 }
6543 }
6544
6545 if (debug_mode > 4)
6546 {
6547 log_error ("ERROR: Invalid debug-mode specified");
6548
6549 return (-1);
6550 }
6551
6552 if (debug_file != NULL)
6553 {
6554 if (debug_mode < 1)
6555 {
6556 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6557
6558 return (-1);
6559 }
6560 }
6561
6562 if (induction_dir != NULL)
6563 {
6564 if (attack_mode == ATTACK_MODE_BF)
6565 {
6566 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6567
6568 return (-1);
6569 }
6570 }
6571
6572 if (attack_mode != ATTACK_MODE_STRAIGHT)
6573 {
6574 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6575 {
6576 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6577
6578 return (-1);
6579 }
6580
6581 weak_hash_threshold = 0;
6582 }
6583
6584 /**
6585 * induction directory
6586 */
6587
6588 char *induction_directory = NULL;
6589
6590 if (attack_mode != ATTACK_MODE_BF)
6591 {
6592 if (induction_dir == NULL)
6593 {
6594 induction_directory = (char *) mymalloc (session_size);
6595
6596 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6597
6598 // create induction folder if it does not already exist
6599
6600 if (keyspace == 0)
6601 {
6602 if (rmdir (induction_directory) == -1)
6603 {
6604 if (errno == ENOENT)
6605 {
6606 // good, we can ignore
6607 }
6608 else if (errno == ENOTEMPTY)
6609 {
6610 char *induction_directory_mv = (char *) mymalloc (session_size);
6611
6612 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6613
6614 if (rename (induction_directory, induction_directory_mv) != 0)
6615 {
6616 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6617
6618 return (-1);
6619 }
6620 }
6621 else
6622 {
6623 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6624
6625 return (-1);
6626 }
6627 }
6628
6629 if (mkdir (induction_directory, 0700) == -1)
6630 {
6631 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6632
6633 return (-1);
6634 }
6635 }
6636 }
6637 else
6638 {
6639 induction_directory = induction_dir;
6640 }
6641 }
6642
6643 data.induction_directory = induction_directory;
6644
6645 /**
6646 * loopback
6647 */
6648
6649 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6650
6651 char *loopback_file = (char *) mymalloc (loopback_size);
6652
6653 /**
6654 * tuning db
6655 */
6656
6657 char tuning_db_file[256] = { 0 };
6658
6659 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6660
6661 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6662
6663 /**
6664 * outfile-check directory
6665 */
6666
6667 char *outfile_check_directory = NULL;
6668
6669 if (outfile_check_dir == NULL)
6670 {
6671 outfile_check_directory = (char *) mymalloc (session_size);
6672
6673 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6674 }
6675 else
6676 {
6677 outfile_check_directory = outfile_check_dir;
6678 }
6679
6680 data.outfile_check_directory = outfile_check_directory;
6681
6682 if (keyspace == 0)
6683 {
6684 struct stat outfile_check_stat;
6685
6686 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6687 {
6688 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6689
6690 if (is_dir == 0)
6691 {
6692 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6693
6694 return (-1);
6695 }
6696 }
6697 else if (outfile_check_dir == NULL)
6698 {
6699 if (mkdir (outfile_check_directory, 0700) == -1)
6700 {
6701 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6702
6703 return (-1);
6704 }
6705 }
6706 }
6707
6708 /**
6709 * special other stuff
6710 */
6711
6712 if (hash_mode == 9710)
6713 {
6714 outfile_format = 5;
6715 outfile_format_chgd = 1;
6716 }
6717
6718 if (hash_mode == 9810)
6719 {
6720 outfile_format = 5;
6721 outfile_format_chgd = 1;
6722 }
6723
6724 if (hash_mode == 10410)
6725 {
6726 outfile_format = 5;
6727 outfile_format_chgd = 1;
6728 }
6729
6730 /**
6731 * store stuff
6732 */
6733
6734 data.hash_mode = hash_mode;
6735 data.restore = restore;
6736 data.restore_timer = restore_timer;
6737 data.restore_disable = restore_disable;
6738 data.status = status;
6739 data.status_timer = status_timer;
6740 data.machine_readable = machine_readable;
6741 data.loopback = loopback;
6742 data.runtime = runtime;
6743 data.remove = remove;
6744 data.remove_timer = remove_timer;
6745 data.debug_mode = debug_mode;
6746 data.debug_file = debug_file;
6747 data.username = username;
6748 data.quiet = quiet;
6749 data.outfile = outfile;
6750 data.outfile_format = outfile_format;
6751 data.outfile_autohex = outfile_autohex;
6752 data.hex_charset = hex_charset;
6753 data.hex_salt = hex_salt;
6754 data.hex_wordlist = hex_wordlist;
6755 data.separator = separator;
6756 data.rp_files = rp_files;
6757 data.rp_files_cnt = rp_files_cnt;
6758 data.rp_gen = rp_gen;
6759 data.rp_gen_seed = rp_gen_seed;
6760 data.force = force;
6761 data.benchmark = benchmark;
6762 data.skip = skip;
6763 data.limit = limit;
6764 #ifdef HAVE_HWMON
6765 data.powertune_enable = powertune_enable;
6766 #endif
6767 data.logfile_disable = logfile_disable;
6768 data.truecrypt_keyfiles = truecrypt_keyfiles;
6769 data.veracrypt_keyfiles = veracrypt_keyfiles;
6770 data.veracrypt_pim = veracrypt_pim;
6771 data.scrypt_tmto = scrypt_tmto;
6772 data.workload_profile = workload_profile;
6773
6774 /**
6775 * cpu affinity
6776 */
6777
6778 if (cpu_affinity)
6779 {
6780 set_cpu_affinity (cpu_affinity);
6781 }
6782
6783 if (rp_gen_seed_chgd == 0)
6784 {
6785 srand (proc_start);
6786 }
6787 else
6788 {
6789 srand (rp_gen_seed);
6790 }
6791
6792 /**
6793 * logfile init
6794 */
6795
6796 if (logfile_disable == 0)
6797 {
6798 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6799
6800 char *logfile = (char *) mymalloc (logfile_size);
6801
6802 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6803
6804 data.logfile = logfile;
6805
6806 char *topid = logfile_generate_topid ();
6807
6808 data.topid = topid;
6809 }
6810
6811 // logfile_append() checks for logfile_disable internally to make it easier from here
6812
6813 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6814 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6815 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6816 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6817 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6818 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6819 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6820 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6821 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6822 #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));
6823
6824 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6825 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6826 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6827 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6828 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6829 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6830 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6831 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6832
6833 logfile_top_msg ("START");
6834
6835 logfile_top_uint (attack_mode);
6836 logfile_top_uint (attack_kern);
6837 logfile_top_uint (benchmark);
6838 logfile_top_uint (bitmap_min);
6839 logfile_top_uint (bitmap_max);
6840 logfile_top_uint (debug_mode);
6841 logfile_top_uint (force);
6842 logfile_top_uint (kernel_accel);
6843 logfile_top_uint (kernel_loops);
6844 logfile_top_uint (gpu_temp_disable);
6845 #ifdef HAVE_HWMON
6846 logfile_top_uint (gpu_temp_abort);
6847 logfile_top_uint (gpu_temp_retain);
6848 #endif
6849 logfile_top_uint (hash_mode);
6850 logfile_top_uint (hex_charset);
6851 logfile_top_uint (hex_salt);
6852 logfile_top_uint (hex_wordlist);
6853 logfile_top_uint (increment);
6854 logfile_top_uint (increment_max);
6855 logfile_top_uint (increment_min);
6856 logfile_top_uint (keyspace);
6857 logfile_top_uint (left);
6858 logfile_top_uint (logfile_disable);
6859 logfile_top_uint (loopback);
6860 logfile_top_uint (markov_classic);
6861 logfile_top_uint (markov_disable);
6862 logfile_top_uint (markov_threshold);
6863 logfile_top_uint (outfile_autohex);
6864 logfile_top_uint (outfile_check_timer);
6865 logfile_top_uint (outfile_format);
6866 logfile_top_uint (potfile_disable);
6867 logfile_top_string (potfile_path);
6868 #if defined(HAVE_HWMON)
6869 logfile_top_uint (powertune_enable);
6870 #endif
6871 logfile_top_uint (scrypt_tmto);
6872 logfile_top_uint (quiet);
6873 logfile_top_uint (remove);
6874 logfile_top_uint (remove_timer);
6875 logfile_top_uint (restore);
6876 logfile_top_uint (restore_disable);
6877 logfile_top_uint (restore_timer);
6878 logfile_top_uint (rp_gen);
6879 logfile_top_uint (rp_gen_func_max);
6880 logfile_top_uint (rp_gen_func_min);
6881 logfile_top_uint (rp_gen_seed);
6882 logfile_top_uint (runtime);
6883 logfile_top_uint (segment_size);
6884 logfile_top_uint (show);
6885 logfile_top_uint (status);
6886 logfile_top_uint (machine_readable);
6887 logfile_top_uint (status_timer);
6888 logfile_top_uint (usage);
6889 logfile_top_uint (username);
6890 logfile_top_uint (version);
6891 logfile_top_uint (weak_hash_threshold);
6892 logfile_top_uint (workload_profile);
6893 logfile_top_uint64 (limit);
6894 logfile_top_uint64 (skip);
6895 logfile_top_char (separator);
6896 logfile_top_string (cpu_affinity);
6897 logfile_top_string (custom_charset_1);
6898 logfile_top_string (custom_charset_2);
6899 logfile_top_string (custom_charset_3);
6900 logfile_top_string (custom_charset_4);
6901 logfile_top_string (debug_file);
6902 logfile_top_string (opencl_devices);
6903 logfile_top_string (opencl_platforms);
6904 logfile_top_string (opencl_device_types);
6905 logfile_top_uint (opencl_vector_width);
6906 logfile_top_string (induction_dir);
6907 logfile_top_string (markov_hcstat);
6908 logfile_top_string (outfile);
6909 logfile_top_string (outfile_check_dir);
6910 logfile_top_string (rule_buf_l);
6911 logfile_top_string (rule_buf_r);
6912 logfile_top_string (session);
6913 logfile_top_string (truecrypt_keyfiles);
6914 logfile_top_string (veracrypt_keyfiles);
6915 logfile_top_uint (veracrypt_pim);
6916
6917 /**
6918 * Init OpenCL library loader
6919 */
6920
6921 if (keyspace == 0)
6922 {
6923 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6924
6925 ocl_init (ocl);
6926
6927 data.ocl = ocl;
6928 }
6929
6930 /**
6931 * OpenCL platform selection
6932 */
6933
6934 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6935
6936 /**
6937 * OpenCL device selection
6938 */
6939
6940 u32 devices_filter = setup_devices_filter (opencl_devices);
6941
6942 /**
6943 * OpenCL device type selection
6944 */
6945
6946 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6947
6948 /**
6949 * benchmark
6950 */
6951
6952 if (benchmark == 1)
6953 {
6954 /**
6955 * disable useless stuff for benchmark
6956 */
6957
6958 status_timer = 0;
6959 restore_timer = 0;
6960 restore_disable = 1;
6961 potfile_disable = 1;
6962 weak_hash_threshold = 0;
6963 gpu_temp_disable = 1;
6964
6965 #ifdef HAVE_HWMON
6966 powertune_enable = 1;
6967 #endif
6968
6969 data.status_timer = status_timer;
6970 data.restore_timer = restore_timer;
6971 data.restore_disable = restore_disable;
6972
6973 /**
6974 * force attack mode to be bruteforce
6975 */
6976
6977 attack_mode = ATTACK_MODE_BF;
6978 attack_kern = ATTACK_KERN_BF;
6979
6980 if (workload_profile_chgd == 0)
6981 {
6982 workload_profile = 3;
6983
6984 data.workload_profile = workload_profile;
6985 }
6986 }
6987
6988 /**
6989 * config
6990 */
6991
6992 uint hash_type = 0;
6993 uint salt_type = 0;
6994 uint attack_exec = 0;
6995 uint opts_type = 0;
6996 uint kern_type = 0;
6997 uint dgst_size = 0;
6998 uint esalt_size = 0;
6999 uint opti_type = 0;
7000 uint dgst_pos0 = -1;
7001 uint dgst_pos1 = -1;
7002 uint dgst_pos2 = -1;
7003 uint dgst_pos3 = -1;
7004
7005 int (*parse_func) (char *, uint, hash_t *);
7006 int (*sort_by_digest) (const void *, const void *);
7007
7008 uint algorithm_pos = 0;
7009 uint algorithm_max = 1;
7010
7011 uint *algorithms = default_benchmark_algorithms;
7012
7013 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7014
7015 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7016 {
7017 /*
7018 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7019 * the following algos are skipped entirely
7020 */
7021
7022 if (algorithm_pos > 0)
7023 {
7024 local_free (rd);
7025
7026 rd = init_restore (argc, argv);
7027
7028 data.rd = rd;
7029 }
7030
7031 /**
7032 * update hash_mode in case of multihash benchmark
7033 */
7034
7035 if (benchmark == 1)
7036 {
7037 if (hash_mode_chgd == 0)
7038 {
7039 hash_mode = algorithms[algorithm_pos];
7040
7041 data.hash_mode = hash_mode;
7042 }
7043
7044 quiet = 1;
7045
7046 data.quiet = quiet;
7047 }
7048
7049 switch (hash_mode)
7050 {
7051 case 0: hash_type = HASH_TYPE_MD5;
7052 salt_type = SALT_TYPE_NONE;
7053 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7054 opts_type = OPTS_TYPE_PT_GENERATE_LE
7055 | OPTS_TYPE_PT_ADD80
7056 | OPTS_TYPE_PT_ADDBITS14;
7057 kern_type = KERN_TYPE_MD5;
7058 dgst_size = DGST_SIZE_4_4;
7059 parse_func = md5_parse_hash;
7060 sort_by_digest = sort_by_digest_4_4;
7061 opti_type = OPTI_TYPE_ZERO_BYTE
7062 | OPTI_TYPE_PRECOMPUTE_INIT
7063 | OPTI_TYPE_PRECOMPUTE_MERKLE
7064 | OPTI_TYPE_MEET_IN_MIDDLE
7065 | OPTI_TYPE_EARLY_SKIP
7066 | OPTI_TYPE_NOT_ITERATED
7067 | OPTI_TYPE_NOT_SALTED
7068 | OPTI_TYPE_RAW_HASH;
7069 dgst_pos0 = 0;
7070 dgst_pos1 = 3;
7071 dgst_pos2 = 2;
7072 dgst_pos3 = 1;
7073 break;
7074
7075 case 10: hash_type = HASH_TYPE_MD5;
7076 salt_type = SALT_TYPE_INTERN;
7077 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7078 opts_type = OPTS_TYPE_PT_GENERATE_LE
7079 | OPTS_TYPE_ST_ADD80
7080 | OPTS_TYPE_ST_ADDBITS14;
7081 kern_type = KERN_TYPE_MD5_PWSLT;
7082 dgst_size = DGST_SIZE_4_4;
7083 parse_func = md5s_parse_hash;
7084 sort_by_digest = sort_by_digest_4_4;
7085 opti_type = OPTI_TYPE_ZERO_BYTE
7086 | OPTI_TYPE_PRECOMPUTE_INIT
7087 | OPTI_TYPE_PRECOMPUTE_MERKLE
7088 | OPTI_TYPE_MEET_IN_MIDDLE
7089 | OPTI_TYPE_EARLY_SKIP
7090 | OPTI_TYPE_NOT_ITERATED
7091 | OPTI_TYPE_APPENDED_SALT
7092 | OPTI_TYPE_RAW_HASH;
7093 dgst_pos0 = 0;
7094 dgst_pos1 = 3;
7095 dgst_pos2 = 2;
7096 dgst_pos3 = 1;
7097 break;
7098
7099 case 11: hash_type = HASH_TYPE_MD5;
7100 salt_type = SALT_TYPE_INTERN;
7101 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7102 opts_type = OPTS_TYPE_PT_GENERATE_LE
7103 | OPTS_TYPE_ST_ADD80
7104 | OPTS_TYPE_ST_ADDBITS14;
7105 kern_type = KERN_TYPE_MD5_PWSLT;
7106 dgst_size = DGST_SIZE_4_4;
7107 parse_func = joomla_parse_hash;
7108 sort_by_digest = sort_by_digest_4_4;
7109 opti_type = OPTI_TYPE_ZERO_BYTE
7110 | OPTI_TYPE_PRECOMPUTE_INIT
7111 | OPTI_TYPE_PRECOMPUTE_MERKLE
7112 | OPTI_TYPE_MEET_IN_MIDDLE
7113 | OPTI_TYPE_EARLY_SKIP
7114 | OPTI_TYPE_NOT_ITERATED
7115 | OPTI_TYPE_APPENDED_SALT
7116 | OPTI_TYPE_RAW_HASH;
7117 dgst_pos0 = 0;
7118 dgst_pos1 = 3;
7119 dgst_pos2 = 2;
7120 dgst_pos3 = 1;
7121 break;
7122
7123 case 12: hash_type = HASH_TYPE_MD5;
7124 salt_type = SALT_TYPE_INTERN;
7125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7126 opts_type = OPTS_TYPE_PT_GENERATE_LE
7127 | OPTS_TYPE_ST_ADD80
7128 | OPTS_TYPE_ST_ADDBITS14;
7129 kern_type = KERN_TYPE_MD5_PWSLT;
7130 dgst_size = DGST_SIZE_4_4;
7131 parse_func = postgresql_parse_hash;
7132 sort_by_digest = sort_by_digest_4_4;
7133 opti_type = OPTI_TYPE_ZERO_BYTE
7134 | OPTI_TYPE_PRECOMPUTE_INIT
7135 | OPTI_TYPE_PRECOMPUTE_MERKLE
7136 | OPTI_TYPE_MEET_IN_MIDDLE
7137 | OPTI_TYPE_EARLY_SKIP
7138 | OPTI_TYPE_NOT_ITERATED
7139 | OPTI_TYPE_APPENDED_SALT
7140 | OPTI_TYPE_RAW_HASH;
7141 dgst_pos0 = 0;
7142 dgst_pos1 = 3;
7143 dgst_pos2 = 2;
7144 dgst_pos3 = 1;
7145 break;
7146
7147 case 20: hash_type = HASH_TYPE_MD5;
7148 salt_type = SALT_TYPE_INTERN;
7149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7150 opts_type = OPTS_TYPE_PT_GENERATE_LE
7151 | OPTS_TYPE_PT_ADD80
7152 | OPTS_TYPE_PT_ADDBITS14;
7153 kern_type = KERN_TYPE_MD5_SLTPW;
7154 dgst_size = DGST_SIZE_4_4;
7155 parse_func = md5s_parse_hash;
7156 sort_by_digest = sort_by_digest_4_4;
7157 opti_type = OPTI_TYPE_ZERO_BYTE
7158 | OPTI_TYPE_PRECOMPUTE_INIT
7159 | OPTI_TYPE_PRECOMPUTE_MERKLE
7160 | OPTI_TYPE_EARLY_SKIP
7161 | OPTI_TYPE_NOT_ITERATED
7162 | OPTI_TYPE_PREPENDED_SALT
7163 | OPTI_TYPE_RAW_HASH;
7164 dgst_pos0 = 0;
7165 dgst_pos1 = 3;
7166 dgst_pos2 = 2;
7167 dgst_pos3 = 1;
7168 break;
7169
7170 case 21: hash_type = HASH_TYPE_MD5;
7171 salt_type = SALT_TYPE_INTERN;
7172 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7173 opts_type = OPTS_TYPE_PT_GENERATE_LE
7174 | OPTS_TYPE_PT_ADD80
7175 | OPTS_TYPE_PT_ADDBITS14;
7176 kern_type = KERN_TYPE_MD5_SLTPW;
7177 dgst_size = DGST_SIZE_4_4;
7178 parse_func = osc_parse_hash;
7179 sort_by_digest = sort_by_digest_4_4;
7180 opti_type = OPTI_TYPE_ZERO_BYTE
7181 | OPTI_TYPE_PRECOMPUTE_INIT
7182 | OPTI_TYPE_PRECOMPUTE_MERKLE
7183 | OPTI_TYPE_EARLY_SKIP
7184 | OPTI_TYPE_NOT_ITERATED
7185 | OPTI_TYPE_PREPENDED_SALT
7186 | OPTI_TYPE_RAW_HASH;
7187 dgst_pos0 = 0;
7188 dgst_pos1 = 3;
7189 dgst_pos2 = 2;
7190 dgst_pos3 = 1;
7191 break;
7192
7193 case 22: hash_type = HASH_TYPE_MD5;
7194 salt_type = SALT_TYPE_EMBEDDED;
7195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7196 opts_type = OPTS_TYPE_PT_GENERATE_LE
7197 | OPTS_TYPE_PT_ADD80
7198 | OPTS_TYPE_PT_ADDBITS14;
7199 kern_type = KERN_TYPE_MD5_SLTPW;
7200 dgst_size = DGST_SIZE_4_4;
7201 parse_func = netscreen_parse_hash;
7202 sort_by_digest = sort_by_digest_4_4;
7203 opti_type = OPTI_TYPE_ZERO_BYTE
7204 | OPTI_TYPE_PRECOMPUTE_INIT
7205 | OPTI_TYPE_PRECOMPUTE_MERKLE
7206 | OPTI_TYPE_EARLY_SKIP
7207 | OPTI_TYPE_NOT_ITERATED
7208 | OPTI_TYPE_PREPENDED_SALT
7209 | OPTI_TYPE_RAW_HASH;
7210 dgst_pos0 = 0;
7211 dgst_pos1 = 3;
7212 dgst_pos2 = 2;
7213 dgst_pos3 = 1;
7214 break;
7215
7216 case 23: hash_type = HASH_TYPE_MD5;
7217 salt_type = SALT_TYPE_EMBEDDED;
7218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7219 opts_type = OPTS_TYPE_PT_GENERATE_LE
7220 | OPTS_TYPE_PT_ADD80
7221 | OPTS_TYPE_PT_ADDBITS14;
7222 kern_type = KERN_TYPE_MD5_SLTPW;
7223 dgst_size = DGST_SIZE_4_4;
7224 parse_func = skype_parse_hash;
7225 sort_by_digest = sort_by_digest_4_4;
7226 opti_type = OPTI_TYPE_ZERO_BYTE
7227 | OPTI_TYPE_PRECOMPUTE_INIT
7228 | OPTI_TYPE_PRECOMPUTE_MERKLE
7229 | OPTI_TYPE_EARLY_SKIP
7230 | OPTI_TYPE_NOT_ITERATED
7231 | OPTI_TYPE_PREPENDED_SALT
7232 | OPTI_TYPE_RAW_HASH;
7233 dgst_pos0 = 0;
7234 dgst_pos1 = 3;
7235 dgst_pos2 = 2;
7236 dgst_pos3 = 1;
7237 break;
7238
7239 case 30: hash_type = HASH_TYPE_MD5;
7240 salt_type = SALT_TYPE_INTERN;
7241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7242 opts_type = OPTS_TYPE_PT_GENERATE_LE
7243 | OPTS_TYPE_PT_UNICODE
7244 | OPTS_TYPE_ST_ADD80
7245 | OPTS_TYPE_ST_ADDBITS14;
7246 kern_type = KERN_TYPE_MD5_PWUSLT;
7247 dgst_size = DGST_SIZE_4_4;
7248 parse_func = md5s_parse_hash;
7249 sort_by_digest = sort_by_digest_4_4;
7250 opti_type = OPTI_TYPE_ZERO_BYTE
7251 | OPTI_TYPE_PRECOMPUTE_INIT
7252 | OPTI_TYPE_PRECOMPUTE_MERKLE
7253 | OPTI_TYPE_MEET_IN_MIDDLE
7254 | OPTI_TYPE_EARLY_SKIP
7255 | OPTI_TYPE_NOT_ITERATED
7256 | OPTI_TYPE_APPENDED_SALT
7257 | OPTI_TYPE_RAW_HASH;
7258 dgst_pos0 = 0;
7259 dgst_pos1 = 3;
7260 dgst_pos2 = 2;
7261 dgst_pos3 = 1;
7262 break;
7263
7264 case 40: hash_type = HASH_TYPE_MD5;
7265 salt_type = SALT_TYPE_INTERN;
7266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7267 opts_type = OPTS_TYPE_PT_GENERATE_LE
7268 | OPTS_TYPE_PT_ADD80
7269 | OPTS_TYPE_PT_ADDBITS14
7270 | OPTS_TYPE_PT_UNICODE;
7271 kern_type = KERN_TYPE_MD5_SLTPWU;
7272 dgst_size = DGST_SIZE_4_4;
7273 parse_func = md5s_parse_hash;
7274 sort_by_digest = sort_by_digest_4_4;
7275 opti_type = OPTI_TYPE_ZERO_BYTE
7276 | OPTI_TYPE_PRECOMPUTE_INIT
7277 | OPTI_TYPE_PRECOMPUTE_MERKLE
7278 | OPTI_TYPE_EARLY_SKIP
7279 | OPTI_TYPE_NOT_ITERATED
7280 | OPTI_TYPE_PREPENDED_SALT
7281 | OPTI_TYPE_RAW_HASH;
7282 dgst_pos0 = 0;
7283 dgst_pos1 = 3;
7284 dgst_pos2 = 2;
7285 dgst_pos3 = 1;
7286 break;
7287
7288 case 50: hash_type = HASH_TYPE_MD5;
7289 salt_type = SALT_TYPE_INTERN;
7290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7291 opts_type = OPTS_TYPE_PT_GENERATE_LE
7292 | OPTS_TYPE_ST_ADD80
7293 | OPTS_TYPE_ST_ADDBITS14;
7294 kern_type = KERN_TYPE_HMACMD5_PW;
7295 dgst_size = DGST_SIZE_4_4;
7296 parse_func = hmacmd5_parse_hash;
7297 sort_by_digest = sort_by_digest_4_4;
7298 opti_type = OPTI_TYPE_ZERO_BYTE
7299 | OPTI_TYPE_NOT_ITERATED;
7300 dgst_pos0 = 0;
7301 dgst_pos1 = 3;
7302 dgst_pos2 = 2;
7303 dgst_pos3 = 1;
7304 break;
7305
7306 case 60: hash_type = HASH_TYPE_MD5;
7307 salt_type = SALT_TYPE_INTERN;
7308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7309 opts_type = OPTS_TYPE_PT_GENERATE_LE
7310 | OPTS_TYPE_PT_ADD80
7311 | OPTS_TYPE_PT_ADDBITS14;
7312 kern_type = KERN_TYPE_HMACMD5_SLT;
7313 dgst_size = DGST_SIZE_4_4;
7314 parse_func = hmacmd5_parse_hash;
7315 sort_by_digest = sort_by_digest_4_4;
7316 opti_type = OPTI_TYPE_ZERO_BYTE
7317 | OPTI_TYPE_NOT_ITERATED;
7318 dgst_pos0 = 0;
7319 dgst_pos1 = 3;
7320 dgst_pos2 = 2;
7321 dgst_pos3 = 1;
7322 break;
7323
7324 case 100: hash_type = HASH_TYPE_SHA1;
7325 salt_type = SALT_TYPE_NONE;
7326 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7327 opts_type = OPTS_TYPE_PT_GENERATE_BE
7328 | OPTS_TYPE_PT_ADD80
7329 | OPTS_TYPE_PT_ADDBITS15;
7330 kern_type = KERN_TYPE_SHA1;
7331 dgst_size = DGST_SIZE_4_5;
7332 parse_func = sha1_parse_hash;
7333 sort_by_digest = sort_by_digest_4_5;
7334 opti_type = OPTI_TYPE_ZERO_BYTE
7335 | OPTI_TYPE_PRECOMPUTE_INIT
7336 | OPTI_TYPE_PRECOMPUTE_MERKLE
7337 | OPTI_TYPE_EARLY_SKIP
7338 | OPTI_TYPE_NOT_ITERATED
7339 | OPTI_TYPE_NOT_SALTED
7340 | OPTI_TYPE_RAW_HASH;
7341 dgst_pos0 = 3;
7342 dgst_pos1 = 4;
7343 dgst_pos2 = 2;
7344 dgst_pos3 = 1;
7345 break;
7346
7347 case 101: hash_type = HASH_TYPE_SHA1;
7348 salt_type = SALT_TYPE_NONE;
7349 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7350 opts_type = OPTS_TYPE_PT_GENERATE_BE
7351 | OPTS_TYPE_PT_ADD80
7352 | OPTS_TYPE_PT_ADDBITS15;
7353 kern_type = KERN_TYPE_SHA1;
7354 dgst_size = DGST_SIZE_4_5;
7355 parse_func = sha1b64_parse_hash;
7356 sort_by_digest = sort_by_digest_4_5;
7357 opti_type = OPTI_TYPE_ZERO_BYTE
7358 | OPTI_TYPE_PRECOMPUTE_INIT
7359 | OPTI_TYPE_PRECOMPUTE_MERKLE
7360 | OPTI_TYPE_EARLY_SKIP
7361 | OPTI_TYPE_NOT_ITERATED
7362 | OPTI_TYPE_NOT_SALTED
7363 | OPTI_TYPE_RAW_HASH;
7364 dgst_pos0 = 3;
7365 dgst_pos1 = 4;
7366 dgst_pos2 = 2;
7367 dgst_pos3 = 1;
7368 break;
7369
7370 case 110: hash_type = HASH_TYPE_SHA1;
7371 salt_type = SALT_TYPE_INTERN;
7372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7373 opts_type = OPTS_TYPE_PT_GENERATE_BE
7374 | OPTS_TYPE_ST_ADD80
7375 | OPTS_TYPE_ST_ADDBITS15;
7376 kern_type = KERN_TYPE_SHA1_PWSLT;
7377 dgst_size = DGST_SIZE_4_5;
7378 parse_func = sha1s_parse_hash;
7379 sort_by_digest = sort_by_digest_4_5;
7380 opti_type = OPTI_TYPE_ZERO_BYTE
7381 | OPTI_TYPE_PRECOMPUTE_INIT
7382 | OPTI_TYPE_PRECOMPUTE_MERKLE
7383 | OPTI_TYPE_EARLY_SKIP
7384 | OPTI_TYPE_NOT_ITERATED
7385 | OPTI_TYPE_APPENDED_SALT
7386 | OPTI_TYPE_RAW_HASH;
7387 dgst_pos0 = 3;
7388 dgst_pos1 = 4;
7389 dgst_pos2 = 2;
7390 dgst_pos3 = 1;
7391 break;
7392
7393 case 111: hash_type = HASH_TYPE_SHA1;
7394 salt_type = SALT_TYPE_EMBEDDED;
7395 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7396 opts_type = OPTS_TYPE_PT_GENERATE_BE
7397 | OPTS_TYPE_ST_ADD80
7398 | OPTS_TYPE_ST_ADDBITS15;
7399 kern_type = KERN_TYPE_SHA1_PWSLT;
7400 dgst_size = DGST_SIZE_4_5;
7401 parse_func = sha1b64s_parse_hash;
7402 sort_by_digest = sort_by_digest_4_5;
7403 opti_type = OPTI_TYPE_ZERO_BYTE
7404 | OPTI_TYPE_PRECOMPUTE_INIT
7405 | OPTI_TYPE_PRECOMPUTE_MERKLE
7406 | OPTI_TYPE_EARLY_SKIP
7407 | OPTI_TYPE_NOT_ITERATED
7408 | OPTI_TYPE_APPENDED_SALT
7409 | OPTI_TYPE_RAW_HASH;
7410 dgst_pos0 = 3;
7411 dgst_pos1 = 4;
7412 dgst_pos2 = 2;
7413 dgst_pos3 = 1;
7414 break;
7415
7416 case 112: hash_type = HASH_TYPE_SHA1;
7417 salt_type = SALT_TYPE_INTERN;
7418 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7419 opts_type = OPTS_TYPE_PT_GENERATE_BE
7420 | OPTS_TYPE_ST_ADD80
7421 | OPTS_TYPE_ST_ADDBITS15
7422 | OPTS_TYPE_ST_HEX;
7423 kern_type = KERN_TYPE_SHA1_PWSLT;
7424 dgst_size = DGST_SIZE_4_5;
7425 parse_func = oracles_parse_hash;
7426 sort_by_digest = sort_by_digest_4_5;
7427 opti_type = OPTI_TYPE_ZERO_BYTE
7428 | OPTI_TYPE_PRECOMPUTE_INIT
7429 | OPTI_TYPE_PRECOMPUTE_MERKLE
7430 | OPTI_TYPE_EARLY_SKIP
7431 | OPTI_TYPE_NOT_ITERATED
7432 | OPTI_TYPE_APPENDED_SALT
7433 | OPTI_TYPE_RAW_HASH;
7434 dgst_pos0 = 3;
7435 dgst_pos1 = 4;
7436 dgst_pos2 = 2;
7437 dgst_pos3 = 1;
7438 break;
7439
7440 case 120: hash_type = HASH_TYPE_SHA1;
7441 salt_type = SALT_TYPE_INTERN;
7442 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7443 opts_type = OPTS_TYPE_PT_GENERATE_BE
7444 | OPTS_TYPE_PT_ADD80
7445 | OPTS_TYPE_PT_ADDBITS15;
7446 kern_type = KERN_TYPE_SHA1_SLTPW;
7447 dgst_size = DGST_SIZE_4_5;
7448 parse_func = sha1s_parse_hash;
7449 sort_by_digest = sort_by_digest_4_5;
7450 opti_type = OPTI_TYPE_ZERO_BYTE
7451 | OPTI_TYPE_PRECOMPUTE_INIT
7452 | OPTI_TYPE_PRECOMPUTE_MERKLE
7453 | OPTI_TYPE_EARLY_SKIP
7454 | OPTI_TYPE_NOT_ITERATED
7455 | OPTI_TYPE_PREPENDED_SALT
7456 | OPTI_TYPE_RAW_HASH;
7457 dgst_pos0 = 3;
7458 dgst_pos1 = 4;
7459 dgst_pos2 = 2;
7460 dgst_pos3 = 1;
7461 break;
7462
7463 case 121: hash_type = HASH_TYPE_SHA1;
7464 salt_type = SALT_TYPE_INTERN;
7465 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7466 opts_type = OPTS_TYPE_PT_GENERATE_BE
7467 | OPTS_TYPE_PT_ADD80
7468 | OPTS_TYPE_PT_ADDBITS15
7469 | OPTS_TYPE_ST_LOWER;
7470 kern_type = KERN_TYPE_SHA1_SLTPW;
7471 dgst_size = DGST_SIZE_4_5;
7472 parse_func = smf_parse_hash;
7473 sort_by_digest = sort_by_digest_4_5;
7474 opti_type = OPTI_TYPE_ZERO_BYTE
7475 | OPTI_TYPE_PRECOMPUTE_INIT
7476 | OPTI_TYPE_PRECOMPUTE_MERKLE
7477 | OPTI_TYPE_EARLY_SKIP
7478 | OPTI_TYPE_NOT_ITERATED
7479 | OPTI_TYPE_PREPENDED_SALT
7480 | OPTI_TYPE_RAW_HASH;
7481 dgst_pos0 = 3;
7482 dgst_pos1 = 4;
7483 dgst_pos2 = 2;
7484 dgst_pos3 = 1;
7485 break;
7486
7487 case 122: hash_type = HASH_TYPE_SHA1;
7488 salt_type = SALT_TYPE_EMBEDDED;
7489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7490 opts_type = OPTS_TYPE_PT_GENERATE_BE
7491 | OPTS_TYPE_PT_ADD80
7492 | OPTS_TYPE_PT_ADDBITS15
7493 | OPTS_TYPE_ST_HEX;
7494 kern_type = KERN_TYPE_SHA1_SLTPW;
7495 dgst_size = DGST_SIZE_4_5;
7496 parse_func = osx1_parse_hash;
7497 sort_by_digest = sort_by_digest_4_5;
7498 opti_type = OPTI_TYPE_ZERO_BYTE
7499 | OPTI_TYPE_PRECOMPUTE_INIT
7500 | OPTI_TYPE_PRECOMPUTE_MERKLE
7501 | OPTI_TYPE_EARLY_SKIP
7502 | OPTI_TYPE_NOT_ITERATED
7503 | OPTI_TYPE_PREPENDED_SALT
7504 | OPTI_TYPE_RAW_HASH;
7505 dgst_pos0 = 3;
7506 dgst_pos1 = 4;
7507 dgst_pos2 = 2;
7508 dgst_pos3 = 1;
7509 break;
7510
7511 case 124: hash_type = HASH_TYPE_SHA1;
7512 salt_type = SALT_TYPE_EMBEDDED;
7513 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7514 opts_type = OPTS_TYPE_PT_GENERATE_BE
7515 | OPTS_TYPE_PT_ADD80
7516 | OPTS_TYPE_PT_ADDBITS15;
7517 kern_type = KERN_TYPE_SHA1_SLTPW;
7518 dgst_size = DGST_SIZE_4_5;
7519 parse_func = djangosha1_parse_hash;
7520 sort_by_digest = sort_by_digest_4_5;
7521 opti_type = OPTI_TYPE_ZERO_BYTE
7522 | OPTI_TYPE_PRECOMPUTE_INIT
7523 | OPTI_TYPE_PRECOMPUTE_MERKLE
7524 | OPTI_TYPE_EARLY_SKIP
7525 | OPTI_TYPE_NOT_ITERATED
7526 | OPTI_TYPE_PREPENDED_SALT
7527 | OPTI_TYPE_RAW_HASH;
7528 dgst_pos0 = 3;
7529 dgst_pos1 = 4;
7530 dgst_pos2 = 2;
7531 dgst_pos3 = 1;
7532 break;
7533
7534 case 125: hash_type = HASH_TYPE_SHA1;
7535 salt_type = SALT_TYPE_EMBEDDED;
7536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7537 opts_type = OPTS_TYPE_PT_GENERATE_BE
7538 | OPTS_TYPE_PT_ADD80
7539 | OPTS_TYPE_PT_ADDBITS15
7540 | OPTS_TYPE_ST_HEX;
7541 kern_type = KERN_TYPE_SHA1_SLTPW;
7542 dgst_size = DGST_SIZE_4_5;
7543 parse_func = arubaos_parse_hash;
7544 sort_by_digest = sort_by_digest_4_5;
7545 opti_type = OPTI_TYPE_ZERO_BYTE
7546 | OPTI_TYPE_PRECOMPUTE_INIT
7547 | OPTI_TYPE_PRECOMPUTE_MERKLE
7548 | OPTI_TYPE_EARLY_SKIP
7549 | OPTI_TYPE_NOT_ITERATED
7550 | OPTI_TYPE_PREPENDED_SALT
7551 | OPTI_TYPE_RAW_HASH;
7552 dgst_pos0 = 3;
7553 dgst_pos1 = 4;
7554 dgst_pos2 = 2;
7555 dgst_pos3 = 1;
7556 break;
7557
7558 case 130: hash_type = HASH_TYPE_SHA1;
7559 salt_type = SALT_TYPE_INTERN;
7560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7561 opts_type = OPTS_TYPE_PT_GENERATE_BE
7562 | OPTS_TYPE_PT_UNICODE
7563 | OPTS_TYPE_ST_ADD80
7564 | OPTS_TYPE_ST_ADDBITS15;
7565 kern_type = KERN_TYPE_SHA1_PWUSLT;
7566 dgst_size = DGST_SIZE_4_5;
7567 parse_func = sha1s_parse_hash;
7568 sort_by_digest = sort_by_digest_4_5;
7569 opti_type = OPTI_TYPE_ZERO_BYTE
7570 | OPTI_TYPE_PRECOMPUTE_INIT
7571 | OPTI_TYPE_PRECOMPUTE_MERKLE
7572 | OPTI_TYPE_EARLY_SKIP
7573 | OPTI_TYPE_NOT_ITERATED
7574 | OPTI_TYPE_APPENDED_SALT
7575 | OPTI_TYPE_RAW_HASH;
7576 dgst_pos0 = 3;
7577 dgst_pos1 = 4;
7578 dgst_pos2 = 2;
7579 dgst_pos3 = 1;
7580 break;
7581
7582 case 131: hash_type = HASH_TYPE_SHA1;
7583 salt_type = SALT_TYPE_EMBEDDED;
7584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7585 opts_type = OPTS_TYPE_PT_GENERATE_BE
7586 | OPTS_TYPE_PT_UNICODE
7587 | OPTS_TYPE_PT_UPPER
7588 | OPTS_TYPE_ST_ADD80
7589 | OPTS_TYPE_ST_ADDBITS15
7590 | OPTS_TYPE_ST_HEX;
7591 kern_type = KERN_TYPE_SHA1_PWUSLT;
7592 dgst_size = DGST_SIZE_4_5;
7593 parse_func = mssql2000_parse_hash;
7594 sort_by_digest = sort_by_digest_4_5;
7595 opti_type = OPTI_TYPE_ZERO_BYTE
7596 | OPTI_TYPE_PRECOMPUTE_INIT
7597 | OPTI_TYPE_PRECOMPUTE_MERKLE
7598 | OPTI_TYPE_EARLY_SKIP
7599 | OPTI_TYPE_NOT_ITERATED
7600 | OPTI_TYPE_APPENDED_SALT
7601 | OPTI_TYPE_RAW_HASH;
7602 dgst_pos0 = 3;
7603 dgst_pos1 = 4;
7604 dgst_pos2 = 2;
7605 dgst_pos3 = 1;
7606 break;
7607
7608 case 132: hash_type = HASH_TYPE_SHA1;
7609 salt_type = SALT_TYPE_EMBEDDED;
7610 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7611 opts_type = OPTS_TYPE_PT_GENERATE_BE
7612 | OPTS_TYPE_PT_UNICODE
7613 | OPTS_TYPE_ST_ADD80
7614 | OPTS_TYPE_ST_ADDBITS15
7615 | OPTS_TYPE_ST_HEX;
7616 kern_type = KERN_TYPE_SHA1_PWUSLT;
7617 dgst_size = DGST_SIZE_4_5;
7618 parse_func = mssql2005_parse_hash;
7619 sort_by_digest = sort_by_digest_4_5;
7620 opti_type = OPTI_TYPE_ZERO_BYTE
7621 | OPTI_TYPE_PRECOMPUTE_INIT
7622 | OPTI_TYPE_PRECOMPUTE_MERKLE
7623 | OPTI_TYPE_EARLY_SKIP
7624 | OPTI_TYPE_NOT_ITERATED
7625 | OPTI_TYPE_APPENDED_SALT
7626 | OPTI_TYPE_RAW_HASH;
7627 dgst_pos0 = 3;
7628 dgst_pos1 = 4;
7629 dgst_pos2 = 2;
7630 dgst_pos3 = 1;
7631 break;
7632
7633 case 133: hash_type = HASH_TYPE_SHA1;
7634 salt_type = SALT_TYPE_EMBEDDED;
7635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7636 opts_type = OPTS_TYPE_PT_GENERATE_BE
7637 | OPTS_TYPE_PT_UNICODE
7638 | OPTS_TYPE_ST_ADD80
7639 | OPTS_TYPE_ST_ADDBITS15;
7640 kern_type = KERN_TYPE_SHA1_PWUSLT;
7641 dgst_size = DGST_SIZE_4_5;
7642 parse_func = peoplesoft_parse_hash;
7643 sort_by_digest = sort_by_digest_4_5;
7644 opti_type = OPTI_TYPE_ZERO_BYTE
7645 | OPTI_TYPE_PRECOMPUTE_INIT
7646 | OPTI_TYPE_PRECOMPUTE_MERKLE
7647 | OPTI_TYPE_EARLY_SKIP
7648 | OPTI_TYPE_NOT_ITERATED
7649 | OPTI_TYPE_APPENDED_SALT
7650 | OPTI_TYPE_RAW_HASH;
7651 dgst_pos0 = 3;
7652 dgst_pos1 = 4;
7653 dgst_pos2 = 2;
7654 dgst_pos3 = 1;
7655 break;
7656
7657 case 140: hash_type = HASH_TYPE_SHA1;
7658 salt_type = SALT_TYPE_INTERN;
7659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7660 opts_type = OPTS_TYPE_PT_GENERATE_BE
7661 | OPTS_TYPE_PT_ADD80
7662 | OPTS_TYPE_PT_ADDBITS15
7663 | OPTS_TYPE_PT_UNICODE;
7664 kern_type = KERN_TYPE_SHA1_SLTPWU;
7665 dgst_size = DGST_SIZE_4_5;
7666 parse_func = sha1s_parse_hash;
7667 sort_by_digest = sort_by_digest_4_5;
7668 opti_type = OPTI_TYPE_ZERO_BYTE
7669 | OPTI_TYPE_PRECOMPUTE_INIT
7670 | OPTI_TYPE_PRECOMPUTE_MERKLE
7671 | OPTI_TYPE_EARLY_SKIP
7672 | OPTI_TYPE_NOT_ITERATED
7673 | OPTI_TYPE_PREPENDED_SALT
7674 | OPTI_TYPE_RAW_HASH;
7675 dgst_pos0 = 3;
7676 dgst_pos1 = 4;
7677 dgst_pos2 = 2;
7678 dgst_pos3 = 1;
7679 break;
7680
7681 case 141: hash_type = HASH_TYPE_SHA1;
7682 salt_type = SALT_TYPE_EMBEDDED;
7683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7684 opts_type = OPTS_TYPE_PT_GENERATE_BE
7685 | OPTS_TYPE_PT_ADD80
7686 | OPTS_TYPE_PT_ADDBITS15
7687 | OPTS_TYPE_PT_UNICODE
7688 | OPTS_TYPE_ST_BASE64;
7689 kern_type = KERN_TYPE_SHA1_SLTPWU;
7690 dgst_size = DGST_SIZE_4_5;
7691 parse_func = episerver_parse_hash;
7692 sort_by_digest = sort_by_digest_4_5;
7693 opti_type = OPTI_TYPE_ZERO_BYTE
7694 | OPTI_TYPE_PRECOMPUTE_INIT
7695 | OPTI_TYPE_PRECOMPUTE_MERKLE
7696 | OPTI_TYPE_EARLY_SKIP
7697 | OPTI_TYPE_NOT_ITERATED
7698 | OPTI_TYPE_PREPENDED_SALT
7699 | OPTI_TYPE_RAW_HASH;
7700 dgst_pos0 = 3;
7701 dgst_pos1 = 4;
7702 dgst_pos2 = 2;
7703 dgst_pos3 = 1;
7704 break;
7705
7706 case 150: hash_type = HASH_TYPE_SHA1;
7707 salt_type = SALT_TYPE_INTERN;
7708 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7709 opts_type = OPTS_TYPE_PT_GENERATE_BE
7710 | OPTS_TYPE_ST_ADD80
7711 | OPTS_TYPE_ST_ADDBITS15;
7712 kern_type = KERN_TYPE_HMACSHA1_PW;
7713 dgst_size = DGST_SIZE_4_5;
7714 parse_func = hmacsha1_parse_hash;
7715 sort_by_digest = sort_by_digest_4_5;
7716 opti_type = OPTI_TYPE_ZERO_BYTE
7717 | OPTI_TYPE_NOT_ITERATED;
7718 dgst_pos0 = 3;
7719 dgst_pos1 = 4;
7720 dgst_pos2 = 2;
7721 dgst_pos3 = 1;
7722 break;
7723
7724 case 160: hash_type = HASH_TYPE_SHA1;
7725 salt_type = SALT_TYPE_INTERN;
7726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7727 opts_type = OPTS_TYPE_PT_GENERATE_BE
7728 | OPTS_TYPE_PT_ADD80
7729 | OPTS_TYPE_PT_ADDBITS15;
7730 kern_type = KERN_TYPE_HMACSHA1_SLT;
7731 dgst_size = DGST_SIZE_4_5;
7732 parse_func = hmacsha1_parse_hash;
7733 sort_by_digest = sort_by_digest_4_5;
7734 opti_type = OPTI_TYPE_ZERO_BYTE
7735 | OPTI_TYPE_NOT_ITERATED;
7736 dgst_pos0 = 3;
7737 dgst_pos1 = 4;
7738 dgst_pos2 = 2;
7739 dgst_pos3 = 1;
7740 break;
7741
7742 case 190: hash_type = HASH_TYPE_SHA1;
7743 salt_type = SALT_TYPE_NONE;
7744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7745 opts_type = OPTS_TYPE_PT_GENERATE_BE
7746 | OPTS_TYPE_PT_ADD80
7747 | OPTS_TYPE_PT_ADDBITS15;
7748 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7749 dgst_size = DGST_SIZE_4_5;
7750 parse_func = sha1linkedin_parse_hash;
7751 sort_by_digest = sort_by_digest_4_5;
7752 opti_type = OPTI_TYPE_ZERO_BYTE
7753 | OPTI_TYPE_PRECOMPUTE_INIT
7754 | OPTI_TYPE_EARLY_SKIP
7755 | OPTI_TYPE_NOT_ITERATED
7756 | OPTI_TYPE_NOT_SALTED;
7757 dgst_pos0 = 0;
7758 dgst_pos1 = 4;
7759 dgst_pos2 = 3;
7760 dgst_pos3 = 2;
7761 break;
7762
7763 case 200: hash_type = HASH_TYPE_MYSQL;
7764 salt_type = SALT_TYPE_NONE;
7765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7766 opts_type = 0;
7767 kern_type = KERN_TYPE_MYSQL;
7768 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7769 parse_func = mysql323_parse_hash;
7770 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7771 opti_type = OPTI_TYPE_ZERO_BYTE;
7772 dgst_pos0 = 0;
7773 dgst_pos1 = 1;
7774 dgst_pos2 = 2;
7775 dgst_pos3 = 3;
7776 break;
7777
7778 case 300: hash_type = HASH_TYPE_SHA1;
7779 salt_type = SALT_TYPE_NONE;
7780 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7781 opts_type = OPTS_TYPE_PT_GENERATE_BE
7782 | OPTS_TYPE_PT_ADD80
7783 | OPTS_TYPE_PT_ADDBITS15;
7784 kern_type = KERN_TYPE_MYSQL41;
7785 dgst_size = DGST_SIZE_4_5;
7786 parse_func = sha1_parse_hash;
7787 sort_by_digest = sort_by_digest_4_5;
7788 opti_type = OPTI_TYPE_ZERO_BYTE
7789 | OPTI_TYPE_PRECOMPUTE_INIT
7790 | OPTI_TYPE_PRECOMPUTE_MERKLE
7791 | OPTI_TYPE_EARLY_SKIP
7792 | OPTI_TYPE_NOT_ITERATED
7793 | OPTI_TYPE_NOT_SALTED;
7794 dgst_pos0 = 3;
7795 dgst_pos1 = 4;
7796 dgst_pos2 = 2;
7797 dgst_pos3 = 1;
7798 break;
7799
7800 case 400: 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_PHPASS;
7805 dgst_size = DGST_SIZE_4_4;
7806 parse_func = phpass_parse_hash;
7807 sort_by_digest = sort_by_digest_4_4;
7808 opti_type = OPTI_TYPE_ZERO_BYTE
7809 | OPTI_TYPE_SLOW_HASH_SIMD;
7810 dgst_pos0 = 0;
7811 dgst_pos1 = 1;
7812 dgst_pos2 = 2;
7813 dgst_pos3 = 3;
7814 break;
7815
7816 case 500: hash_type = HASH_TYPE_MD5;
7817 salt_type = SALT_TYPE_EMBEDDED;
7818 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7819 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7820 kern_type = KERN_TYPE_MD5CRYPT;
7821 dgst_size = DGST_SIZE_4_4;
7822 parse_func = md5crypt_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 501: hash_type = HASH_TYPE_MD5;
7832 salt_type = SALT_TYPE_EMBEDDED;
7833 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7834 opts_type = OPTS_TYPE_PT_GENERATE_LE
7835 | OPTS_TYPE_HASH_COPY;
7836 kern_type = KERN_TYPE_MD5CRYPT;
7837 dgst_size = DGST_SIZE_4_4;
7838 parse_func = juniper_parse_hash;
7839 sort_by_digest = sort_by_digest_4_4;
7840 opti_type = OPTI_TYPE_ZERO_BYTE;
7841 dgst_pos0 = 0;
7842 dgst_pos1 = 1;
7843 dgst_pos2 = 2;
7844 dgst_pos3 = 3;
7845 break;
7846
7847 case 900: hash_type = HASH_TYPE_MD4;
7848 salt_type = SALT_TYPE_NONE;
7849 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7850 opts_type = OPTS_TYPE_PT_GENERATE_LE
7851 | OPTS_TYPE_PT_ADD80
7852 | OPTS_TYPE_PT_ADDBITS14;
7853 kern_type = KERN_TYPE_MD4;
7854 dgst_size = DGST_SIZE_4_4;
7855 parse_func = md4_parse_hash;
7856 sort_by_digest = sort_by_digest_4_4;
7857 opti_type = OPTI_TYPE_ZERO_BYTE
7858 | OPTI_TYPE_PRECOMPUTE_INIT
7859 | OPTI_TYPE_PRECOMPUTE_MERKLE
7860 | OPTI_TYPE_MEET_IN_MIDDLE
7861 | OPTI_TYPE_EARLY_SKIP
7862 | OPTI_TYPE_NOT_ITERATED
7863 | OPTI_TYPE_NOT_SALTED
7864 | OPTI_TYPE_RAW_HASH;
7865 dgst_pos0 = 0;
7866 dgst_pos1 = 3;
7867 dgst_pos2 = 2;
7868 dgst_pos3 = 1;
7869 break;
7870
7871 case 1000: hash_type = HASH_TYPE_MD4;
7872 salt_type = SALT_TYPE_NONE;
7873 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7874 opts_type = OPTS_TYPE_PT_GENERATE_LE
7875 | OPTS_TYPE_PT_ADD80
7876 | OPTS_TYPE_PT_ADDBITS14
7877 | OPTS_TYPE_PT_UNICODE;
7878 kern_type = KERN_TYPE_MD4_PWU;
7879 dgst_size = DGST_SIZE_4_4;
7880 parse_func = md4_parse_hash;
7881 sort_by_digest = sort_by_digest_4_4;
7882 opti_type = OPTI_TYPE_ZERO_BYTE
7883 | OPTI_TYPE_PRECOMPUTE_INIT
7884 | OPTI_TYPE_PRECOMPUTE_MERKLE
7885 | OPTI_TYPE_MEET_IN_MIDDLE
7886 | OPTI_TYPE_EARLY_SKIP
7887 | OPTI_TYPE_NOT_ITERATED
7888 | OPTI_TYPE_NOT_SALTED
7889 | OPTI_TYPE_RAW_HASH;
7890 dgst_pos0 = 0;
7891 dgst_pos1 = 3;
7892 dgst_pos2 = 2;
7893 dgst_pos3 = 1;
7894 break;
7895
7896 case 1100: hash_type = HASH_TYPE_MD4;
7897 salt_type = SALT_TYPE_INTERN;
7898 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7899 opts_type = OPTS_TYPE_PT_GENERATE_LE
7900 | OPTS_TYPE_PT_ADD80
7901 | OPTS_TYPE_PT_ADDBITS14
7902 | OPTS_TYPE_PT_UNICODE
7903 | OPTS_TYPE_ST_ADD80
7904 | OPTS_TYPE_ST_UNICODE
7905 | OPTS_TYPE_ST_LOWER;
7906 kern_type = KERN_TYPE_MD44_PWUSLT;
7907 dgst_size = DGST_SIZE_4_4;
7908 parse_func = dcc_parse_hash;
7909 sort_by_digest = sort_by_digest_4_4;
7910 opti_type = OPTI_TYPE_ZERO_BYTE
7911 | OPTI_TYPE_PRECOMPUTE_INIT
7912 | OPTI_TYPE_PRECOMPUTE_MERKLE
7913 | OPTI_TYPE_EARLY_SKIP
7914 | OPTI_TYPE_NOT_ITERATED;
7915 dgst_pos0 = 0;
7916 dgst_pos1 = 3;
7917 dgst_pos2 = 2;
7918 dgst_pos3 = 1;
7919 break;
7920
7921 case 1400: hash_type = HASH_TYPE_SHA256;
7922 salt_type = SALT_TYPE_NONE;
7923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7924 opts_type = OPTS_TYPE_PT_GENERATE_BE
7925 | OPTS_TYPE_PT_ADD80
7926 | OPTS_TYPE_PT_ADDBITS15;
7927 kern_type = KERN_TYPE_SHA256;
7928 dgst_size = DGST_SIZE_4_8;
7929 parse_func = sha256_parse_hash;
7930 sort_by_digest = sort_by_digest_4_8;
7931 opti_type = OPTI_TYPE_ZERO_BYTE
7932 | OPTI_TYPE_PRECOMPUTE_INIT
7933 | OPTI_TYPE_PRECOMPUTE_MERKLE
7934 | OPTI_TYPE_EARLY_SKIP
7935 | OPTI_TYPE_NOT_ITERATED
7936 | OPTI_TYPE_NOT_SALTED
7937 | OPTI_TYPE_RAW_HASH;
7938 dgst_pos0 = 3;
7939 dgst_pos1 = 7;
7940 dgst_pos2 = 2;
7941 dgst_pos3 = 6;
7942 break;
7943
7944 case 1410: hash_type = HASH_TYPE_SHA256;
7945 salt_type = SALT_TYPE_INTERN;
7946 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7947 opts_type = OPTS_TYPE_PT_GENERATE_BE
7948 | OPTS_TYPE_ST_ADD80
7949 | OPTS_TYPE_ST_ADDBITS15;
7950 kern_type = KERN_TYPE_SHA256_PWSLT;
7951 dgst_size = DGST_SIZE_4_8;
7952 parse_func = sha256s_parse_hash;
7953 sort_by_digest = sort_by_digest_4_8;
7954 opti_type = OPTI_TYPE_ZERO_BYTE
7955 | OPTI_TYPE_PRECOMPUTE_INIT
7956 | OPTI_TYPE_PRECOMPUTE_MERKLE
7957 | OPTI_TYPE_EARLY_SKIP
7958 | OPTI_TYPE_NOT_ITERATED
7959 | OPTI_TYPE_APPENDED_SALT
7960 | OPTI_TYPE_RAW_HASH;
7961 dgst_pos0 = 3;
7962 dgst_pos1 = 7;
7963 dgst_pos2 = 2;
7964 dgst_pos3 = 6;
7965 break;
7966
7967 case 1420: hash_type = HASH_TYPE_SHA256;
7968 salt_type = SALT_TYPE_INTERN;
7969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7970 opts_type = OPTS_TYPE_PT_GENERATE_BE
7971 | OPTS_TYPE_PT_ADD80
7972 | OPTS_TYPE_PT_ADDBITS15;
7973 kern_type = KERN_TYPE_SHA256_SLTPW;
7974 dgst_size = DGST_SIZE_4_8;
7975 parse_func = sha256s_parse_hash;
7976 sort_by_digest = sort_by_digest_4_8;
7977 opti_type = OPTI_TYPE_ZERO_BYTE
7978 | OPTI_TYPE_PRECOMPUTE_INIT
7979 | OPTI_TYPE_PRECOMPUTE_MERKLE
7980 | OPTI_TYPE_EARLY_SKIP
7981 | OPTI_TYPE_NOT_ITERATED
7982 | OPTI_TYPE_PREPENDED_SALT
7983 | OPTI_TYPE_RAW_HASH;
7984 dgst_pos0 = 3;
7985 dgst_pos1 = 7;
7986 dgst_pos2 = 2;
7987 dgst_pos3 = 6;
7988 break;
7989
7990 case 1421: hash_type = HASH_TYPE_SHA256;
7991 salt_type = SALT_TYPE_EMBEDDED;
7992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7993 opts_type = OPTS_TYPE_PT_GENERATE_BE
7994 | OPTS_TYPE_PT_ADD80
7995 | OPTS_TYPE_PT_ADDBITS15;
7996 kern_type = KERN_TYPE_SHA256_SLTPW;
7997 dgst_size = DGST_SIZE_4_8;
7998 parse_func = hmailserver_parse_hash;
7999 sort_by_digest = sort_by_digest_4_8;
8000 opti_type = OPTI_TYPE_ZERO_BYTE
8001 | OPTI_TYPE_PRECOMPUTE_INIT
8002 | OPTI_TYPE_PRECOMPUTE_MERKLE
8003 | OPTI_TYPE_EARLY_SKIP
8004 | OPTI_TYPE_NOT_ITERATED
8005 | OPTI_TYPE_PREPENDED_SALT
8006 | OPTI_TYPE_RAW_HASH;
8007 dgst_pos0 = 3;
8008 dgst_pos1 = 7;
8009 dgst_pos2 = 2;
8010 dgst_pos3 = 6;
8011 break;
8012
8013 case 1430: hash_type = HASH_TYPE_SHA256;
8014 salt_type = SALT_TYPE_INTERN;
8015 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8016 opts_type = OPTS_TYPE_PT_GENERATE_BE
8017 | OPTS_TYPE_PT_UNICODE
8018 | OPTS_TYPE_ST_ADD80
8019 | OPTS_TYPE_ST_ADDBITS15;
8020 kern_type = KERN_TYPE_SHA256_PWUSLT;
8021 dgst_size = DGST_SIZE_4_8;
8022 parse_func = sha256s_parse_hash;
8023 sort_by_digest = sort_by_digest_4_8;
8024 opti_type = OPTI_TYPE_ZERO_BYTE
8025 | OPTI_TYPE_PRECOMPUTE_INIT
8026 | OPTI_TYPE_PRECOMPUTE_MERKLE
8027 | OPTI_TYPE_EARLY_SKIP
8028 | OPTI_TYPE_NOT_ITERATED
8029 | OPTI_TYPE_APPENDED_SALT
8030 | OPTI_TYPE_RAW_HASH;
8031 dgst_pos0 = 3;
8032 dgst_pos1 = 7;
8033 dgst_pos2 = 2;
8034 dgst_pos3 = 6;
8035 break;
8036
8037 case 1440: hash_type = HASH_TYPE_SHA256;
8038 salt_type = SALT_TYPE_INTERN;
8039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8040 opts_type = OPTS_TYPE_PT_GENERATE_BE
8041 | OPTS_TYPE_PT_ADD80
8042 | OPTS_TYPE_PT_ADDBITS15
8043 | OPTS_TYPE_PT_UNICODE;
8044 kern_type = KERN_TYPE_SHA256_SLTPWU;
8045 dgst_size = DGST_SIZE_4_8;
8046 parse_func = sha256s_parse_hash;
8047 sort_by_digest = sort_by_digest_4_8;
8048 opti_type = OPTI_TYPE_ZERO_BYTE
8049 | OPTI_TYPE_PRECOMPUTE_INIT
8050 | OPTI_TYPE_PRECOMPUTE_MERKLE
8051 | OPTI_TYPE_EARLY_SKIP
8052 | OPTI_TYPE_NOT_ITERATED
8053 | OPTI_TYPE_PREPENDED_SALT
8054 | OPTI_TYPE_RAW_HASH;
8055 dgst_pos0 = 3;
8056 dgst_pos1 = 7;
8057 dgst_pos2 = 2;
8058 dgst_pos3 = 6;
8059 break;
8060
8061 case 1441: hash_type = HASH_TYPE_SHA256;
8062 salt_type = SALT_TYPE_EMBEDDED;
8063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8064 opts_type = OPTS_TYPE_PT_GENERATE_BE
8065 | OPTS_TYPE_PT_ADD80
8066 | OPTS_TYPE_PT_ADDBITS15
8067 | OPTS_TYPE_PT_UNICODE
8068 | OPTS_TYPE_ST_BASE64;
8069 kern_type = KERN_TYPE_SHA256_SLTPWU;
8070 dgst_size = DGST_SIZE_4_8;
8071 parse_func = episerver4_parse_hash;
8072 sort_by_digest = sort_by_digest_4_8;
8073 opti_type = OPTI_TYPE_ZERO_BYTE
8074 | OPTI_TYPE_PRECOMPUTE_INIT
8075 | OPTI_TYPE_PRECOMPUTE_MERKLE
8076 | OPTI_TYPE_EARLY_SKIP
8077 | OPTI_TYPE_NOT_ITERATED
8078 | OPTI_TYPE_PREPENDED_SALT
8079 | OPTI_TYPE_RAW_HASH;
8080 dgst_pos0 = 3;
8081 dgst_pos1 = 7;
8082 dgst_pos2 = 2;
8083 dgst_pos3 = 6;
8084 break;
8085
8086 case 1450: hash_type = HASH_TYPE_SHA256;
8087 salt_type = SALT_TYPE_INTERN;
8088 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8089 opts_type = OPTS_TYPE_PT_GENERATE_BE
8090 | OPTS_TYPE_ST_ADD80;
8091 kern_type = KERN_TYPE_HMACSHA256_PW;
8092 dgst_size = DGST_SIZE_4_8;
8093 parse_func = hmacsha256_parse_hash;
8094 sort_by_digest = sort_by_digest_4_8;
8095 opti_type = OPTI_TYPE_ZERO_BYTE
8096 | OPTI_TYPE_NOT_ITERATED;
8097 dgst_pos0 = 3;
8098 dgst_pos1 = 7;
8099 dgst_pos2 = 2;
8100 dgst_pos3 = 6;
8101 break;
8102
8103 case 1460: hash_type = HASH_TYPE_SHA256;
8104 salt_type = SALT_TYPE_INTERN;
8105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8106 opts_type = OPTS_TYPE_PT_GENERATE_BE
8107 | OPTS_TYPE_PT_ADD80
8108 | OPTS_TYPE_PT_ADDBITS15;
8109 kern_type = KERN_TYPE_HMACSHA256_SLT;
8110 dgst_size = DGST_SIZE_4_8;
8111 parse_func = hmacsha256_parse_hash;
8112 sort_by_digest = sort_by_digest_4_8;
8113 opti_type = OPTI_TYPE_ZERO_BYTE
8114 | OPTI_TYPE_NOT_ITERATED;
8115 dgst_pos0 = 3;
8116 dgst_pos1 = 7;
8117 dgst_pos2 = 2;
8118 dgst_pos3 = 6;
8119 break;
8120
8121 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8122 salt_type = SALT_TYPE_EMBEDDED;
8123 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8124 opts_type = OPTS_TYPE_PT_GENERATE_LE
8125 | OPTS_TYPE_PT_BITSLICE;
8126 kern_type = KERN_TYPE_DESCRYPT;
8127 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8128 parse_func = descrypt_parse_hash;
8129 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8130 opti_type = OPTI_TYPE_ZERO_BYTE
8131 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8132 dgst_pos0 = 0;
8133 dgst_pos1 = 1;
8134 dgst_pos2 = 2;
8135 dgst_pos3 = 3;
8136 break;
8137
8138 case 1600: hash_type = HASH_TYPE_MD5;
8139 salt_type = SALT_TYPE_EMBEDDED;
8140 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8141 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8142 kern_type = KERN_TYPE_APR1CRYPT;
8143 dgst_size = DGST_SIZE_4_4;
8144 parse_func = md5apr1_parse_hash;
8145 sort_by_digest = sort_by_digest_4_4;
8146 opti_type = OPTI_TYPE_ZERO_BYTE;
8147 dgst_pos0 = 0;
8148 dgst_pos1 = 1;
8149 dgst_pos2 = 2;
8150 dgst_pos3 = 3;
8151 break;
8152
8153 case 1700: hash_type = HASH_TYPE_SHA512;
8154 salt_type = SALT_TYPE_NONE;
8155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8156 opts_type = OPTS_TYPE_PT_GENERATE_BE
8157 | OPTS_TYPE_PT_ADD80
8158 | OPTS_TYPE_PT_ADDBITS15;
8159 kern_type = KERN_TYPE_SHA512;
8160 dgst_size = DGST_SIZE_8_8;
8161 parse_func = sha512_parse_hash;
8162 sort_by_digest = sort_by_digest_8_8;
8163 opti_type = OPTI_TYPE_ZERO_BYTE
8164 | OPTI_TYPE_PRECOMPUTE_INIT
8165 | OPTI_TYPE_PRECOMPUTE_MERKLE
8166 | OPTI_TYPE_EARLY_SKIP
8167 | OPTI_TYPE_NOT_ITERATED
8168 | OPTI_TYPE_NOT_SALTED
8169 | OPTI_TYPE_USES_BITS_64
8170 | OPTI_TYPE_RAW_HASH;
8171 dgst_pos0 = 14;
8172 dgst_pos1 = 15;
8173 dgst_pos2 = 6;
8174 dgst_pos3 = 7;
8175 break;
8176
8177 case 1710: hash_type = HASH_TYPE_SHA512;
8178 salt_type = SALT_TYPE_INTERN;
8179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8180 opts_type = OPTS_TYPE_PT_GENERATE_BE
8181 | OPTS_TYPE_ST_ADD80
8182 | OPTS_TYPE_ST_ADDBITS15;
8183 kern_type = KERN_TYPE_SHA512_PWSLT;
8184 dgst_size = DGST_SIZE_8_8;
8185 parse_func = sha512s_parse_hash;
8186 sort_by_digest = sort_by_digest_8_8;
8187 opti_type = OPTI_TYPE_ZERO_BYTE
8188 | OPTI_TYPE_PRECOMPUTE_INIT
8189 | OPTI_TYPE_PRECOMPUTE_MERKLE
8190 | OPTI_TYPE_EARLY_SKIP
8191 | OPTI_TYPE_NOT_ITERATED
8192 | OPTI_TYPE_APPENDED_SALT
8193 | OPTI_TYPE_USES_BITS_64
8194 | OPTI_TYPE_RAW_HASH;
8195 dgst_pos0 = 14;
8196 dgst_pos1 = 15;
8197 dgst_pos2 = 6;
8198 dgst_pos3 = 7;
8199 break;
8200
8201 case 1711: hash_type = HASH_TYPE_SHA512;
8202 salt_type = SALT_TYPE_EMBEDDED;
8203 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8204 opts_type = OPTS_TYPE_PT_GENERATE_BE
8205 | OPTS_TYPE_ST_ADD80
8206 | OPTS_TYPE_ST_ADDBITS15;
8207 kern_type = KERN_TYPE_SHA512_PWSLT;
8208 dgst_size = DGST_SIZE_8_8;
8209 parse_func = sha512b64s_parse_hash;
8210 sort_by_digest = sort_by_digest_8_8;
8211 opti_type = OPTI_TYPE_ZERO_BYTE
8212 | OPTI_TYPE_PRECOMPUTE_INIT
8213 | OPTI_TYPE_PRECOMPUTE_MERKLE
8214 | OPTI_TYPE_EARLY_SKIP
8215 | OPTI_TYPE_NOT_ITERATED
8216 | OPTI_TYPE_APPENDED_SALT
8217 | OPTI_TYPE_USES_BITS_64
8218 | OPTI_TYPE_RAW_HASH;
8219 dgst_pos0 = 14;
8220 dgst_pos1 = 15;
8221 dgst_pos2 = 6;
8222 dgst_pos3 = 7;
8223 break;
8224
8225 case 1720: hash_type = HASH_TYPE_SHA512;
8226 salt_type = SALT_TYPE_INTERN;
8227 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8228 opts_type = OPTS_TYPE_PT_GENERATE_BE
8229 | OPTS_TYPE_PT_ADD80
8230 | OPTS_TYPE_PT_ADDBITS15;
8231 kern_type = KERN_TYPE_SHA512_SLTPW;
8232 dgst_size = DGST_SIZE_8_8;
8233 parse_func = sha512s_parse_hash;
8234 sort_by_digest = sort_by_digest_8_8;
8235 opti_type = OPTI_TYPE_ZERO_BYTE
8236 | OPTI_TYPE_PRECOMPUTE_INIT
8237 | OPTI_TYPE_PRECOMPUTE_MERKLE
8238 | OPTI_TYPE_EARLY_SKIP
8239 | OPTI_TYPE_NOT_ITERATED
8240 | OPTI_TYPE_PREPENDED_SALT
8241 | OPTI_TYPE_USES_BITS_64
8242 | OPTI_TYPE_RAW_HASH;
8243 dgst_pos0 = 14;
8244 dgst_pos1 = 15;
8245 dgst_pos2 = 6;
8246 dgst_pos3 = 7;
8247 break;
8248
8249 case 1722: hash_type = HASH_TYPE_SHA512;
8250 salt_type = SALT_TYPE_EMBEDDED;
8251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8252 opts_type = OPTS_TYPE_PT_GENERATE_BE
8253 | OPTS_TYPE_PT_ADD80
8254 | OPTS_TYPE_PT_ADDBITS15
8255 | OPTS_TYPE_ST_HEX;
8256 kern_type = KERN_TYPE_SHA512_SLTPW;
8257 dgst_size = DGST_SIZE_8_8;
8258 parse_func = osx512_parse_hash;
8259 sort_by_digest = sort_by_digest_8_8;
8260 opti_type = OPTI_TYPE_ZERO_BYTE
8261 | OPTI_TYPE_PRECOMPUTE_INIT
8262 | OPTI_TYPE_PRECOMPUTE_MERKLE
8263 | OPTI_TYPE_EARLY_SKIP
8264 | OPTI_TYPE_NOT_ITERATED
8265 | OPTI_TYPE_PREPENDED_SALT
8266 | OPTI_TYPE_USES_BITS_64
8267 | OPTI_TYPE_RAW_HASH;
8268 dgst_pos0 = 14;
8269 dgst_pos1 = 15;
8270 dgst_pos2 = 6;
8271 dgst_pos3 = 7;
8272 break;
8273
8274 case 1730: hash_type = HASH_TYPE_SHA512;
8275 salt_type = SALT_TYPE_INTERN;
8276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8277 opts_type = OPTS_TYPE_PT_GENERATE_BE
8278 | OPTS_TYPE_PT_UNICODE
8279 | OPTS_TYPE_ST_ADD80
8280 | OPTS_TYPE_ST_ADDBITS15;
8281 kern_type = KERN_TYPE_SHA512_PWSLTU;
8282 dgst_size = DGST_SIZE_8_8;
8283 parse_func = sha512s_parse_hash;
8284 sort_by_digest = sort_by_digest_8_8;
8285 opti_type = OPTI_TYPE_ZERO_BYTE
8286 | OPTI_TYPE_PRECOMPUTE_INIT
8287 | OPTI_TYPE_PRECOMPUTE_MERKLE
8288 | OPTI_TYPE_EARLY_SKIP
8289 | OPTI_TYPE_NOT_ITERATED
8290 | OPTI_TYPE_APPENDED_SALT
8291 | OPTI_TYPE_USES_BITS_64
8292 | OPTI_TYPE_RAW_HASH;
8293 dgst_pos0 = 14;
8294 dgst_pos1 = 15;
8295 dgst_pos2 = 6;
8296 dgst_pos3 = 7;
8297 break;
8298
8299 case 1731: hash_type = HASH_TYPE_SHA512;
8300 salt_type = SALT_TYPE_EMBEDDED;
8301 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8302 opts_type = OPTS_TYPE_PT_GENERATE_BE
8303 | OPTS_TYPE_PT_UNICODE
8304 | OPTS_TYPE_ST_ADD80
8305 | OPTS_TYPE_ST_ADDBITS15
8306 | OPTS_TYPE_ST_HEX;
8307 kern_type = KERN_TYPE_SHA512_PWSLTU;
8308 dgst_size = DGST_SIZE_8_8;
8309 parse_func = mssql2012_parse_hash;
8310 sort_by_digest = sort_by_digest_8_8;
8311 opti_type = OPTI_TYPE_ZERO_BYTE
8312 | OPTI_TYPE_PRECOMPUTE_INIT
8313 | OPTI_TYPE_PRECOMPUTE_MERKLE
8314 | OPTI_TYPE_EARLY_SKIP
8315 | OPTI_TYPE_NOT_ITERATED
8316 | OPTI_TYPE_APPENDED_SALT
8317 | OPTI_TYPE_USES_BITS_64
8318 | OPTI_TYPE_RAW_HASH;
8319 dgst_pos0 = 14;
8320 dgst_pos1 = 15;
8321 dgst_pos2 = 6;
8322 dgst_pos3 = 7;
8323 break;
8324
8325 case 1740: hash_type = HASH_TYPE_SHA512;
8326 salt_type = SALT_TYPE_INTERN;
8327 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8328 opts_type = OPTS_TYPE_PT_GENERATE_BE
8329 | OPTS_TYPE_PT_ADD80
8330 | OPTS_TYPE_PT_ADDBITS15
8331 | OPTS_TYPE_PT_UNICODE;
8332 kern_type = KERN_TYPE_SHA512_SLTPWU;
8333 dgst_size = DGST_SIZE_8_8;
8334 parse_func = sha512s_parse_hash;
8335 sort_by_digest = sort_by_digest_8_8;
8336 opti_type = OPTI_TYPE_ZERO_BYTE
8337 | OPTI_TYPE_PRECOMPUTE_INIT
8338 | OPTI_TYPE_PRECOMPUTE_MERKLE
8339 | OPTI_TYPE_EARLY_SKIP
8340 | OPTI_TYPE_NOT_ITERATED
8341 | OPTI_TYPE_PREPENDED_SALT
8342 | OPTI_TYPE_USES_BITS_64
8343 | OPTI_TYPE_RAW_HASH;
8344 dgst_pos0 = 14;
8345 dgst_pos1 = 15;
8346 dgst_pos2 = 6;
8347 dgst_pos3 = 7;
8348 break;
8349
8350 case 1750: hash_type = HASH_TYPE_SHA512;
8351 salt_type = SALT_TYPE_INTERN;
8352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8353 opts_type = OPTS_TYPE_PT_GENERATE_BE
8354 | OPTS_TYPE_ST_ADD80;
8355 kern_type = KERN_TYPE_HMACSHA512_PW;
8356 dgst_size = DGST_SIZE_8_8;
8357 parse_func = hmacsha512_parse_hash;
8358 sort_by_digest = sort_by_digest_8_8;
8359 opti_type = OPTI_TYPE_ZERO_BYTE
8360 | OPTI_TYPE_USES_BITS_64
8361 | OPTI_TYPE_NOT_ITERATED;
8362 dgst_pos0 = 14;
8363 dgst_pos1 = 15;
8364 dgst_pos2 = 6;
8365 dgst_pos3 = 7;
8366 break;
8367
8368 case 1760: hash_type = HASH_TYPE_SHA512;
8369 salt_type = SALT_TYPE_INTERN;
8370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8371 opts_type = OPTS_TYPE_PT_GENERATE_BE
8372 | OPTS_TYPE_PT_ADD80
8373 | OPTS_TYPE_PT_ADDBITS15;
8374 kern_type = KERN_TYPE_HMACSHA512_SLT;
8375 dgst_size = DGST_SIZE_8_8;
8376 parse_func = hmacsha512_parse_hash;
8377 sort_by_digest = sort_by_digest_8_8;
8378 opti_type = OPTI_TYPE_ZERO_BYTE
8379 | OPTI_TYPE_USES_BITS_64
8380 | OPTI_TYPE_NOT_ITERATED;
8381 dgst_pos0 = 14;
8382 dgst_pos1 = 15;
8383 dgst_pos2 = 6;
8384 dgst_pos3 = 7;
8385 break;
8386
8387 case 1800: hash_type = HASH_TYPE_SHA512;
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 kern_type = KERN_TYPE_SHA512CRYPT;
8392 dgst_size = DGST_SIZE_8_8;
8393 parse_func = sha512crypt_parse_hash;
8394 sort_by_digest = sort_by_digest_8_8;
8395 opti_type = OPTI_TYPE_ZERO_BYTE
8396 | OPTI_TYPE_USES_BITS_64;
8397 dgst_pos0 = 0;
8398 dgst_pos1 = 1;
8399 dgst_pos2 = 2;
8400 dgst_pos3 = 3;
8401 break;
8402
8403 case 2100: hash_type = HASH_TYPE_DCC2;
8404 salt_type = SALT_TYPE_EMBEDDED;
8405 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8406 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8407 | OPTS_TYPE_ST_LOWER
8408 | OPTS_TYPE_ST_UNICODE;
8409 kern_type = KERN_TYPE_DCC2;
8410 dgst_size = DGST_SIZE_4_4;
8411 parse_func = dcc2_parse_hash;
8412 sort_by_digest = sort_by_digest_4_4;
8413 opti_type = OPTI_TYPE_ZERO_BYTE
8414 | OPTI_TYPE_SLOW_HASH_SIMD;
8415 dgst_pos0 = 0;
8416 dgst_pos1 = 1;
8417 dgst_pos2 = 2;
8418 dgst_pos3 = 3;
8419 break;
8420
8421 case 2400: hash_type = HASH_TYPE_MD5;
8422 salt_type = SALT_TYPE_NONE;
8423 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8424 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8425 kern_type = KERN_TYPE_MD5PIX;
8426 dgst_size = DGST_SIZE_4_4;
8427 parse_func = md5pix_parse_hash;
8428 sort_by_digest = sort_by_digest_4_4;
8429 opti_type = OPTI_TYPE_ZERO_BYTE
8430 | OPTI_TYPE_PRECOMPUTE_INIT
8431 | OPTI_TYPE_PRECOMPUTE_MERKLE
8432 | OPTI_TYPE_EARLY_SKIP
8433 | OPTI_TYPE_NOT_ITERATED
8434 | OPTI_TYPE_NOT_SALTED;
8435 dgst_pos0 = 0;
8436 dgst_pos1 = 3;
8437 dgst_pos2 = 2;
8438 dgst_pos3 = 1;
8439 break;
8440
8441 case 2410: hash_type = HASH_TYPE_MD5;
8442 salt_type = SALT_TYPE_INTERN;
8443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8444 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8445 kern_type = KERN_TYPE_MD5ASA;
8446 dgst_size = DGST_SIZE_4_4;
8447 parse_func = md5asa_parse_hash;
8448 sort_by_digest = sort_by_digest_4_4;
8449 opti_type = OPTI_TYPE_ZERO_BYTE
8450 | OPTI_TYPE_PRECOMPUTE_INIT
8451 | OPTI_TYPE_PRECOMPUTE_MERKLE
8452 | OPTI_TYPE_EARLY_SKIP
8453 | OPTI_TYPE_NOT_ITERATED;
8454 dgst_pos0 = 0;
8455 dgst_pos1 = 3;
8456 dgst_pos2 = 2;
8457 dgst_pos3 = 1;
8458 break;
8459
8460 case 2500: hash_type = HASH_TYPE_WPA;
8461 salt_type = SALT_TYPE_EMBEDDED;
8462 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8463 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8464 kern_type = KERN_TYPE_WPA;
8465 dgst_size = DGST_SIZE_4_4;
8466 parse_func = wpa_parse_hash;
8467 sort_by_digest = sort_by_digest_4_4;
8468 opti_type = OPTI_TYPE_ZERO_BYTE
8469 | OPTI_TYPE_SLOW_HASH_SIMD;
8470 dgst_pos0 = 0;
8471 dgst_pos1 = 1;
8472 dgst_pos2 = 2;
8473 dgst_pos3 = 3;
8474 break;
8475
8476 case 2600: hash_type = HASH_TYPE_MD5;
8477 salt_type = SALT_TYPE_VIRTUAL;
8478 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8479 opts_type = OPTS_TYPE_PT_GENERATE_LE
8480 | OPTS_TYPE_PT_ADD80
8481 | OPTS_TYPE_PT_ADDBITS14
8482 | OPTS_TYPE_ST_ADD80;
8483 kern_type = KERN_TYPE_MD55_PWSLT1;
8484 dgst_size = DGST_SIZE_4_4;
8485 parse_func = md5md5_parse_hash;
8486 sort_by_digest = sort_by_digest_4_4;
8487 opti_type = OPTI_TYPE_ZERO_BYTE
8488 | OPTI_TYPE_PRECOMPUTE_INIT
8489 | OPTI_TYPE_PRECOMPUTE_MERKLE
8490 | OPTI_TYPE_EARLY_SKIP;
8491 dgst_pos0 = 0;
8492 dgst_pos1 = 3;
8493 dgst_pos2 = 2;
8494 dgst_pos3 = 1;
8495 break;
8496
8497 case 2611: hash_type = HASH_TYPE_MD5;
8498 salt_type = SALT_TYPE_INTERN;
8499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8500 opts_type = OPTS_TYPE_PT_GENERATE_LE
8501 | OPTS_TYPE_PT_ADD80
8502 | OPTS_TYPE_PT_ADDBITS14
8503 | OPTS_TYPE_ST_ADD80;
8504 kern_type = KERN_TYPE_MD55_PWSLT1;
8505 dgst_size = DGST_SIZE_4_4;
8506 parse_func = vb3_parse_hash;
8507 sort_by_digest = sort_by_digest_4_4;
8508 opti_type = OPTI_TYPE_ZERO_BYTE
8509 | OPTI_TYPE_PRECOMPUTE_INIT
8510 | OPTI_TYPE_PRECOMPUTE_MERKLE
8511 | OPTI_TYPE_EARLY_SKIP;
8512 dgst_pos0 = 0;
8513 dgst_pos1 = 3;
8514 dgst_pos2 = 2;
8515 dgst_pos3 = 1;
8516 break;
8517
8518 case 2612: hash_type = HASH_TYPE_MD5;
8519 salt_type = SALT_TYPE_EMBEDDED;
8520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8521 opts_type = OPTS_TYPE_PT_GENERATE_LE
8522 | OPTS_TYPE_PT_ADD80
8523 | OPTS_TYPE_PT_ADDBITS14
8524 | OPTS_TYPE_ST_ADD80
8525 | OPTS_TYPE_ST_HEX;
8526 kern_type = KERN_TYPE_MD55_PWSLT1;
8527 dgst_size = DGST_SIZE_4_4;
8528 parse_func = phps_parse_hash;
8529 sort_by_digest = sort_by_digest_4_4;
8530 opti_type = OPTI_TYPE_ZERO_BYTE
8531 | OPTI_TYPE_PRECOMPUTE_INIT
8532 | OPTI_TYPE_PRECOMPUTE_MERKLE
8533 | OPTI_TYPE_EARLY_SKIP;
8534 dgst_pos0 = 0;
8535 dgst_pos1 = 3;
8536 dgst_pos2 = 2;
8537 dgst_pos3 = 1;
8538 break;
8539
8540 case 2711: hash_type = HASH_TYPE_MD5;
8541 salt_type = SALT_TYPE_INTERN;
8542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8543 opts_type = OPTS_TYPE_PT_GENERATE_LE
8544 | OPTS_TYPE_PT_ADD80
8545 | OPTS_TYPE_PT_ADDBITS14
8546 | OPTS_TYPE_ST_ADD80;
8547 kern_type = KERN_TYPE_MD55_PWSLT2;
8548 dgst_size = DGST_SIZE_4_4;
8549 parse_func = vb30_parse_hash;
8550 sort_by_digest = sort_by_digest_4_4;
8551 opti_type = OPTI_TYPE_ZERO_BYTE
8552 | OPTI_TYPE_PRECOMPUTE_INIT
8553 | OPTI_TYPE_EARLY_SKIP;
8554 dgst_pos0 = 0;
8555 dgst_pos1 = 3;
8556 dgst_pos2 = 2;
8557 dgst_pos3 = 1;
8558 break;
8559
8560 case 2811: hash_type = HASH_TYPE_MD5;
8561 salt_type = SALT_TYPE_INTERN;
8562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8563 opts_type = OPTS_TYPE_PT_GENERATE_LE
8564 | OPTS_TYPE_PT_ADD80
8565 | OPTS_TYPE_PT_ADDBITS14;
8566 kern_type = KERN_TYPE_MD55_SLTPW;
8567 dgst_size = DGST_SIZE_4_4;
8568 parse_func = ipb2_parse_hash;
8569 sort_by_digest = sort_by_digest_4_4;
8570 opti_type = OPTI_TYPE_ZERO_BYTE
8571 | OPTI_TYPE_PRECOMPUTE_INIT
8572 | OPTI_TYPE_EARLY_SKIP;
8573 dgst_pos0 = 0;
8574 dgst_pos1 = 3;
8575 dgst_pos2 = 2;
8576 dgst_pos3 = 1;
8577 break;
8578
8579 case 3000: hash_type = HASH_TYPE_LM;
8580 salt_type = SALT_TYPE_NONE;
8581 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8582 opts_type = OPTS_TYPE_PT_GENERATE_LE
8583 | OPTS_TYPE_PT_UPPER
8584 | OPTS_TYPE_PT_BITSLICE;
8585 kern_type = KERN_TYPE_LM;
8586 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8587 parse_func = lm_parse_hash;
8588 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8589 opti_type = OPTI_TYPE_ZERO_BYTE
8590 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8591 dgst_pos0 = 0;
8592 dgst_pos1 = 1;
8593 dgst_pos2 = 2;
8594 dgst_pos3 = 3;
8595 break;
8596
8597 case 3100: hash_type = HASH_TYPE_ORACLEH;
8598 salt_type = SALT_TYPE_INTERN;
8599 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8600 opts_type = OPTS_TYPE_PT_GENERATE_LE
8601 | OPTS_TYPE_PT_UPPER
8602 | OPTS_TYPE_ST_UPPER;
8603 kern_type = KERN_TYPE_ORACLEH;
8604 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8605 parse_func = oracleh_parse_hash;
8606 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
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 3200: hash_type = HASH_TYPE_BCRYPT;
8615 salt_type = SALT_TYPE_EMBEDDED;
8616 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8617 opts_type = OPTS_TYPE_PT_GENERATE_LE
8618 | OPTS_TYPE_ST_GENERATE_LE;
8619 kern_type = KERN_TYPE_BCRYPT;
8620 dgst_size = DGST_SIZE_4_6;
8621 parse_func = bcrypt_parse_hash;
8622 sort_by_digest = sort_by_digest_4_6;
8623 opti_type = OPTI_TYPE_ZERO_BYTE;
8624 dgst_pos0 = 0;
8625 dgst_pos1 = 1;
8626 dgst_pos2 = 2;
8627 dgst_pos3 = 3;
8628 break;
8629
8630 case 3710: hash_type = HASH_TYPE_MD5;
8631 salt_type = SALT_TYPE_INTERN;
8632 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8633 opts_type = OPTS_TYPE_PT_GENERATE_LE
8634 | OPTS_TYPE_PT_ADD80
8635 | OPTS_TYPE_PT_ADDBITS14;
8636 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8637 dgst_size = DGST_SIZE_4_4;
8638 parse_func = md5s_parse_hash;
8639 sort_by_digest = sort_by_digest_4_4;
8640 opti_type = OPTI_TYPE_ZERO_BYTE
8641 | OPTI_TYPE_PRECOMPUTE_INIT
8642 | OPTI_TYPE_PRECOMPUTE_MERKLE
8643 | OPTI_TYPE_EARLY_SKIP;
8644 dgst_pos0 = 0;
8645 dgst_pos1 = 3;
8646 dgst_pos2 = 2;
8647 dgst_pos3 = 1;
8648 break;
8649
8650 case 3711: hash_type = HASH_TYPE_MD5;
8651 salt_type = SALT_TYPE_EMBEDDED;
8652 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8653 opts_type = OPTS_TYPE_PT_GENERATE_LE
8654 | OPTS_TYPE_PT_ADD80
8655 | OPTS_TYPE_PT_ADDBITS14;
8656 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8657 dgst_size = DGST_SIZE_4_4;
8658 parse_func = mediawiki_b_parse_hash;
8659 sort_by_digest = sort_by_digest_4_4;
8660 opti_type = OPTI_TYPE_ZERO_BYTE
8661 | OPTI_TYPE_PRECOMPUTE_INIT
8662 | OPTI_TYPE_PRECOMPUTE_MERKLE
8663 | OPTI_TYPE_EARLY_SKIP;
8664 dgst_pos0 = 0;
8665 dgst_pos1 = 3;
8666 dgst_pos2 = 2;
8667 dgst_pos3 = 1;
8668 break;
8669
8670 case 3800: hash_type = HASH_TYPE_MD5;
8671 salt_type = SALT_TYPE_INTERN;
8672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8673 opts_type = OPTS_TYPE_PT_GENERATE_LE
8674 | OPTS_TYPE_ST_ADDBITS14;
8675 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8676 dgst_size = DGST_SIZE_4_4;
8677 parse_func = md5s_parse_hash;
8678 sort_by_digest = sort_by_digest_4_4;
8679 opti_type = OPTI_TYPE_ZERO_BYTE
8680 | OPTI_TYPE_PRECOMPUTE_INIT
8681 | OPTI_TYPE_PRECOMPUTE_MERKLE
8682 | OPTI_TYPE_EARLY_SKIP
8683 | OPTI_TYPE_NOT_ITERATED
8684 | OPTI_TYPE_RAW_HASH;
8685 dgst_pos0 = 0;
8686 dgst_pos1 = 3;
8687 dgst_pos2 = 2;
8688 dgst_pos3 = 1;
8689 break;
8690
8691 case 4300: hash_type = HASH_TYPE_MD5;
8692 salt_type = SALT_TYPE_VIRTUAL;
8693 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8694 opts_type = OPTS_TYPE_PT_GENERATE_LE
8695 | OPTS_TYPE_PT_ADD80
8696 | OPTS_TYPE_PT_ADDBITS14
8697 | OPTS_TYPE_ST_ADD80;
8698 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8699 dgst_size = DGST_SIZE_4_4;
8700 parse_func = md5md5_parse_hash;
8701 sort_by_digest = sort_by_digest_4_4;
8702 opti_type = OPTI_TYPE_ZERO_BYTE
8703 | OPTI_TYPE_PRECOMPUTE_INIT
8704 | OPTI_TYPE_PRECOMPUTE_MERKLE
8705 | OPTI_TYPE_EARLY_SKIP;
8706 dgst_pos0 = 0;
8707 dgst_pos1 = 3;
8708 dgst_pos2 = 2;
8709 dgst_pos3 = 1;
8710 break;
8711
8712
8713 case 4400: hash_type = HASH_TYPE_MD5;
8714 salt_type = SALT_TYPE_NONE;
8715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8716 opts_type = OPTS_TYPE_PT_GENERATE_BE
8717 | OPTS_TYPE_PT_ADD80
8718 | OPTS_TYPE_PT_ADDBITS15;
8719 kern_type = KERN_TYPE_MD5_SHA1;
8720 dgst_size = DGST_SIZE_4_4;
8721 parse_func = md5_parse_hash;
8722 sort_by_digest = sort_by_digest_4_4;
8723 opti_type = OPTI_TYPE_ZERO_BYTE
8724 | OPTI_TYPE_PRECOMPUTE_INIT
8725 | OPTI_TYPE_PRECOMPUTE_MERKLE
8726 | OPTI_TYPE_EARLY_SKIP
8727 | OPTI_TYPE_NOT_ITERATED
8728 | OPTI_TYPE_NOT_SALTED
8729 | OPTI_TYPE_RAW_HASH;
8730 dgst_pos0 = 0;
8731 dgst_pos1 = 3;
8732 dgst_pos2 = 2;
8733 dgst_pos3 = 1;
8734 break;
8735
8736 case 4500: hash_type = HASH_TYPE_SHA1;
8737 salt_type = SALT_TYPE_NONE;
8738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8739 opts_type = OPTS_TYPE_PT_GENERATE_BE
8740 | OPTS_TYPE_PT_ADD80
8741 | OPTS_TYPE_PT_ADDBITS15;
8742 kern_type = KERN_TYPE_SHA11;
8743 dgst_size = DGST_SIZE_4_5;
8744 parse_func = sha1_parse_hash;
8745 sort_by_digest = sort_by_digest_4_5;
8746 opti_type = OPTI_TYPE_ZERO_BYTE
8747 | OPTI_TYPE_PRECOMPUTE_INIT
8748 | OPTI_TYPE_PRECOMPUTE_MERKLE
8749 | OPTI_TYPE_EARLY_SKIP
8750 | OPTI_TYPE_NOT_SALTED;
8751 dgst_pos0 = 3;
8752 dgst_pos1 = 4;
8753 dgst_pos2 = 2;
8754 dgst_pos3 = 1;
8755 break;
8756
8757 case 4700: hash_type = HASH_TYPE_SHA1;
8758 salt_type = SALT_TYPE_NONE;
8759 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8760 opts_type = OPTS_TYPE_PT_GENERATE_LE
8761 | OPTS_TYPE_PT_ADD80
8762 | OPTS_TYPE_PT_ADDBITS14;
8763 kern_type = KERN_TYPE_SHA1_MD5;
8764 dgst_size = DGST_SIZE_4_5;
8765 parse_func = sha1_parse_hash;
8766 sort_by_digest = sort_by_digest_4_5;
8767 opti_type = OPTI_TYPE_ZERO_BYTE
8768 | OPTI_TYPE_PRECOMPUTE_INIT
8769 | OPTI_TYPE_PRECOMPUTE_MERKLE
8770 | OPTI_TYPE_EARLY_SKIP
8771 | OPTI_TYPE_NOT_ITERATED
8772 | OPTI_TYPE_NOT_SALTED
8773 | OPTI_TYPE_RAW_HASH;
8774 dgst_pos0 = 3;
8775 dgst_pos1 = 4;
8776 dgst_pos2 = 2;
8777 dgst_pos3 = 1;
8778 break;
8779
8780 case 4800: hash_type = HASH_TYPE_MD5;
8781 salt_type = SALT_TYPE_EMBEDDED;
8782 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8783 opts_type = OPTS_TYPE_PT_GENERATE_LE
8784 | OPTS_TYPE_PT_ADDBITS14;
8785 kern_type = KERN_TYPE_MD5_CHAP;
8786 dgst_size = DGST_SIZE_4_4;
8787 parse_func = chap_parse_hash;
8788 sort_by_digest = sort_by_digest_4_4;
8789 opti_type = OPTI_TYPE_ZERO_BYTE
8790 | OPTI_TYPE_PRECOMPUTE_INIT
8791 | OPTI_TYPE_PRECOMPUTE_MERKLE
8792 | OPTI_TYPE_MEET_IN_MIDDLE
8793 | OPTI_TYPE_EARLY_SKIP
8794 | OPTI_TYPE_NOT_ITERATED
8795 | OPTI_TYPE_RAW_HASH;
8796 dgst_pos0 = 0;
8797 dgst_pos1 = 3;
8798 dgst_pos2 = 2;
8799 dgst_pos3 = 1;
8800 break;
8801
8802 case 4900: hash_type = HASH_TYPE_SHA1;
8803 salt_type = SALT_TYPE_INTERN;
8804 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8805 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8806 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8807 dgst_size = DGST_SIZE_4_5;
8808 parse_func = sha1s_parse_hash;
8809 sort_by_digest = sort_by_digest_4_5;
8810 opti_type = OPTI_TYPE_ZERO_BYTE
8811 | OPTI_TYPE_PRECOMPUTE_INIT
8812 | OPTI_TYPE_PRECOMPUTE_MERKLE
8813 | OPTI_TYPE_EARLY_SKIP;
8814 dgst_pos0 = 3;
8815 dgst_pos1 = 4;
8816 dgst_pos2 = 2;
8817 dgst_pos3 = 1;
8818 break;
8819
8820 case 5000: hash_type = HASH_TYPE_KECCAK;
8821 salt_type = SALT_TYPE_EMBEDDED;
8822 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8823 opts_type = OPTS_TYPE_PT_GENERATE_LE
8824 | OPTS_TYPE_PT_ADD01;
8825 kern_type = KERN_TYPE_KECCAK;
8826 dgst_size = DGST_SIZE_8_25;
8827 parse_func = keccak_parse_hash;
8828 sort_by_digest = sort_by_digest_8_25;
8829 opti_type = OPTI_TYPE_ZERO_BYTE
8830 | OPTI_TYPE_USES_BITS_64
8831 | OPTI_TYPE_RAW_HASH;
8832 dgst_pos0 = 2;
8833 dgst_pos1 = 3;
8834 dgst_pos2 = 4;
8835 dgst_pos3 = 5;
8836 break;
8837
8838 case 5100: hash_type = HASH_TYPE_MD5H;
8839 salt_type = SALT_TYPE_NONE;
8840 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8841 opts_type = OPTS_TYPE_PT_GENERATE_LE
8842 | OPTS_TYPE_PT_ADD80
8843 | OPTS_TYPE_PT_ADDBITS14;
8844 kern_type = KERN_TYPE_MD5H;
8845 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8846 parse_func = md5half_parse_hash;
8847 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8848 opti_type = OPTI_TYPE_ZERO_BYTE
8849 | OPTI_TYPE_RAW_HASH;
8850 dgst_pos0 = 0;
8851 dgst_pos1 = 1;
8852 dgst_pos2 = 2;
8853 dgst_pos3 = 3;
8854 break;
8855
8856 case 5200: hash_type = HASH_TYPE_SHA256;
8857 salt_type = SALT_TYPE_EMBEDDED;
8858 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8859 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8860 kern_type = KERN_TYPE_PSAFE3;
8861 dgst_size = DGST_SIZE_4_8;
8862 parse_func = psafe3_parse_hash;
8863 sort_by_digest = sort_by_digest_4_8;
8864 opti_type = OPTI_TYPE_ZERO_BYTE;
8865 dgst_pos0 = 0;
8866 dgst_pos1 = 1;
8867 dgst_pos2 = 2;
8868 dgst_pos3 = 3;
8869 break;
8870
8871 case 5300: hash_type = HASH_TYPE_MD5;
8872 salt_type = SALT_TYPE_EMBEDDED;
8873 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8874 opts_type = OPTS_TYPE_PT_GENERATE_LE
8875 | OPTS_TYPE_ST_ADD80;
8876 kern_type = KERN_TYPE_IKEPSK_MD5;
8877 dgst_size = DGST_SIZE_4_4;
8878 parse_func = ikepsk_md5_parse_hash;
8879 sort_by_digest = sort_by_digest_4_4;
8880 opti_type = OPTI_TYPE_ZERO_BYTE;
8881 dgst_pos0 = 0;
8882 dgst_pos1 = 3;
8883 dgst_pos2 = 2;
8884 dgst_pos3 = 1;
8885 break;
8886
8887 case 5400: hash_type = HASH_TYPE_SHA1;
8888 salt_type = SALT_TYPE_EMBEDDED;
8889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8890 opts_type = OPTS_TYPE_PT_GENERATE_BE
8891 | OPTS_TYPE_ST_ADD80;
8892 kern_type = KERN_TYPE_IKEPSK_SHA1;
8893 dgst_size = DGST_SIZE_4_5;
8894 parse_func = ikepsk_sha1_parse_hash;
8895 sort_by_digest = sort_by_digest_4_5;
8896 opti_type = OPTI_TYPE_ZERO_BYTE;
8897 dgst_pos0 = 3;
8898 dgst_pos1 = 4;
8899 dgst_pos2 = 2;
8900 dgst_pos3 = 1;
8901 break;
8902
8903 case 5500: hash_type = HASH_TYPE_NETNTLM;
8904 salt_type = SALT_TYPE_EMBEDDED;
8905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8906 opts_type = OPTS_TYPE_PT_GENERATE_LE
8907 | OPTS_TYPE_PT_ADD80
8908 | OPTS_TYPE_PT_ADDBITS14
8909 | OPTS_TYPE_PT_UNICODE
8910 | OPTS_TYPE_ST_HEX;
8911 kern_type = KERN_TYPE_NETNTLMv1;
8912 dgst_size = DGST_SIZE_4_4;
8913 parse_func = netntlmv1_parse_hash;
8914 sort_by_digest = sort_by_digest_4_4;
8915 opti_type = OPTI_TYPE_ZERO_BYTE
8916 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8917 dgst_pos0 = 0;
8918 dgst_pos1 = 1;
8919 dgst_pos2 = 2;
8920 dgst_pos3 = 3;
8921 break;
8922
8923 case 5600: hash_type = HASH_TYPE_MD5;
8924 salt_type = SALT_TYPE_EMBEDDED;
8925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8926 opts_type = OPTS_TYPE_PT_GENERATE_LE
8927 | OPTS_TYPE_PT_ADD80
8928 | OPTS_TYPE_PT_ADDBITS14
8929 | OPTS_TYPE_PT_UNICODE;
8930 kern_type = KERN_TYPE_NETNTLMv2;
8931 dgst_size = DGST_SIZE_4_4;
8932 parse_func = netntlmv2_parse_hash;
8933 sort_by_digest = sort_by_digest_4_4;
8934 opti_type = OPTI_TYPE_ZERO_BYTE;
8935 dgst_pos0 = 0;
8936 dgst_pos1 = 3;
8937 dgst_pos2 = 2;
8938 dgst_pos3 = 1;
8939 break;
8940
8941 case 5700: hash_type = HASH_TYPE_SHA256;
8942 salt_type = SALT_TYPE_NONE;
8943 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8944 opts_type = OPTS_TYPE_PT_GENERATE_BE
8945 | OPTS_TYPE_PT_ADD80
8946 | OPTS_TYPE_PT_ADDBITS15;
8947 kern_type = KERN_TYPE_SHA256;
8948 dgst_size = DGST_SIZE_4_8;
8949 parse_func = cisco4_parse_hash;
8950 sort_by_digest = sort_by_digest_4_8;
8951 opti_type = OPTI_TYPE_ZERO_BYTE
8952 | OPTI_TYPE_PRECOMPUTE_INIT
8953 | OPTI_TYPE_PRECOMPUTE_MERKLE
8954 | OPTI_TYPE_EARLY_SKIP
8955 | OPTI_TYPE_NOT_ITERATED
8956 | OPTI_TYPE_NOT_SALTED
8957 | OPTI_TYPE_RAW_HASH;
8958 dgst_pos0 = 3;
8959 dgst_pos1 = 7;
8960 dgst_pos2 = 2;
8961 dgst_pos3 = 6;
8962 break;
8963
8964 case 5800: hash_type = HASH_TYPE_SHA1;
8965 salt_type = SALT_TYPE_INTERN;
8966 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8967 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8968 | OPTS_TYPE_ST_ADD80;
8969 kern_type = KERN_TYPE_ANDROIDPIN;
8970 dgst_size = DGST_SIZE_4_5;
8971 parse_func = androidpin_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 6000: hash_type = HASH_TYPE_RIPEMD160;
8981 salt_type = SALT_TYPE_NONE;
8982 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8983 opts_type = OPTS_TYPE_PT_GENERATE_LE
8984 | OPTS_TYPE_PT_ADD80;
8985 kern_type = KERN_TYPE_RIPEMD160;
8986 dgst_size = DGST_SIZE_4_5;
8987 parse_func = ripemd160_parse_hash;
8988 sort_by_digest = sort_by_digest_4_5;
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 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8997 salt_type = SALT_TYPE_NONE;
8998 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_BE
9000 | OPTS_TYPE_PT_ADD80;
9001 kern_type = KERN_TYPE_WHIRLPOOL;
9002 dgst_size = DGST_SIZE_4_16;
9003 parse_func = whirlpool_parse_hash;
9004 sort_by_digest = sort_by_digest_4_16;
9005 opti_type = OPTI_TYPE_ZERO_BYTE;
9006 dgst_pos0 = 0;
9007 dgst_pos1 = 1;
9008 dgst_pos2 = 2;
9009 dgst_pos3 = 3;
9010 break;
9011
9012 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9013 salt_type = SALT_TYPE_EMBEDDED;
9014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9015 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9016 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9017 dgst_size = DGST_SIZE_4_5;
9018 parse_func = truecrypt_parse_hash_2k;
9019 sort_by_digest = sort_by_digest_4_5;
9020 opti_type = OPTI_TYPE_ZERO_BYTE;
9021 dgst_pos0 = 0;
9022 dgst_pos1 = 1;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 3;
9025 break;
9026
9027 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9028 salt_type = SALT_TYPE_EMBEDDED;
9029 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9030 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9031 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9032 dgst_size = DGST_SIZE_4_5;
9033 parse_func = truecrypt_parse_hash_2k;
9034 sort_by_digest = sort_by_digest_4_5;
9035 opti_type = OPTI_TYPE_ZERO_BYTE;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9043 salt_type = SALT_TYPE_EMBEDDED;
9044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9045 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9046 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9047 dgst_size = DGST_SIZE_4_5;
9048 parse_func = truecrypt_parse_hash_2k;
9049 sort_by_digest = sort_by_digest_4_5;
9050 opti_type = OPTI_TYPE_ZERO_BYTE;
9051 dgst_pos0 = 0;
9052 dgst_pos1 = 1;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 3;
9055 break;
9056
9057 case 6221: 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_XTS512;
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 6222: 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_XTS1024;
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 6223: hash_type = HASH_TYPE_SHA512;
9090 salt_type = SALT_TYPE_EMBEDDED;
9091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9092 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9093 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9094 dgst_size = DGST_SIZE_8_8;
9095 parse_func = truecrypt_parse_hash_1k;
9096 sort_by_digest = sort_by_digest_8_8;
9097 opti_type = OPTI_TYPE_ZERO_BYTE
9098 | OPTI_TYPE_USES_BITS_64;
9099 dgst_pos0 = 0;
9100 dgst_pos1 = 1;
9101 dgst_pos2 = 2;
9102 dgst_pos3 = 3;
9103 break;
9104
9105 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9106 salt_type = SALT_TYPE_EMBEDDED;
9107 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9108 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9109 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9110 dgst_size = DGST_SIZE_4_8;
9111 parse_func = truecrypt_parse_hash_1k;
9112 sort_by_digest = sort_by_digest_4_8;
9113 opti_type = OPTI_TYPE_ZERO_BYTE;
9114 dgst_pos0 = 0;
9115 dgst_pos1 = 1;
9116 dgst_pos2 = 2;
9117 dgst_pos3 = 3;
9118 break;
9119
9120 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9121 salt_type = SALT_TYPE_EMBEDDED;
9122 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9123 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9124 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9125 dgst_size = DGST_SIZE_4_8;
9126 parse_func = truecrypt_parse_hash_1k;
9127 sort_by_digest = sort_by_digest_4_8;
9128 opti_type = OPTI_TYPE_ZERO_BYTE;
9129 dgst_pos0 = 0;
9130 dgst_pos1 = 1;
9131 dgst_pos2 = 2;
9132 dgst_pos3 = 3;
9133 break;
9134
9135 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9136 salt_type = SALT_TYPE_EMBEDDED;
9137 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9138 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9139 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9140 dgst_size = DGST_SIZE_4_8;
9141 parse_func = truecrypt_parse_hash_1k;
9142 sort_by_digest = sort_by_digest_4_8;
9143 opti_type = OPTI_TYPE_ZERO_BYTE;
9144 dgst_pos0 = 0;
9145 dgst_pos1 = 1;
9146 dgst_pos2 = 2;
9147 dgst_pos3 = 3;
9148 break;
9149
9150 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9151 salt_type = SALT_TYPE_EMBEDDED;
9152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9153 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9154 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9155 dgst_size = DGST_SIZE_4_5;
9156 parse_func = truecrypt_parse_hash_1k;
9157 sort_by_digest = sort_by_digest_4_5;
9158 opti_type = OPTI_TYPE_ZERO_BYTE;
9159 dgst_pos0 = 0;
9160 dgst_pos1 = 1;
9161 dgst_pos2 = 2;
9162 dgst_pos3 = 3;
9163 break;
9164
9165 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9166 salt_type = SALT_TYPE_EMBEDDED;
9167 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9168 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9169 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9170 dgst_size = DGST_SIZE_4_5;
9171 parse_func = truecrypt_parse_hash_1k;
9172 sort_by_digest = sort_by_digest_4_5;
9173 opti_type = OPTI_TYPE_ZERO_BYTE;
9174 dgst_pos0 = 0;
9175 dgst_pos1 = 1;
9176 dgst_pos2 = 2;
9177 dgst_pos3 = 3;
9178 break;
9179
9180 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9181 salt_type = SALT_TYPE_EMBEDDED;
9182 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9183 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9184 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9185 dgst_size = DGST_SIZE_4_5;
9186 parse_func = truecrypt_parse_hash_1k;
9187 sort_by_digest = sort_by_digest_4_5;
9188 opti_type = OPTI_TYPE_ZERO_BYTE;
9189 dgst_pos0 = 0;
9190 dgst_pos1 = 1;
9191 dgst_pos2 = 2;
9192 dgst_pos3 = 3;
9193 break;
9194
9195 case 6300: hash_type = HASH_TYPE_MD5;
9196 salt_type = SALT_TYPE_EMBEDDED;
9197 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9198 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9199 kern_type = KERN_TYPE_MD5AIX;
9200 dgst_size = DGST_SIZE_4_4;
9201 parse_func = md5aix_parse_hash;
9202 sort_by_digest = sort_by_digest_4_4;
9203 opti_type = OPTI_TYPE_ZERO_BYTE;
9204 dgst_pos0 = 0;
9205 dgst_pos1 = 1;
9206 dgst_pos2 = 2;
9207 dgst_pos3 = 3;
9208 break;
9209
9210 case 6400: hash_type = HASH_TYPE_SHA256;
9211 salt_type = SALT_TYPE_EMBEDDED;
9212 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9213 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9214 kern_type = KERN_TYPE_SHA256AIX;
9215 dgst_size = DGST_SIZE_4_8;
9216 parse_func = sha256aix_parse_hash;
9217 sort_by_digest = sort_by_digest_4_8;
9218 opti_type = OPTI_TYPE_ZERO_BYTE;
9219 dgst_pos0 = 0;
9220 dgst_pos1 = 1;
9221 dgst_pos2 = 2;
9222 dgst_pos3 = 3;
9223 break;
9224
9225 case 6500: hash_type = HASH_TYPE_SHA512;
9226 salt_type = SALT_TYPE_EMBEDDED;
9227 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9228 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9229 kern_type = KERN_TYPE_SHA512AIX;
9230 dgst_size = DGST_SIZE_8_8;
9231 parse_func = sha512aix_parse_hash;
9232 sort_by_digest = sort_by_digest_8_8;
9233 opti_type = OPTI_TYPE_ZERO_BYTE
9234 | OPTI_TYPE_USES_BITS_64;
9235 dgst_pos0 = 0;
9236 dgst_pos1 = 1;
9237 dgst_pos2 = 2;
9238 dgst_pos3 = 3;
9239 break;
9240
9241 case 6600: hash_type = HASH_TYPE_AES;
9242 salt_type = SALT_TYPE_EMBEDDED;
9243 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9244 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9245 kern_type = KERN_TYPE_AGILEKEY;
9246 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9247 parse_func = agilekey_parse_hash;
9248 sort_by_digest = sort_by_digest_4_5;
9249 opti_type = OPTI_TYPE_ZERO_BYTE;
9250 dgst_pos0 = 0;
9251 dgst_pos1 = 1;
9252 dgst_pos2 = 2;
9253 dgst_pos3 = 3;
9254 break;
9255
9256 case 6700: hash_type = HASH_TYPE_SHA1;
9257 salt_type = SALT_TYPE_EMBEDDED;
9258 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9259 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9260 kern_type = KERN_TYPE_SHA1AIX;
9261 dgst_size = DGST_SIZE_4_5;
9262 parse_func = sha1aix_parse_hash;
9263 sort_by_digest = sort_by_digest_4_5;
9264 opti_type = OPTI_TYPE_ZERO_BYTE;
9265 dgst_pos0 = 0;
9266 dgst_pos1 = 1;
9267 dgst_pos2 = 2;
9268 dgst_pos3 = 3;
9269 break;
9270
9271 case 6800: hash_type = HASH_TYPE_AES;
9272 salt_type = SALT_TYPE_EMBEDDED;
9273 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9274 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9275 kern_type = KERN_TYPE_LASTPASS;
9276 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9277 parse_func = lastpass_parse_hash;
9278 sort_by_digest = sort_by_digest_4_8;
9279 opti_type = OPTI_TYPE_ZERO_BYTE;
9280 dgst_pos0 = 0;
9281 dgst_pos1 = 1;
9282 dgst_pos2 = 2;
9283 dgst_pos3 = 3;
9284 break;
9285
9286 case 6900: hash_type = HASH_TYPE_GOST;
9287 salt_type = SALT_TYPE_NONE;
9288 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9289 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9290 kern_type = KERN_TYPE_GOST;
9291 dgst_size = DGST_SIZE_4_8;
9292 parse_func = gost_parse_hash;
9293 sort_by_digest = sort_by_digest_4_8;
9294 opti_type = OPTI_TYPE_ZERO_BYTE;
9295 dgst_pos0 = 0;
9296 dgst_pos1 = 1;
9297 dgst_pos2 = 2;
9298 dgst_pos3 = 3;
9299 break;
9300
9301 case 7100: hash_type = HASH_TYPE_SHA512;
9302 salt_type = SALT_TYPE_EMBEDDED;
9303 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9304 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9305 kern_type = KERN_TYPE_PBKDF2_SHA512;
9306 dgst_size = DGST_SIZE_8_16;
9307 parse_func = sha512osx_parse_hash;
9308 sort_by_digest = sort_by_digest_8_16;
9309 opti_type = OPTI_TYPE_ZERO_BYTE
9310 | OPTI_TYPE_USES_BITS_64
9311 | OPTI_TYPE_SLOW_HASH_SIMD;
9312 dgst_pos0 = 0;
9313 dgst_pos1 = 1;
9314 dgst_pos2 = 2;
9315 dgst_pos3 = 3;
9316 break;
9317
9318 case 7200: hash_type = HASH_TYPE_SHA512;
9319 salt_type = SALT_TYPE_EMBEDDED;
9320 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9321 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9322 kern_type = KERN_TYPE_PBKDF2_SHA512;
9323 dgst_size = DGST_SIZE_8_16;
9324 parse_func = sha512grub_parse_hash;
9325 sort_by_digest = sort_by_digest_8_16;
9326 opti_type = OPTI_TYPE_ZERO_BYTE
9327 | OPTI_TYPE_USES_BITS_64
9328 | OPTI_TYPE_SLOW_HASH_SIMD;
9329 dgst_pos0 = 0;
9330 dgst_pos1 = 1;
9331 dgst_pos2 = 2;
9332 dgst_pos3 = 3;
9333 break;
9334
9335 case 7300: hash_type = HASH_TYPE_SHA1;
9336 salt_type = SALT_TYPE_EMBEDDED;
9337 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9338 opts_type = OPTS_TYPE_PT_GENERATE_BE
9339 | OPTS_TYPE_ST_ADD80
9340 | OPTS_TYPE_ST_ADDBITS15;
9341 kern_type = KERN_TYPE_RAKP;
9342 dgst_size = DGST_SIZE_4_5;
9343 parse_func = rakp_parse_hash;
9344 sort_by_digest = sort_by_digest_4_5;
9345 opti_type = OPTI_TYPE_ZERO_BYTE
9346 | OPTI_TYPE_NOT_ITERATED;
9347 dgst_pos0 = 3;
9348 dgst_pos1 = 4;
9349 dgst_pos2 = 2;
9350 dgst_pos3 = 1;
9351 break;
9352
9353 case 7400: hash_type = HASH_TYPE_SHA256;
9354 salt_type = SALT_TYPE_EMBEDDED;
9355 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9356 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9357 kern_type = KERN_TYPE_SHA256CRYPT;
9358 dgst_size = DGST_SIZE_4_8;
9359 parse_func = sha256crypt_parse_hash;
9360 sort_by_digest = sort_by_digest_4_8;
9361 opti_type = OPTI_TYPE_ZERO_BYTE;
9362 dgst_pos0 = 0;
9363 dgst_pos1 = 1;
9364 dgst_pos2 = 2;
9365 dgst_pos3 = 3;
9366 break;
9367
9368 case 7500: hash_type = HASH_TYPE_KRB5PA;
9369 salt_type = SALT_TYPE_EMBEDDED;
9370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9371 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9372 kern_type = KERN_TYPE_KRB5PA;
9373 dgst_size = DGST_SIZE_4_4;
9374 parse_func = krb5pa_parse_hash;
9375 sort_by_digest = sort_by_digest_4_4;
9376 opti_type = OPTI_TYPE_ZERO_BYTE
9377 | OPTI_TYPE_NOT_ITERATED;
9378 dgst_pos0 = 0;
9379 dgst_pos1 = 1;
9380 dgst_pos2 = 2;
9381 dgst_pos3 = 3;
9382 break;
9383
9384 case 7600: hash_type = HASH_TYPE_SHA1;
9385 salt_type = SALT_TYPE_INTERN;
9386 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9387 opts_type = OPTS_TYPE_PT_GENERATE_BE
9388 | OPTS_TYPE_PT_ADD80
9389 | OPTS_TYPE_PT_ADDBITS15;
9390 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9391 dgst_size = DGST_SIZE_4_5;
9392 parse_func = redmine_parse_hash;
9393 sort_by_digest = sort_by_digest_4_5;
9394 opti_type = OPTI_TYPE_ZERO_BYTE
9395 | OPTI_TYPE_PRECOMPUTE_INIT
9396 | OPTI_TYPE_EARLY_SKIP
9397 | OPTI_TYPE_NOT_ITERATED
9398 | OPTI_TYPE_PREPENDED_SALT;
9399 dgst_pos0 = 3;
9400 dgst_pos1 = 4;
9401 dgst_pos2 = 2;
9402 dgst_pos3 = 1;
9403 break;
9404
9405 case 7700: hash_type = HASH_TYPE_SAPB;
9406 salt_type = SALT_TYPE_EMBEDDED;
9407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9408 opts_type = OPTS_TYPE_PT_GENERATE_LE
9409 | OPTS_TYPE_PT_UPPER
9410 | OPTS_TYPE_ST_UPPER;
9411 kern_type = KERN_TYPE_SAPB;
9412 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9413 parse_func = sapb_parse_hash;
9414 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9415 opti_type = OPTI_TYPE_ZERO_BYTE
9416 | OPTI_TYPE_PRECOMPUTE_INIT
9417 | OPTI_TYPE_NOT_ITERATED;
9418 dgst_pos0 = 0;
9419 dgst_pos1 = 1;
9420 dgst_pos2 = 2;
9421 dgst_pos3 = 3;
9422 break;
9423
9424 case 7800: hash_type = HASH_TYPE_SAPG;
9425 salt_type = SALT_TYPE_EMBEDDED;
9426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9427 opts_type = OPTS_TYPE_PT_GENERATE_BE
9428 | OPTS_TYPE_ST_ADD80
9429 | OPTS_TYPE_ST_UPPER;
9430 kern_type = KERN_TYPE_SAPG;
9431 dgst_size = DGST_SIZE_4_5;
9432 parse_func = sapg_parse_hash;
9433 sort_by_digest = sort_by_digest_4_5;
9434 opti_type = OPTI_TYPE_ZERO_BYTE
9435 | OPTI_TYPE_PRECOMPUTE_INIT
9436 | OPTI_TYPE_NOT_ITERATED;
9437 dgst_pos0 = 3;
9438 dgst_pos1 = 4;
9439 dgst_pos2 = 2;
9440 dgst_pos3 = 1;
9441 break;
9442
9443 case 7900: hash_type = HASH_TYPE_SHA512;
9444 salt_type = SALT_TYPE_EMBEDDED;
9445 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9446 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9447 kern_type = KERN_TYPE_DRUPAL7;
9448 dgst_size = DGST_SIZE_8_8;
9449 parse_func = drupal7_parse_hash;
9450 sort_by_digest = sort_by_digest_8_8;
9451 opti_type = OPTI_TYPE_ZERO_BYTE
9452 | OPTI_TYPE_USES_BITS_64;
9453 dgst_pos0 = 0;
9454 dgst_pos1 = 1;
9455 dgst_pos2 = 2;
9456 dgst_pos3 = 3;
9457 break;
9458
9459 case 8000: hash_type = HASH_TYPE_SHA256;
9460 salt_type = SALT_TYPE_EMBEDDED;
9461 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9462 opts_type = OPTS_TYPE_PT_GENERATE_BE
9463 | OPTS_TYPE_PT_UNICODE
9464 | OPTS_TYPE_ST_ADD80
9465 | OPTS_TYPE_ST_HEX;
9466 kern_type = KERN_TYPE_SYBASEASE;
9467 dgst_size = DGST_SIZE_4_8;
9468 parse_func = sybasease_parse_hash;
9469 sort_by_digest = sort_by_digest_4_8;
9470 opti_type = OPTI_TYPE_ZERO_BYTE
9471 | OPTI_TYPE_PRECOMPUTE_INIT
9472 | OPTI_TYPE_EARLY_SKIP
9473 | OPTI_TYPE_NOT_ITERATED
9474 | OPTI_TYPE_RAW_HASH;
9475 dgst_pos0 = 3;
9476 dgst_pos1 = 7;
9477 dgst_pos2 = 2;
9478 dgst_pos3 = 6;
9479 break;
9480
9481 case 8100: hash_type = HASH_TYPE_SHA1;
9482 salt_type = SALT_TYPE_EMBEDDED;
9483 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9484 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9485 kern_type = KERN_TYPE_NETSCALER;
9486 dgst_size = DGST_SIZE_4_5;
9487 parse_func = netscaler_parse_hash;
9488 sort_by_digest = sort_by_digest_4_5;
9489 opti_type = OPTI_TYPE_ZERO_BYTE
9490 | OPTI_TYPE_PRECOMPUTE_INIT
9491 | OPTI_TYPE_PRECOMPUTE_MERKLE
9492 | OPTI_TYPE_EARLY_SKIP
9493 | OPTI_TYPE_NOT_ITERATED
9494 | OPTI_TYPE_PREPENDED_SALT
9495 | OPTI_TYPE_RAW_HASH;
9496 dgst_pos0 = 3;
9497 dgst_pos1 = 4;
9498 dgst_pos2 = 2;
9499 dgst_pos3 = 1;
9500 break;
9501
9502 case 8200: hash_type = HASH_TYPE_SHA256;
9503 salt_type = SALT_TYPE_EMBEDDED;
9504 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9505 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9506 kern_type = KERN_TYPE_CLOUDKEY;
9507 dgst_size = DGST_SIZE_4_8;
9508 parse_func = cloudkey_parse_hash;
9509 sort_by_digest = sort_by_digest_4_8;
9510 opti_type = OPTI_TYPE_ZERO_BYTE;
9511 dgst_pos0 = 0;
9512 dgst_pos1 = 1;
9513 dgst_pos2 = 2;
9514 dgst_pos3 = 3;
9515 break;
9516
9517 case 8300: hash_type = HASH_TYPE_SHA1;
9518 salt_type = SALT_TYPE_EMBEDDED;
9519 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9520 opts_type = OPTS_TYPE_PT_GENERATE_BE
9521 | OPTS_TYPE_ST_HEX
9522 | OPTS_TYPE_ST_ADD80;
9523 kern_type = KERN_TYPE_NSEC3;
9524 dgst_size = DGST_SIZE_4_5;
9525 parse_func = nsec3_parse_hash;
9526 sort_by_digest = sort_by_digest_4_5;
9527 opti_type = OPTI_TYPE_ZERO_BYTE;
9528 dgst_pos0 = 3;
9529 dgst_pos1 = 4;
9530 dgst_pos2 = 2;
9531 dgst_pos3 = 1;
9532 break;
9533
9534 case 8400: hash_type = HASH_TYPE_SHA1;
9535 salt_type = SALT_TYPE_INTERN;
9536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9537 opts_type = OPTS_TYPE_PT_GENERATE_BE
9538 | OPTS_TYPE_PT_ADD80
9539 | OPTS_TYPE_PT_ADDBITS15;
9540 kern_type = KERN_TYPE_WBB3;
9541 dgst_size = DGST_SIZE_4_5;
9542 parse_func = wbb3_parse_hash;
9543 sort_by_digest = sort_by_digest_4_5;
9544 opti_type = OPTI_TYPE_ZERO_BYTE
9545 | OPTI_TYPE_PRECOMPUTE_INIT
9546 | OPTI_TYPE_NOT_ITERATED;
9547 dgst_pos0 = 3;
9548 dgst_pos1 = 4;
9549 dgst_pos2 = 2;
9550 dgst_pos3 = 1;
9551 break;
9552
9553 case 8500: hash_type = HASH_TYPE_DESRACF;
9554 salt_type = SALT_TYPE_EMBEDDED;
9555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9556 opts_type = OPTS_TYPE_PT_GENERATE_LE
9557 | OPTS_TYPE_ST_UPPER;
9558 kern_type = KERN_TYPE_RACF;
9559 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9560 parse_func = racf_parse_hash;
9561 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9562 opti_type = OPTI_TYPE_ZERO_BYTE
9563 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9564 dgst_pos0 = 0;
9565 dgst_pos1 = 1;
9566 dgst_pos2 = 2;
9567 dgst_pos3 = 3;
9568 break;
9569
9570 case 8600: hash_type = HASH_TYPE_LOTUS5;
9571 salt_type = SALT_TYPE_NONE;
9572 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9573 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9574 kern_type = KERN_TYPE_LOTUS5;
9575 dgst_size = DGST_SIZE_4_4;
9576 parse_func = lotus5_parse_hash;
9577 sort_by_digest = sort_by_digest_4_4;
9578 opti_type = OPTI_TYPE_EARLY_SKIP
9579 | OPTI_TYPE_NOT_ITERATED
9580 | OPTI_TYPE_NOT_SALTED
9581 | OPTI_TYPE_RAW_HASH;
9582 dgst_pos0 = 0;
9583 dgst_pos1 = 1;
9584 dgst_pos2 = 2;
9585 dgst_pos3 = 3;
9586 break;
9587
9588 case 8700: hash_type = HASH_TYPE_LOTUS6;
9589 salt_type = SALT_TYPE_EMBEDDED;
9590 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9591 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9592 kern_type = KERN_TYPE_LOTUS6;
9593 dgst_size = DGST_SIZE_4_4;
9594 parse_func = lotus6_parse_hash;
9595 sort_by_digest = sort_by_digest_4_4;
9596 opti_type = OPTI_TYPE_EARLY_SKIP
9597 | OPTI_TYPE_NOT_ITERATED
9598 | OPTI_TYPE_RAW_HASH;
9599 dgst_pos0 = 0;
9600 dgst_pos1 = 1;
9601 dgst_pos2 = 2;
9602 dgst_pos3 = 3;
9603 break;
9604
9605 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9606 salt_type = SALT_TYPE_EMBEDDED;
9607 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9608 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9609 kern_type = KERN_TYPE_ANDROIDFDE;
9610 dgst_size = DGST_SIZE_4_4;
9611 parse_func = androidfde_parse_hash;
9612 sort_by_digest = sort_by_digest_4_4;
9613 opti_type = OPTI_TYPE_ZERO_BYTE;
9614 dgst_pos0 = 0;
9615 dgst_pos1 = 1;
9616 dgst_pos2 = 2;
9617 dgst_pos3 = 3;
9618 break;
9619
9620 case 8900: hash_type = HASH_TYPE_SCRYPT;
9621 salt_type = SALT_TYPE_EMBEDDED;
9622 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9623 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9624 kern_type = KERN_TYPE_SCRYPT;
9625 dgst_size = DGST_SIZE_4_8;
9626 parse_func = scrypt_parse_hash;
9627 sort_by_digest = sort_by_digest_4_8;
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 9000: hash_type = HASH_TYPE_SHA1;
9636 salt_type = SALT_TYPE_EMBEDDED;
9637 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9638 opts_type = OPTS_TYPE_PT_GENERATE_LE
9639 | OPTS_TYPE_ST_GENERATE_LE;
9640 kern_type = KERN_TYPE_PSAFE2;
9641 dgst_size = DGST_SIZE_4_5;
9642 parse_func = psafe2_parse_hash;
9643 sort_by_digest = sort_by_digest_4_5;
9644 opti_type = OPTI_TYPE_ZERO_BYTE;
9645 dgst_pos0 = 0;
9646 dgst_pos1 = 1;
9647 dgst_pos2 = 2;
9648 dgst_pos3 = 3;
9649 break;
9650
9651 case 9100: hash_type = HASH_TYPE_LOTUS8;
9652 salt_type = SALT_TYPE_EMBEDDED;
9653 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9654 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9655 kern_type = KERN_TYPE_LOTUS8;
9656 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9657 parse_func = lotus8_parse_hash;
9658 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9659 opti_type = OPTI_TYPE_ZERO_BYTE;
9660 dgst_pos0 = 0;
9661 dgst_pos1 = 1;
9662 dgst_pos2 = 2;
9663 dgst_pos3 = 3;
9664 break;
9665
9666 case 9200: hash_type = HASH_TYPE_SHA256;
9667 salt_type = SALT_TYPE_EMBEDDED;
9668 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9669 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9670 kern_type = KERN_TYPE_PBKDF2_SHA256;
9671 dgst_size = DGST_SIZE_4_32;
9672 parse_func = cisco8_parse_hash;
9673 sort_by_digest = sort_by_digest_4_32;
9674 opti_type = OPTI_TYPE_ZERO_BYTE
9675 | OPTI_TYPE_SLOW_HASH_SIMD;
9676 dgst_pos0 = 0;
9677 dgst_pos1 = 1;
9678 dgst_pos2 = 2;
9679 dgst_pos3 = 3;
9680 break;
9681
9682 case 9300: hash_type = HASH_TYPE_SCRYPT;
9683 salt_type = SALT_TYPE_EMBEDDED;
9684 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9685 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9686 kern_type = KERN_TYPE_SCRYPT;
9687 dgst_size = DGST_SIZE_4_8;
9688 parse_func = cisco9_parse_hash;
9689 sort_by_digest = sort_by_digest_4_8;
9690 opti_type = OPTI_TYPE_ZERO_BYTE;
9691 dgst_pos0 = 0;
9692 dgst_pos1 = 1;
9693 dgst_pos2 = 2;
9694 dgst_pos3 = 3;
9695 break;
9696
9697 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9698 salt_type = SALT_TYPE_EMBEDDED;
9699 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9700 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9701 kern_type = KERN_TYPE_OFFICE2007;
9702 dgst_size = DGST_SIZE_4_4;
9703 parse_func = office2007_parse_hash;
9704 sort_by_digest = sort_by_digest_4_4;
9705 opti_type = OPTI_TYPE_ZERO_BYTE;
9706 dgst_pos0 = 0;
9707 dgst_pos1 = 1;
9708 dgst_pos2 = 2;
9709 dgst_pos3 = 3;
9710 break;
9711
9712 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9713 salt_type = SALT_TYPE_EMBEDDED;
9714 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9715 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9716 kern_type = KERN_TYPE_OFFICE2010;
9717 dgst_size = DGST_SIZE_4_4;
9718 parse_func = office2010_parse_hash;
9719 sort_by_digest = sort_by_digest_4_4;
9720 opti_type = OPTI_TYPE_ZERO_BYTE;
9721 dgst_pos0 = 0;
9722 dgst_pos1 = 1;
9723 dgst_pos2 = 2;
9724 dgst_pos3 = 3;
9725 break;
9726
9727 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9728 salt_type = SALT_TYPE_EMBEDDED;
9729 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9730 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9731 kern_type = KERN_TYPE_OFFICE2013;
9732 dgst_size = DGST_SIZE_4_4;
9733 parse_func = office2013_parse_hash;
9734 sort_by_digest = sort_by_digest_4_4;
9735 opti_type = OPTI_TYPE_ZERO_BYTE;
9736 dgst_pos0 = 0;
9737 dgst_pos1 = 1;
9738 dgst_pos2 = 2;
9739 dgst_pos3 = 3;
9740 break;
9741
9742 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9743 salt_type = SALT_TYPE_EMBEDDED;
9744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9745 opts_type = OPTS_TYPE_PT_GENERATE_LE
9746 | OPTS_TYPE_PT_ADD80
9747 | OPTS_TYPE_PT_UNICODE;
9748 kern_type = KERN_TYPE_OLDOFFICE01;
9749 dgst_size = DGST_SIZE_4_4;
9750 parse_func = oldoffice01_parse_hash;
9751 sort_by_digest = sort_by_digest_4_4;
9752 opti_type = OPTI_TYPE_ZERO_BYTE
9753 | OPTI_TYPE_PRECOMPUTE_INIT
9754 | OPTI_TYPE_NOT_ITERATED;
9755 dgst_pos0 = 0;
9756 dgst_pos1 = 1;
9757 dgst_pos2 = 2;
9758 dgst_pos3 = 3;
9759 break;
9760
9761 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9762 salt_type = SALT_TYPE_EMBEDDED;
9763 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9764 opts_type = OPTS_TYPE_PT_GENERATE_LE
9765 | OPTS_TYPE_PT_ADD80;
9766 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9767 dgst_size = DGST_SIZE_4_4;
9768 parse_func = oldoffice01cm1_parse_hash;
9769 sort_by_digest = sort_by_digest_4_4;
9770 opti_type = OPTI_TYPE_ZERO_BYTE
9771 | OPTI_TYPE_PRECOMPUTE_INIT
9772 | OPTI_TYPE_NOT_ITERATED;
9773 dgst_pos0 = 0;
9774 dgst_pos1 = 1;
9775 dgst_pos2 = 2;
9776 dgst_pos3 = 3;
9777 break;
9778
9779 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9780 salt_type = SALT_TYPE_EMBEDDED;
9781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9782 opts_type = OPTS_TYPE_PT_GENERATE_LE
9783 | OPTS_TYPE_PT_ADD80
9784 | OPTS_TYPE_PT_UNICODE
9785 | OPTS_TYPE_PT_NEVERCRACK;
9786 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9787 dgst_size = DGST_SIZE_4_4;
9788 parse_func = oldoffice01cm2_parse_hash;
9789 sort_by_digest = sort_by_digest_4_4;
9790 opti_type = OPTI_TYPE_ZERO_BYTE
9791 | OPTI_TYPE_PRECOMPUTE_INIT
9792 | OPTI_TYPE_NOT_ITERATED;
9793 dgst_pos0 = 0;
9794 dgst_pos1 = 1;
9795 dgst_pos2 = 2;
9796 dgst_pos3 = 3;
9797 break;
9798
9799 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9800 salt_type = SALT_TYPE_EMBEDDED;
9801 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9802 opts_type = OPTS_TYPE_PT_GENERATE_BE
9803 | OPTS_TYPE_PT_ADD80
9804 | OPTS_TYPE_PT_UNICODE;
9805 kern_type = KERN_TYPE_OLDOFFICE34;
9806 dgst_size = DGST_SIZE_4_4;
9807 parse_func = oldoffice34_parse_hash;
9808 sort_by_digest = sort_by_digest_4_4;
9809 opti_type = OPTI_TYPE_ZERO_BYTE
9810 | OPTI_TYPE_PRECOMPUTE_INIT
9811 | OPTI_TYPE_NOT_ITERATED;
9812 dgst_pos0 = 0;
9813 dgst_pos1 = 1;
9814 dgst_pos2 = 2;
9815 dgst_pos3 = 3;
9816 break;
9817
9818 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9819 salt_type = SALT_TYPE_EMBEDDED;
9820 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9821 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9822 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9823 dgst_size = DGST_SIZE_4_4;
9824 parse_func = oldoffice34cm1_parse_hash;
9825 sort_by_digest = sort_by_digest_4_4;
9826 opti_type = OPTI_TYPE_ZERO_BYTE
9827 | OPTI_TYPE_PRECOMPUTE_INIT
9828 | OPTI_TYPE_NOT_ITERATED;
9829 dgst_pos0 = 0;
9830 dgst_pos1 = 1;
9831 dgst_pos2 = 2;
9832 dgst_pos3 = 3;
9833 break;
9834
9835 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9836 salt_type = SALT_TYPE_EMBEDDED;
9837 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9838 opts_type = OPTS_TYPE_PT_GENERATE_BE
9839 | OPTS_TYPE_PT_ADD80
9840 | OPTS_TYPE_PT_UNICODE
9841 | OPTS_TYPE_PT_NEVERCRACK;
9842 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9843 dgst_size = DGST_SIZE_4_4;
9844 parse_func = oldoffice34cm2_parse_hash;
9845 sort_by_digest = sort_by_digest_4_4;
9846 opti_type = OPTI_TYPE_ZERO_BYTE
9847 | OPTI_TYPE_PRECOMPUTE_INIT
9848 | OPTI_TYPE_NOT_ITERATED;
9849 dgst_pos0 = 0;
9850 dgst_pos1 = 1;
9851 dgst_pos2 = 2;
9852 dgst_pos3 = 3;
9853 break;
9854
9855 case 9900: hash_type = HASH_TYPE_MD5;
9856 salt_type = SALT_TYPE_NONE;
9857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9858 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9859 kern_type = KERN_TYPE_RADMIN2;
9860 dgst_size = DGST_SIZE_4_4;
9861 parse_func = radmin2_parse_hash;
9862 sort_by_digest = sort_by_digest_4_4;
9863 opti_type = OPTI_TYPE_ZERO_BYTE
9864 | OPTI_TYPE_PRECOMPUTE_INIT
9865 | OPTI_TYPE_EARLY_SKIP
9866 | OPTI_TYPE_NOT_ITERATED
9867 | OPTI_TYPE_NOT_SALTED;
9868 dgst_pos0 = 0;
9869 dgst_pos1 = 3;
9870 dgst_pos2 = 2;
9871 dgst_pos3 = 1;
9872 break;
9873
9874 case 10000: hash_type = HASH_TYPE_SHA256;
9875 salt_type = SALT_TYPE_EMBEDDED;
9876 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9877 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9878 kern_type = KERN_TYPE_PBKDF2_SHA256;
9879 dgst_size = DGST_SIZE_4_32;
9880 parse_func = djangopbkdf2_parse_hash;
9881 sort_by_digest = sort_by_digest_4_32;
9882 opti_type = OPTI_TYPE_ZERO_BYTE
9883 | OPTI_TYPE_SLOW_HASH_SIMD;
9884 dgst_pos0 = 0;
9885 dgst_pos1 = 1;
9886 dgst_pos2 = 2;
9887 dgst_pos3 = 3;
9888 break;
9889
9890 case 10100: hash_type = HASH_TYPE_SIPHASH;
9891 salt_type = SALT_TYPE_EMBEDDED;
9892 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9893 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9894 kern_type = KERN_TYPE_SIPHASH;
9895 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9896 parse_func = siphash_parse_hash;
9897 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9898 opti_type = OPTI_TYPE_ZERO_BYTE
9899 | OPTI_TYPE_NOT_ITERATED
9900 | OPTI_TYPE_RAW_HASH;
9901 dgst_pos0 = 0;
9902 dgst_pos1 = 1;
9903 dgst_pos2 = 2;
9904 dgst_pos3 = 3;
9905 break;
9906
9907 case 10200: hash_type = HASH_TYPE_MD5;
9908 salt_type = SALT_TYPE_EMBEDDED;
9909 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9910 opts_type = OPTS_TYPE_PT_GENERATE_LE
9911 | OPTS_TYPE_ST_ADD80
9912 | OPTS_TYPE_ST_ADDBITS14;
9913 kern_type = KERN_TYPE_HMACMD5_PW;
9914 dgst_size = DGST_SIZE_4_4;
9915 parse_func = crammd5_parse_hash;
9916 sort_by_digest = sort_by_digest_4_4;
9917 opti_type = OPTI_TYPE_ZERO_BYTE
9918 | OPTI_TYPE_NOT_ITERATED;
9919 dgst_pos0 = 0;
9920 dgst_pos1 = 3;
9921 dgst_pos2 = 2;
9922 dgst_pos3 = 1;
9923 break;
9924
9925 case 10300: hash_type = HASH_TYPE_SHA1;
9926 salt_type = SALT_TYPE_EMBEDDED;
9927 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9928 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9929 kern_type = KERN_TYPE_SAPH_SHA1;
9930 dgst_size = DGST_SIZE_4_5;
9931 parse_func = saph_sha1_parse_hash;
9932 sort_by_digest = sort_by_digest_4_5;
9933 opti_type = OPTI_TYPE_ZERO_BYTE;
9934 dgst_pos0 = 0;
9935 dgst_pos1 = 1;
9936 dgst_pos2 = 2;
9937 dgst_pos3 = 3;
9938 break;
9939
9940 case 10400: 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_PDF11;
9945 dgst_size = DGST_SIZE_4_4;
9946 parse_func = pdf11_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 10410: 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_PDF11CM1;
9961 dgst_size = DGST_SIZE_4_4;
9962 parse_func = pdf11cm1_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 10420: hash_type = HASH_TYPE_PDFU16;
9973 salt_type = SALT_TYPE_EMBEDDED;
9974 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9975 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9976 kern_type = KERN_TYPE_PDF11CM2;
9977 dgst_size = DGST_SIZE_4_4;
9978 parse_func = pdf11cm2_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 10500: hash_type = HASH_TYPE_PDFU16;
9989 salt_type = SALT_TYPE_EMBEDDED;
9990 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9991 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9992 kern_type = KERN_TYPE_PDF14;
9993 dgst_size = DGST_SIZE_4_4;
9994 parse_func = pdf14_parse_hash;
9995 sort_by_digest = sort_by_digest_4_4;
9996 opti_type = OPTI_TYPE_ZERO_BYTE
9997 | OPTI_TYPE_NOT_ITERATED;
9998 dgst_pos0 = 0;
9999 dgst_pos1 = 1;
10000 dgst_pos2 = 2;
10001 dgst_pos3 = 3;
10002 break;
10003
10004 case 10600: hash_type = HASH_TYPE_SHA256;
10005 salt_type = SALT_TYPE_EMBEDDED;
10006 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10007 opts_type = OPTS_TYPE_PT_GENERATE_BE
10008 | OPTS_TYPE_ST_ADD80
10009 | OPTS_TYPE_ST_ADDBITS15
10010 | OPTS_TYPE_HASH_COPY;
10011 kern_type = KERN_TYPE_SHA256_PWSLT;
10012 dgst_size = DGST_SIZE_4_8;
10013 parse_func = pdf17l3_parse_hash;
10014 sort_by_digest = sort_by_digest_4_8;
10015 opti_type = OPTI_TYPE_ZERO_BYTE
10016 | OPTI_TYPE_PRECOMPUTE_INIT
10017 | OPTI_TYPE_PRECOMPUTE_MERKLE
10018 | OPTI_TYPE_EARLY_SKIP
10019 | OPTI_TYPE_NOT_ITERATED
10020 | OPTI_TYPE_APPENDED_SALT
10021 | OPTI_TYPE_RAW_HASH;
10022 dgst_pos0 = 3;
10023 dgst_pos1 = 7;
10024 dgst_pos2 = 2;
10025 dgst_pos3 = 6;
10026 break;
10027
10028 case 10700: hash_type = HASH_TYPE_PDFU32;
10029 salt_type = SALT_TYPE_EMBEDDED;
10030 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10031 opts_type = OPTS_TYPE_PT_GENERATE_LE
10032 | OPTS_TYPE_HASH_COPY;
10033 kern_type = KERN_TYPE_PDF17L8;
10034 dgst_size = DGST_SIZE_4_8;
10035 parse_func = pdf17l8_parse_hash;
10036 sort_by_digest = sort_by_digest_4_8;
10037 opti_type = OPTI_TYPE_ZERO_BYTE
10038 | OPTI_TYPE_NOT_ITERATED;
10039 dgst_pos0 = 0;
10040 dgst_pos1 = 1;
10041 dgst_pos2 = 2;
10042 dgst_pos3 = 3;
10043 break;
10044
10045 case 10800: hash_type = HASH_TYPE_SHA384;
10046 salt_type = SALT_TYPE_NONE;
10047 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10048 opts_type = OPTS_TYPE_PT_GENERATE_BE
10049 | OPTS_TYPE_PT_ADD80
10050 | OPTS_TYPE_PT_ADDBITS15;
10051 kern_type = KERN_TYPE_SHA384;
10052 dgst_size = DGST_SIZE_8_8;
10053 parse_func = sha384_parse_hash;
10054 sort_by_digest = sort_by_digest_8_8;
10055 opti_type = OPTI_TYPE_ZERO_BYTE
10056 | OPTI_TYPE_PRECOMPUTE_INIT
10057 | OPTI_TYPE_PRECOMPUTE_MERKLE
10058 | OPTI_TYPE_EARLY_SKIP
10059 | OPTI_TYPE_NOT_ITERATED
10060 | OPTI_TYPE_NOT_SALTED
10061 | OPTI_TYPE_USES_BITS_64
10062 | OPTI_TYPE_RAW_HASH;
10063 dgst_pos0 = 6;
10064 dgst_pos1 = 7;
10065 dgst_pos2 = 4;
10066 dgst_pos3 = 5;
10067 break;
10068
10069 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10070 salt_type = SALT_TYPE_EMBEDDED;
10071 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10072 opts_type = OPTS_TYPE_PT_GENERATE_LE
10073 | OPTS_TYPE_ST_BASE64
10074 | OPTS_TYPE_HASH_COPY;
10075 kern_type = KERN_TYPE_PBKDF2_SHA256;
10076 dgst_size = DGST_SIZE_4_32;
10077 parse_func = pbkdf2_sha256_parse_hash;
10078 sort_by_digest = sort_by_digest_4_32;
10079 opti_type = OPTI_TYPE_ZERO_BYTE
10080 | OPTI_TYPE_SLOW_HASH_SIMD;
10081 dgst_pos0 = 0;
10082 dgst_pos1 = 1;
10083 dgst_pos2 = 2;
10084 dgst_pos3 = 3;
10085 break;
10086
10087 case 11000: hash_type = HASH_TYPE_MD5;
10088 salt_type = SALT_TYPE_INTERN;
10089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10090 opts_type = OPTS_TYPE_PT_GENERATE_LE
10091 | OPTS_TYPE_PT_ADD80;
10092 kern_type = KERN_TYPE_PRESTASHOP;
10093 dgst_size = DGST_SIZE_4_4;
10094 parse_func = prestashop_parse_hash;
10095 sort_by_digest = sort_by_digest_4_4;
10096 opti_type = OPTI_TYPE_ZERO_BYTE
10097 | OPTI_TYPE_PRECOMPUTE_INIT
10098 | OPTI_TYPE_NOT_ITERATED
10099 | OPTI_TYPE_PREPENDED_SALT;
10100 dgst_pos0 = 0;
10101 dgst_pos1 = 3;
10102 dgst_pos2 = 2;
10103 dgst_pos3 = 1;
10104 break;
10105
10106 case 11100: hash_type = HASH_TYPE_MD5;
10107 salt_type = SALT_TYPE_EMBEDDED;
10108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10109 opts_type = OPTS_TYPE_PT_GENERATE_LE
10110 | OPTS_TYPE_ST_ADD80;
10111 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10112 dgst_size = DGST_SIZE_4_4;
10113 parse_func = postgresql_auth_parse_hash;
10114 sort_by_digest = sort_by_digest_4_4;
10115 opti_type = OPTI_TYPE_ZERO_BYTE
10116 | OPTI_TYPE_PRECOMPUTE_INIT
10117 | OPTI_TYPE_PRECOMPUTE_MERKLE
10118 | OPTI_TYPE_EARLY_SKIP;
10119 dgst_pos0 = 0;
10120 dgst_pos1 = 3;
10121 dgst_pos2 = 2;
10122 dgst_pos3 = 1;
10123 break;
10124
10125 case 11200: hash_type = HASH_TYPE_SHA1;
10126 salt_type = SALT_TYPE_EMBEDDED;
10127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10128 opts_type = OPTS_TYPE_PT_GENERATE_BE
10129 | OPTS_TYPE_PT_ADD80
10130 | OPTS_TYPE_ST_HEX;
10131 kern_type = KERN_TYPE_MYSQL_AUTH;
10132 dgst_size = DGST_SIZE_4_5;
10133 parse_func = mysql_auth_parse_hash;
10134 sort_by_digest = sort_by_digest_4_5;
10135 opti_type = OPTI_TYPE_ZERO_BYTE
10136 | OPTI_TYPE_EARLY_SKIP;
10137 dgst_pos0 = 3;
10138 dgst_pos1 = 4;
10139 dgst_pos2 = 2;
10140 dgst_pos3 = 1;
10141 break;
10142
10143 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10144 salt_type = SALT_TYPE_EMBEDDED;
10145 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10146 opts_type = OPTS_TYPE_PT_GENERATE_LE
10147 | OPTS_TYPE_ST_HEX
10148 | OPTS_TYPE_ST_ADD80;
10149 kern_type = KERN_TYPE_BITCOIN_WALLET;
10150 dgst_size = DGST_SIZE_4_4;
10151 parse_func = bitcoin_wallet_parse_hash;
10152 sort_by_digest = sort_by_digest_4_4;
10153 opti_type = OPTI_TYPE_ZERO_BYTE;
10154 dgst_pos0 = 0;
10155 dgst_pos1 = 1;
10156 dgst_pos2 = 2;
10157 dgst_pos3 = 3;
10158 break;
10159
10160 case 11400: hash_type = HASH_TYPE_MD5;
10161 salt_type = SALT_TYPE_EMBEDDED;
10162 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10163 opts_type = OPTS_TYPE_PT_GENERATE_LE
10164 | OPTS_TYPE_PT_ADD80
10165 | OPTS_TYPE_HASH_COPY;
10166 kern_type = KERN_TYPE_SIP_AUTH;
10167 dgst_size = DGST_SIZE_4_4;
10168 parse_func = sip_auth_parse_hash;
10169 sort_by_digest = sort_by_digest_4_4;
10170 opti_type = OPTI_TYPE_ZERO_BYTE;
10171 dgst_pos0 = 0;
10172 dgst_pos1 = 3;
10173 dgst_pos2 = 2;
10174 dgst_pos3 = 1;
10175 break;
10176
10177 case 11500: hash_type = HASH_TYPE_CRC32;
10178 salt_type = SALT_TYPE_INTERN;
10179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10180 opts_type = OPTS_TYPE_PT_GENERATE_LE
10181 | OPTS_TYPE_ST_GENERATE_LE
10182 | OPTS_TYPE_ST_HEX;
10183 kern_type = KERN_TYPE_CRC32;
10184 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10185 parse_func = crc32_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 11600: hash_type = HASH_TYPE_AES;
10195 salt_type = SALT_TYPE_EMBEDDED;
10196 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10197 opts_type = OPTS_TYPE_PT_GENERATE_LE
10198 | OPTS_TYPE_PT_NEVERCRACK;
10199 kern_type = KERN_TYPE_SEVEN_ZIP;
10200 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10201 parse_func = seven_zip_parse_hash;
10202 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
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 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
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_256;
10216 dgst_size = DGST_SIZE_4_8;
10217 parse_func = gost2012sbog_256_parse_hash;
10218 sort_by_digest = sort_by_digest_4_8;
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 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10227 salt_type = SALT_TYPE_NONE;
10228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10229 opts_type = OPTS_TYPE_PT_GENERATE_LE
10230 | OPTS_TYPE_PT_ADD01;
10231 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10232 dgst_size = DGST_SIZE_4_16;
10233 parse_func = gost2012sbog_512_parse_hash;
10234 sort_by_digest = sort_by_digest_4_16;
10235 opti_type = OPTI_TYPE_ZERO_BYTE;
10236 dgst_pos0 = 0;
10237 dgst_pos1 = 1;
10238 dgst_pos2 = 2;
10239 dgst_pos3 = 3;
10240 break;
10241
10242 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10243 salt_type = SALT_TYPE_EMBEDDED;
10244 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10245 opts_type = OPTS_TYPE_PT_GENERATE_LE
10246 | OPTS_TYPE_ST_BASE64
10247 | OPTS_TYPE_HASH_COPY;
10248 kern_type = KERN_TYPE_PBKDF2_MD5;
10249 dgst_size = DGST_SIZE_4_32;
10250 parse_func = pbkdf2_md5_parse_hash;
10251 sort_by_digest = sort_by_digest_4_32;
10252 opti_type = OPTI_TYPE_ZERO_BYTE
10253 | OPTI_TYPE_SLOW_HASH_SIMD;
10254 dgst_pos0 = 0;
10255 dgst_pos1 = 1;
10256 dgst_pos2 = 2;
10257 dgst_pos3 = 3;
10258 break;
10259
10260 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10261 salt_type = SALT_TYPE_EMBEDDED;
10262 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10263 opts_type = OPTS_TYPE_PT_GENERATE_LE
10264 | OPTS_TYPE_ST_BASE64
10265 | OPTS_TYPE_HASH_COPY;
10266 kern_type = KERN_TYPE_PBKDF2_SHA1;
10267 dgst_size = DGST_SIZE_4_32;
10268 parse_func = pbkdf2_sha1_parse_hash;
10269 sort_by_digest = sort_by_digest_4_32;
10270 opti_type = OPTI_TYPE_ZERO_BYTE
10271 | OPTI_TYPE_SLOW_HASH_SIMD;
10272 dgst_pos0 = 0;
10273 dgst_pos1 = 1;
10274 dgst_pos2 = 2;
10275 dgst_pos3 = 3;
10276 break;
10277
10278 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10279 salt_type = SALT_TYPE_EMBEDDED;
10280 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10281 opts_type = OPTS_TYPE_PT_GENERATE_LE
10282 | OPTS_TYPE_ST_BASE64
10283 | OPTS_TYPE_HASH_COPY;
10284 kern_type = KERN_TYPE_PBKDF2_SHA512;
10285 dgst_size = DGST_SIZE_8_16;
10286 parse_func = pbkdf2_sha512_parse_hash;
10287 sort_by_digest = sort_by_digest_8_16;
10288 opti_type = OPTI_TYPE_ZERO_BYTE
10289 | OPTI_TYPE_USES_BITS_64
10290 | OPTI_TYPE_SLOW_HASH_SIMD;
10291 dgst_pos0 = 0;
10292 dgst_pos1 = 1;
10293 dgst_pos2 = 2;
10294 dgst_pos3 = 3;
10295 break;
10296
10297 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
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_ECRYPTFS;
10302 dgst_size = DGST_SIZE_8_8;
10303 parse_func = ecryptfs_parse_hash;
10304 sort_by_digest = sort_by_digest_8_8;
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 12300: hash_type = HASH_TYPE_ORACLET;
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_ORACLET;
10318 dgst_size = DGST_SIZE_8_16;
10319 parse_func = oraclet_parse_hash;
10320 sort_by_digest = sort_by_digest_8_16;
10321 opti_type = OPTI_TYPE_ZERO_BYTE
10322 | OPTI_TYPE_USES_BITS_64;
10323 dgst_pos0 = 0;
10324 dgst_pos1 = 1;
10325 dgst_pos2 = 2;
10326 dgst_pos3 = 3;
10327 break;
10328
10329 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
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_BSDICRYPT;
10334 dgst_size = DGST_SIZE_4_4;
10335 parse_func = bsdicrypt_parse_hash;
10336 sort_by_digest = sort_by_digest_4_4;
10337 opti_type = OPTI_TYPE_ZERO_BYTE
10338 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10339 dgst_pos0 = 0;
10340 dgst_pos1 = 1;
10341 dgst_pos2 = 2;
10342 dgst_pos3 = 3;
10343 break;
10344
10345 case 12500: hash_type = HASH_TYPE_RAR3HP;
10346 salt_type = SALT_TYPE_EMBEDDED;
10347 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10348 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10349 kern_type = KERN_TYPE_RAR3;
10350 dgst_size = DGST_SIZE_4_4;
10351 parse_func = rar3hp_parse_hash;
10352 sort_by_digest = sort_by_digest_4_4;
10353 opti_type = OPTI_TYPE_ZERO_BYTE;
10354 dgst_pos0 = 0;
10355 dgst_pos1 = 1;
10356 dgst_pos2 = 2;
10357 dgst_pos3 = 3;
10358 break;
10359
10360 case 12600: hash_type = HASH_TYPE_SHA256;
10361 salt_type = SALT_TYPE_INTERN;
10362 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10363 opts_type = OPTS_TYPE_PT_GENERATE_BE
10364 | OPTS_TYPE_PT_ADD80;
10365 kern_type = KERN_TYPE_CF10;
10366 dgst_size = DGST_SIZE_4_8;
10367 parse_func = cf10_parse_hash;
10368 sort_by_digest = sort_by_digest_4_8;
10369 opti_type = OPTI_TYPE_ZERO_BYTE
10370 | OPTI_TYPE_PRECOMPUTE_INIT
10371 | OPTI_TYPE_EARLY_SKIP
10372 | OPTI_TYPE_NOT_ITERATED;
10373 dgst_pos0 = 3;
10374 dgst_pos1 = 7;
10375 dgst_pos2 = 2;
10376 dgst_pos3 = 6;
10377 break;
10378
10379 case 12700: hash_type = HASH_TYPE_AES;
10380 salt_type = SALT_TYPE_EMBEDDED;
10381 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10382 opts_type = OPTS_TYPE_PT_GENERATE_LE
10383 | OPTS_TYPE_HASH_COPY;
10384 kern_type = KERN_TYPE_MYWALLET;
10385 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10386 parse_func = mywallet_parse_hash;
10387 sort_by_digest = sort_by_digest_4_5;
10388 opti_type = OPTI_TYPE_ZERO_BYTE;
10389 dgst_pos0 = 0;
10390 dgst_pos1 = 1;
10391 dgst_pos2 = 2;
10392 dgst_pos3 = 3;
10393 break;
10394
10395 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10396 salt_type = SALT_TYPE_EMBEDDED;
10397 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10398 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10399 kern_type = KERN_TYPE_MS_DRSR;
10400 dgst_size = DGST_SIZE_4_8;
10401 parse_func = ms_drsr_parse_hash;
10402 sort_by_digest = sort_by_digest_4_8;
10403 opti_type = OPTI_TYPE_ZERO_BYTE;
10404 dgst_pos0 = 0;
10405 dgst_pos1 = 1;
10406 dgst_pos2 = 2;
10407 dgst_pos3 = 3;
10408 break;
10409
10410 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10411 salt_type = SALT_TYPE_EMBEDDED;
10412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10413 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10414 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10415 dgst_size = DGST_SIZE_4_8;
10416 parse_func = androidfde_samsung_parse_hash;
10417 sort_by_digest = sort_by_digest_4_8;
10418 opti_type = OPTI_TYPE_ZERO_BYTE;
10419 dgst_pos0 = 0;
10420 dgst_pos1 = 1;
10421 dgst_pos2 = 2;
10422 dgst_pos3 = 3;
10423 break;
10424
10425 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10426 salt_type = SALT_TYPE_EMBEDDED;
10427 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10428 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10429 kern_type = KERN_TYPE_RAR5;
10430 dgst_size = DGST_SIZE_4_4;
10431 parse_func = rar5_parse_hash;
10432 sort_by_digest = sort_by_digest_4_4;
10433 opti_type = OPTI_TYPE_ZERO_BYTE;
10434 dgst_pos0 = 0;
10435 dgst_pos1 = 1;
10436 dgst_pos2 = 2;
10437 dgst_pos3 = 3;
10438 break;
10439
10440 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10441 salt_type = SALT_TYPE_EMBEDDED;
10442 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10443 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10444 kern_type = KERN_TYPE_KRB5TGS;
10445 dgst_size = DGST_SIZE_4_4;
10446 parse_func = krb5tgs_parse_hash;
10447 sort_by_digest = sort_by_digest_4_4;
10448 opti_type = OPTI_TYPE_ZERO_BYTE
10449 | OPTI_TYPE_NOT_ITERATED;
10450 dgst_pos0 = 0;
10451 dgst_pos1 = 1;
10452 dgst_pos2 = 2;
10453 dgst_pos3 = 3;
10454 break;
10455
10456 case 13200: hash_type = HASH_TYPE_AES;
10457 salt_type = SALT_TYPE_EMBEDDED;
10458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10459 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10460 kern_type = KERN_TYPE_AXCRYPT;
10461 dgst_size = DGST_SIZE_4_4;
10462 parse_func = axcrypt_parse_hash;
10463 sort_by_digest = sort_by_digest_4_4;
10464 opti_type = OPTI_TYPE_ZERO_BYTE;
10465 dgst_pos0 = 0;
10466 dgst_pos1 = 1;
10467 dgst_pos2 = 2;
10468 dgst_pos3 = 3;
10469 break;
10470
10471 case 13300: hash_type = HASH_TYPE_SHA1;
10472 salt_type = SALT_TYPE_NONE;
10473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10474 opts_type = OPTS_TYPE_PT_GENERATE_BE
10475 | OPTS_TYPE_PT_ADD80
10476 | OPTS_TYPE_PT_ADDBITS15;
10477 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10478 dgst_size = DGST_SIZE_4_5;
10479 parse_func = sha1axcrypt_parse_hash;
10480 sort_by_digest = sort_by_digest_4_5;
10481 opti_type = OPTI_TYPE_ZERO_BYTE
10482 | OPTI_TYPE_PRECOMPUTE_INIT
10483 | OPTI_TYPE_EARLY_SKIP
10484 | OPTI_TYPE_NOT_ITERATED
10485 | OPTI_TYPE_NOT_SALTED;
10486 dgst_pos0 = 0;
10487 dgst_pos1 = 4;
10488 dgst_pos2 = 3;
10489 dgst_pos3 = 2;
10490 break;
10491
10492 case 13400: hash_type = HASH_TYPE_AES;
10493 salt_type = SALT_TYPE_EMBEDDED;
10494 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10495 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10496 kern_type = KERN_TYPE_KEEPASS;
10497 dgst_size = DGST_SIZE_4_4;
10498 parse_func = keepass_parse_hash;
10499 sort_by_digest = sort_by_digest_4_4;
10500 opti_type = OPTI_TYPE_ZERO_BYTE;
10501 dgst_pos0 = 0;
10502 dgst_pos1 = 1;
10503 dgst_pos2 = 2;
10504 dgst_pos3 = 3;
10505 break;
10506
10507 case 13500: hash_type = HASH_TYPE_SHA1;
10508 salt_type = SALT_TYPE_EMBEDDED;
10509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10510 opts_type = OPTS_TYPE_PT_GENERATE_BE
10511 | OPTS_TYPE_PT_UNICODE
10512 | OPTS_TYPE_PT_ADD80;
10513 kern_type = KERN_TYPE_PSTOKEN;
10514 dgst_size = DGST_SIZE_4_5;
10515 parse_func = pstoken_parse_hash;
10516 sort_by_digest = sort_by_digest_4_5;
10517 opti_type = OPTI_TYPE_ZERO_BYTE
10518 | OPTI_TYPE_PRECOMPUTE_INIT
10519 | OPTI_TYPE_EARLY_SKIP
10520 | OPTI_TYPE_NOT_ITERATED
10521 | OPTI_TYPE_PREPENDED_SALT
10522 | OPTI_TYPE_RAW_HASH;
10523 dgst_pos0 = 3;
10524 dgst_pos1 = 4;
10525 dgst_pos2 = 2;
10526 dgst_pos3 = 1;
10527 break;
10528
10529 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10530 salt_type = SALT_TYPE_EMBEDDED;
10531 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10532 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10533 kern_type = KERN_TYPE_ZIP2;
10534 dgst_size = DGST_SIZE_4_4;
10535 parse_func = zip2_parse_hash;
10536 sort_by_digest = sort_by_digest_4_4;
10537 opti_type = OPTI_TYPE_ZERO_BYTE;
10538 dgst_pos0 = 0;
10539 dgst_pos1 = 1;
10540 dgst_pos2 = 2;
10541 dgst_pos3 = 3;
10542 break;
10543
10544 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10545 salt_type = SALT_TYPE_EMBEDDED;
10546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10547 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10548 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10549 dgst_size = DGST_SIZE_4_5;
10550 parse_func = veracrypt_parse_hash_655331;
10551 sort_by_digest = sort_by_digest_4_5;
10552 opti_type = OPTI_TYPE_ZERO_BYTE;
10553 dgst_pos0 = 0;
10554 dgst_pos1 = 1;
10555 dgst_pos2 = 2;
10556 dgst_pos3 = 3;
10557 break;
10558
10559 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10560 salt_type = SALT_TYPE_EMBEDDED;
10561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10562 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10563 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10564 dgst_size = DGST_SIZE_4_5;
10565 parse_func = veracrypt_parse_hash_655331;
10566 sort_by_digest = sort_by_digest_4_5;
10567 opti_type = OPTI_TYPE_ZERO_BYTE;
10568 dgst_pos0 = 0;
10569 dgst_pos1 = 1;
10570 dgst_pos2 = 2;
10571 dgst_pos3 = 3;
10572 break;
10573
10574 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10575 salt_type = SALT_TYPE_EMBEDDED;
10576 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10577 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10578 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10579 dgst_size = DGST_SIZE_4_5;
10580 parse_func = veracrypt_parse_hash_655331;
10581 sort_by_digest = sort_by_digest_4_5;
10582 opti_type = OPTI_TYPE_ZERO_BYTE;
10583 dgst_pos0 = 0;
10584 dgst_pos1 = 1;
10585 dgst_pos2 = 2;
10586 dgst_pos3 = 3;
10587 break;
10588
10589 case 13721: 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_XTS512;
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 13722: 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_XTS1024;
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 13723: hash_type = HASH_TYPE_SHA512;
10622 salt_type = SALT_TYPE_EMBEDDED;
10623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10624 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10625 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10626 dgst_size = DGST_SIZE_8_8;
10627 parse_func = veracrypt_parse_hash_500000;
10628 sort_by_digest = sort_by_digest_8_8;
10629 opti_type = OPTI_TYPE_ZERO_BYTE
10630 | OPTI_TYPE_USES_BITS_64;
10631 dgst_pos0 = 0;
10632 dgst_pos1 = 1;
10633 dgst_pos2 = 2;
10634 dgst_pos3 = 3;
10635 break;
10636
10637 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10638 salt_type = SALT_TYPE_EMBEDDED;
10639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10640 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10641 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10642 dgst_size = DGST_SIZE_4_8;
10643 parse_func = veracrypt_parse_hash_500000;
10644 sort_by_digest = sort_by_digest_4_8;
10645 opti_type = OPTI_TYPE_ZERO_BYTE;
10646 dgst_pos0 = 0;
10647 dgst_pos1 = 1;
10648 dgst_pos2 = 2;
10649 dgst_pos3 = 3;
10650 break;
10651
10652 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10653 salt_type = SALT_TYPE_EMBEDDED;
10654 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10655 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10656 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10657 dgst_size = DGST_SIZE_4_8;
10658 parse_func = veracrypt_parse_hash_500000;
10659 sort_by_digest = sort_by_digest_4_8;
10660 opti_type = OPTI_TYPE_ZERO_BYTE;
10661 dgst_pos0 = 0;
10662 dgst_pos1 = 1;
10663 dgst_pos2 = 2;
10664 dgst_pos3 = 3;
10665 break;
10666
10667 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10668 salt_type = SALT_TYPE_EMBEDDED;
10669 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10670 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10671 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10672 dgst_size = DGST_SIZE_4_8;
10673 parse_func = veracrypt_parse_hash_500000;
10674 sort_by_digest = sort_by_digest_4_8;
10675 opti_type = OPTI_TYPE_ZERO_BYTE;
10676 dgst_pos0 = 0;
10677 dgst_pos1 = 1;
10678 dgst_pos2 = 2;
10679 dgst_pos3 = 3;
10680 break;
10681
10682 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10683 salt_type = SALT_TYPE_EMBEDDED;
10684 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10685 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10686 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10687 dgst_size = DGST_SIZE_4_5;
10688 parse_func = veracrypt_parse_hash_327661;
10689 sort_by_digest = sort_by_digest_4_5;
10690 opti_type = OPTI_TYPE_ZERO_BYTE;
10691 dgst_pos0 = 0;
10692 dgst_pos1 = 1;
10693 dgst_pos2 = 2;
10694 dgst_pos3 = 3;
10695 break;
10696
10697 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10698 salt_type = SALT_TYPE_EMBEDDED;
10699 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10700 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10701 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10702 dgst_size = DGST_SIZE_4_5;
10703 parse_func = veracrypt_parse_hash_327661;
10704 sort_by_digest = sort_by_digest_4_5;
10705 opti_type = OPTI_TYPE_ZERO_BYTE;
10706 dgst_pos0 = 0;
10707 dgst_pos1 = 1;
10708 dgst_pos2 = 2;
10709 dgst_pos3 = 3;
10710 break;
10711
10712 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10713 salt_type = SALT_TYPE_EMBEDDED;
10714 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10715 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10716 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10717 dgst_size = DGST_SIZE_4_5;
10718 parse_func = veracrypt_parse_hash_327661;
10719 sort_by_digest = sort_by_digest_4_5;
10720 opti_type = OPTI_TYPE_ZERO_BYTE;
10721 dgst_pos0 = 0;
10722 dgst_pos1 = 1;
10723 dgst_pos2 = 2;
10724 dgst_pos3 = 3;
10725 break;
10726
10727 case 13751: hash_type = HASH_TYPE_SHA256;
10728 salt_type = SALT_TYPE_EMBEDDED;
10729 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10730 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10731 kern_type = KERN_TYPE_VCSHA256_XTS512;
10732 dgst_size = DGST_SIZE_4_8;
10733 parse_func = veracrypt_parse_hash_500000;
10734 sort_by_digest = sort_by_digest_4_8;
10735 opti_type = OPTI_TYPE_ZERO_BYTE;
10736 dgst_pos0 = 0;
10737 dgst_pos1 = 1;
10738 dgst_pos2 = 2;
10739 dgst_pos3 = 3;
10740 break;
10741
10742 case 13752: hash_type = HASH_TYPE_SHA256;
10743 salt_type = SALT_TYPE_EMBEDDED;
10744 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10745 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10746 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10747 dgst_size = DGST_SIZE_4_8;
10748 parse_func = veracrypt_parse_hash_500000;
10749 sort_by_digest = sort_by_digest_4_8;
10750 opti_type = OPTI_TYPE_ZERO_BYTE;
10751 dgst_pos0 = 0;
10752 dgst_pos1 = 1;
10753 dgst_pos2 = 2;
10754 dgst_pos3 = 3;
10755 break;
10756
10757 case 13753: hash_type = HASH_TYPE_SHA256;
10758 salt_type = SALT_TYPE_EMBEDDED;
10759 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10760 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10761 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10762 dgst_size = DGST_SIZE_4_8;
10763 parse_func = veracrypt_parse_hash_500000;
10764 sort_by_digest = sort_by_digest_4_8;
10765 opti_type = OPTI_TYPE_ZERO_BYTE;
10766 dgst_pos0 = 0;
10767 dgst_pos1 = 1;
10768 dgst_pos2 = 2;
10769 dgst_pos3 = 3;
10770 break;
10771
10772 case 13761: hash_type = HASH_TYPE_SHA256;
10773 salt_type = SALT_TYPE_EMBEDDED;
10774 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10775 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10776 kern_type = KERN_TYPE_VCSHA256_XTS512;
10777 dgst_size = DGST_SIZE_4_8;
10778 parse_func = veracrypt_parse_hash_200000;
10779 sort_by_digest = sort_by_digest_4_8;
10780 opti_type = OPTI_TYPE_ZERO_BYTE;
10781 dgst_pos0 = 0;
10782 dgst_pos1 = 1;
10783 dgst_pos2 = 2;
10784 dgst_pos3 = 3;
10785 break;
10786
10787 case 13762: hash_type = HASH_TYPE_SHA256;
10788 salt_type = SALT_TYPE_EMBEDDED;
10789 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10790 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10791 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10792 dgst_size = DGST_SIZE_4_8;
10793 parse_func = veracrypt_parse_hash_200000;
10794 sort_by_digest = sort_by_digest_4_8;
10795 opti_type = OPTI_TYPE_ZERO_BYTE;
10796 dgst_pos0 = 0;
10797 dgst_pos1 = 1;
10798 dgst_pos2 = 2;
10799 dgst_pos3 = 3;
10800 break;
10801
10802 case 13763: hash_type = HASH_TYPE_SHA256;
10803 salt_type = SALT_TYPE_EMBEDDED;
10804 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10805 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10806 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10807 dgst_size = DGST_SIZE_4_8;
10808 parse_func = veracrypt_parse_hash_200000;
10809 sort_by_digest = sort_by_digest_4_8;
10810 opti_type = OPTI_TYPE_ZERO_BYTE;
10811 dgst_pos0 = 0;
10812 dgst_pos1 = 1;
10813 dgst_pos2 = 2;
10814 dgst_pos3 = 3;
10815 break;
10816
10817
10818 default: usage_mini_print (PROGNAME); return (-1);
10819 }
10820
10821 /**
10822 * parser
10823 */
10824
10825 data.parse_func = parse_func;
10826
10827 /**
10828 * misc stuff
10829 */
10830
10831 if (hex_salt)
10832 {
10833 if (salt_type == SALT_TYPE_INTERN)
10834 {
10835 opts_type |= OPTS_TYPE_ST_HEX;
10836 }
10837 else
10838 {
10839 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10840
10841 return (-1);
10842 }
10843 }
10844
10845 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10846 | (salt_type == SALT_TYPE_EXTERN)
10847 | (salt_type == SALT_TYPE_EMBEDDED)
10848 | (salt_type == SALT_TYPE_VIRTUAL));
10849
10850 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10851
10852 data.hash_type = hash_type;
10853 data.attack_mode = attack_mode;
10854 data.attack_kern = attack_kern;
10855 data.attack_exec = attack_exec;
10856 data.kern_type = kern_type;
10857 data.opts_type = opts_type;
10858 data.dgst_size = dgst_size;
10859 data.salt_type = salt_type;
10860 data.isSalted = isSalted;
10861 data.sort_by_digest = sort_by_digest;
10862 data.dgst_pos0 = dgst_pos0;
10863 data.dgst_pos1 = dgst_pos1;
10864 data.dgst_pos2 = dgst_pos2;
10865 data.dgst_pos3 = dgst_pos3;
10866
10867 esalt_size = 0;
10868
10869 switch (hash_mode)
10870 {
10871 case 2500: esalt_size = sizeof (wpa_t); break;
10872 case 5300: esalt_size = sizeof (ikepsk_t); break;
10873 case 5400: esalt_size = sizeof (ikepsk_t); break;
10874 case 5500: esalt_size = sizeof (netntlm_t); break;
10875 case 5600: esalt_size = sizeof (netntlm_t); break;
10876 case 6211: esalt_size = sizeof (tc_t); break;
10877 case 6212: esalt_size = sizeof (tc_t); break;
10878 case 6213: esalt_size = sizeof (tc_t); break;
10879 case 6221: esalt_size = sizeof (tc_t); break;
10880 case 6222: esalt_size = sizeof (tc_t); break;
10881 case 6223: esalt_size = sizeof (tc_t); break;
10882 case 6231: esalt_size = sizeof (tc_t); break;
10883 case 6232: esalt_size = sizeof (tc_t); break;
10884 case 6233: esalt_size = sizeof (tc_t); break;
10885 case 6241: esalt_size = sizeof (tc_t); break;
10886 case 6242: esalt_size = sizeof (tc_t); break;
10887 case 6243: esalt_size = sizeof (tc_t); break;
10888 case 6600: esalt_size = sizeof (agilekey_t); break;
10889 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10890 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10891 case 7300: esalt_size = sizeof (rakp_t); break;
10892 case 7500: esalt_size = sizeof (krb5pa_t); break;
10893 case 8200: esalt_size = sizeof (cloudkey_t); break;
10894 case 8800: esalt_size = sizeof (androidfde_t); break;
10895 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10896 case 9400: esalt_size = sizeof (office2007_t); break;
10897 case 9500: esalt_size = sizeof (office2010_t); break;
10898 case 9600: esalt_size = sizeof (office2013_t); break;
10899 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10900 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10901 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10902 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10903 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10904 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10905 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10906 case 10200: esalt_size = sizeof (cram_md5_t); break;
10907 case 10400: esalt_size = sizeof (pdf_t); break;
10908 case 10410: esalt_size = sizeof (pdf_t); break;
10909 case 10420: esalt_size = sizeof (pdf_t); break;
10910 case 10500: esalt_size = sizeof (pdf_t); break;
10911 case 10600: esalt_size = sizeof (pdf_t); break;
10912 case 10700: esalt_size = sizeof (pdf_t); break;
10913 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10914 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10915 case 11400: esalt_size = sizeof (sip_t); break;
10916 case 11600: esalt_size = sizeof (seven_zip_t); break;
10917 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10918 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10919 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10920 case 13000: esalt_size = sizeof (rar5_t); break;
10921 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10922 case 13400: esalt_size = sizeof (keepass_t); break;
10923 case 13500: esalt_size = sizeof (pstoken_t); break;
10924 case 13600: esalt_size = sizeof (zip2_t); break;
10925 case 13711: esalt_size = sizeof (tc_t); break;
10926 case 13712: esalt_size = sizeof (tc_t); break;
10927 case 13713: esalt_size = sizeof (tc_t); break;
10928 case 13721: esalt_size = sizeof (tc_t); break;
10929 case 13722: esalt_size = sizeof (tc_t); break;
10930 case 13723: esalt_size = sizeof (tc_t); break;
10931 case 13731: esalt_size = sizeof (tc_t); break;
10932 case 13732: esalt_size = sizeof (tc_t); break;
10933 case 13733: esalt_size = sizeof (tc_t); break;
10934 case 13741: esalt_size = sizeof (tc_t); break;
10935 case 13742: esalt_size = sizeof (tc_t); break;
10936 case 13743: esalt_size = sizeof (tc_t); break;
10937 case 13751: esalt_size = sizeof (tc_t); break;
10938 case 13752: esalt_size = sizeof (tc_t); break;
10939 case 13753: esalt_size = sizeof (tc_t); break;
10940 case 13761: esalt_size = sizeof (tc_t); break;
10941 case 13762: esalt_size = sizeof (tc_t); break;
10942 case 13763: esalt_size = sizeof (tc_t); break;
10943 }
10944
10945 data.esalt_size = esalt_size;
10946
10947 /**
10948 * choose dictionary parser
10949 */
10950
10951 if (hash_type == HASH_TYPE_LM)
10952 {
10953 get_next_word_func = get_next_word_lm;
10954 }
10955 else if (opts_type & OPTS_TYPE_PT_UPPER)
10956 {
10957 get_next_word_func = get_next_word_uc;
10958 }
10959 else
10960 {
10961 get_next_word_func = get_next_word_std;
10962 }
10963
10964 /**
10965 * dictstat
10966 */
10967
10968 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10969
10970 #ifdef _POSIX
10971 size_t dictstat_nmemb = 0;
10972 #endif
10973
10974 #ifdef _WIN
10975 uint dictstat_nmemb = 0;
10976 #endif
10977
10978 char dictstat[256] = { 0 };
10979
10980 FILE *dictstat_fp = NULL;
10981
10982 if (keyspace == 0)
10983 {
10984 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10985
10986 dictstat_fp = fopen (dictstat, "rb");
10987
10988 if (dictstat_fp)
10989 {
10990 #ifdef _POSIX
10991 struct stat tmpstat;
10992
10993 fstat (fileno (dictstat_fp), &tmpstat);
10994 #endif
10995
10996 #ifdef _WIN
10997 struct stat64 tmpstat;
10998
10999 _fstat64 (fileno (dictstat_fp), &tmpstat);
11000 #endif
11001
11002 if (tmpstat.st_mtime < COMPTIME)
11003 {
11004 /* with v0.15 the format changed so we have to ensure user is using a good version
11005 since there is no version-header in the dictstat file */
11006
11007 fclose (dictstat_fp);
11008
11009 unlink (dictstat);
11010 }
11011 else
11012 {
11013 while (!feof (dictstat_fp))
11014 {
11015 dictstat_t d;
11016
11017 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11018
11019 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11020
11021 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11022 {
11023 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11024
11025 return -1;
11026 }
11027 }
11028
11029 fclose (dictstat_fp);
11030 }
11031 }
11032 }
11033
11034 /**
11035 * potfile
11036 */
11037
11038 char potfile[256] = { 0 };
11039
11040 if (potfile_path == NULL)
11041 {
11042 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11043 }
11044 else
11045 {
11046 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11047 }
11048
11049 data.pot_fp = NULL;
11050
11051 FILE *out_fp = NULL;
11052 FILE *pot_fp = NULL;
11053
11054 if (show == 1 || left == 1)
11055 {
11056 pot_fp = fopen (potfile, "rb");
11057
11058 if (pot_fp == NULL)
11059 {
11060 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11061
11062 return (-1);
11063 }
11064
11065 if (outfile != NULL)
11066 {
11067 if ((out_fp = fopen (outfile, "ab")) == NULL)
11068 {
11069 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11070
11071 fclose (pot_fp);
11072
11073 return (-1);
11074 }
11075 }
11076 else
11077 {
11078 out_fp = stdout;
11079 }
11080 }
11081 else
11082 {
11083 if (potfile_disable == 0)
11084 {
11085 pot_fp = fopen (potfile, "ab");
11086
11087 if (pot_fp == NULL)
11088 {
11089 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11090
11091 return (-1);
11092 }
11093
11094 data.pot_fp = pot_fp;
11095 }
11096 }
11097
11098 pot_t *pot = NULL;
11099
11100 uint pot_cnt = 0;
11101 uint pot_avail = 0;
11102
11103 if (show == 1 || left == 1)
11104 {
11105 SUPPRESS_OUTPUT = 1;
11106
11107 pot_avail = count_lines (pot_fp);
11108
11109 rewind (pot_fp);
11110
11111 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11112
11113 uint pot_hashes_avail = 0;
11114
11115 uint line_num = 0;
11116
11117 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11118
11119 while (!feof (pot_fp))
11120 {
11121 line_num++;
11122
11123 int line_len = fgetl (pot_fp, line_buf);
11124
11125 if (line_len == 0) continue;
11126
11127 char *plain_buf = line_buf + line_len;
11128
11129 pot_t *pot_ptr = &pot[pot_cnt];
11130
11131 hash_t *hashes_buf = &pot_ptr->hash;
11132
11133 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11134 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11135
11136 if (pot_cnt == pot_hashes_avail)
11137 {
11138 uint pos = 0;
11139
11140 for (pos = 0; pos < INCR_POT; pos++)
11141 {
11142 if ((pot_cnt + pos) >= pot_avail) break;
11143
11144 pot_t *tmp_pot = &pot[pot_cnt + pos];
11145
11146 hash_t *tmp_hash = &tmp_pot->hash;
11147
11148 tmp_hash->digest = mymalloc (dgst_size);
11149
11150 if (isSalted)
11151 {
11152 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11153 }
11154
11155 if (esalt_size)
11156 {
11157 tmp_hash->esalt = mymalloc (esalt_size);
11158 }
11159
11160 pot_hashes_avail++;
11161 }
11162 }
11163
11164 int plain_len = 0;
11165
11166 int parser_status;
11167
11168 int iter = MAX_CUT_TRIES;
11169
11170 do
11171 {
11172 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11173 {
11174 if (line_buf[i] == ':')
11175 {
11176 line_len--;
11177
11178 break;
11179 }
11180 }
11181
11182 if (data.hash_mode != 2500)
11183 {
11184 parser_status = parse_func (line_buf, line_len, hashes_buf);
11185 }
11186 else
11187 {
11188 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11189
11190 if (line_len > max_salt_size)
11191 {
11192 parser_status = PARSER_GLOBAL_LENGTH;
11193 }
11194 else
11195 {
11196 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11197
11198 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11199
11200 hashes_buf->salt->salt_len = line_len;
11201
11202 parser_status = PARSER_OK;
11203 }
11204 }
11205
11206 // if NOT parsed without error, we add the ":" to the plain
11207
11208 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11209 {
11210 plain_len++;
11211 plain_buf--;
11212 }
11213
11214 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11215
11216 if (parser_status < PARSER_GLOBAL_ZERO)
11217 {
11218 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11219
11220 continue;
11221 }
11222
11223 if (plain_len >= 255) continue;
11224
11225 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11226
11227 pot_ptr->plain_len = plain_len;
11228
11229 pot_cnt++;
11230 }
11231
11232 myfree (line_buf);
11233
11234 fclose (pot_fp);
11235
11236 SUPPRESS_OUTPUT = 0;
11237
11238 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11239 }
11240
11241 /**
11242 * word len
11243 */
11244
11245 uint pw_min = PW_MIN;
11246 uint pw_max = PW_MAX;
11247
11248 switch (hash_mode)
11249 {
11250 case 125: if (pw_max > 32) pw_max = 32;
11251 break;
11252 case 400: if (pw_max > 40) pw_max = 40;
11253 break;
11254 case 500: if (pw_max > 16) pw_max = 16;
11255 break;
11256 case 1500: if (pw_max > 8) pw_max = 8;
11257 break;
11258 case 1600: if (pw_max > 16) pw_max = 16;
11259 break;
11260 case 1800: if (pw_max > 16) pw_max = 16;
11261 break;
11262 case 2100: if (pw_max > 16) pw_max = 16;
11263 break;
11264 case 2500: if (pw_min < 8) pw_min = 8;
11265 break;
11266 case 3000: if (pw_max > 7) pw_max = 7;
11267 break;
11268 case 5200: if (pw_max > 24) pw_max = 24;
11269 break;
11270 case 5800: if (pw_max > 16) pw_max = 16;
11271 break;
11272 case 6300: if (pw_max > 16) pw_max = 16;
11273 break;
11274 case 7400: if (pw_max > 16) pw_max = 16;
11275 break;
11276 case 7500: if (pw_max > 8) pw_max = 8;
11277 break;
11278 case 7900: if (pw_max > 48) pw_max = 48;
11279 break;
11280 case 8500: if (pw_max > 8) pw_max = 8;
11281 break;
11282 case 8600: if (pw_max > 16) pw_max = 16;
11283 break;
11284 case 9710: pw_min = 5;
11285 pw_max = 5;
11286 break;
11287 case 9810: pw_min = 5;
11288 pw_max = 5;
11289 break;
11290 case 10410: pw_min = 5;
11291 pw_max = 5;
11292 break;
11293 case 10300: if (pw_max < 3) pw_min = 3;
11294 if (pw_max > 40) pw_max = 40;
11295 break;
11296 case 10500: if (pw_max < 3) pw_min = 3;
11297 if (pw_max > 40) pw_max = 40;
11298 break;
11299 case 10700: if (pw_max > 16) pw_max = 16;
11300 break;
11301 case 11300: if (pw_max > 40) pw_max = 40;
11302 break;
11303 case 11600: if (pw_max > 32) pw_max = 32;
11304 break;
11305 case 12500: if (pw_max > 20) pw_max = 20;
11306 break;
11307 case 12800: if (pw_max > 24) pw_max = 24;
11308 break;
11309 }
11310
11311 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11312 {
11313 switch (attack_kern)
11314 {
11315 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11316 break;
11317 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11318 break;
11319 }
11320 }
11321
11322 /**
11323 * charsets : keep them together for more easy maintainnce
11324 */
11325
11326 cs_t mp_sys[6] = { { { 0 }, 0 } };
11327 cs_t mp_usr[4] = { { { 0 }, 0 } };
11328
11329 mp_setup_sys (mp_sys);
11330
11331 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11332 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11333 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11334 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11335
11336 /**
11337 * load hashes, part I: find input mode, count hashes
11338 */
11339
11340 uint hashlist_mode = 0;
11341 uint hashlist_format = HLFMT_HASHCAT;
11342
11343 uint hashes_avail = 0;
11344
11345 if (benchmark == 0)
11346 {
11347 struct stat f;
11348
11349 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11350
11351 if ((hash_mode == 2500) ||
11352 (hash_mode == 5200) ||
11353 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11354 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11355 (hash_mode == 9000))
11356 {
11357 hashlist_mode = HL_MODE_ARG;
11358
11359 char *hashfile = myargv[optind];
11360
11361 data.hashfile = hashfile;
11362
11363 logfile_top_var_string ("target", hashfile);
11364 }
11365
11366 if (hashlist_mode == HL_MODE_ARG)
11367 {
11368 if (hash_mode == 2500)
11369 {
11370 struct stat st;
11371
11372 if (stat (data.hashfile, &st) == -1)
11373 {
11374 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11375
11376 return (-1);
11377 }
11378
11379 hashes_avail = st.st_size / sizeof (hccap_t);
11380 }
11381 else
11382 {
11383 hashes_avail = 1;
11384 }
11385 }
11386 else if (hashlist_mode == HL_MODE_FILE)
11387 {
11388 char *hashfile = myargv[optind];
11389
11390 data.hashfile = hashfile;
11391
11392 logfile_top_var_string ("target", hashfile);
11393
11394 FILE *fp = NULL;
11395
11396 if ((fp = fopen (hashfile, "rb")) == NULL)
11397 {
11398 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11399
11400 return (-1);
11401 }
11402
11403 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11404
11405 hashes_avail = count_lines (fp);
11406
11407 rewind (fp);
11408
11409 if (hashes_avail == 0)
11410 {
11411 log_error ("ERROR: hashfile is empty or corrupt");
11412
11413 fclose (fp);
11414
11415 return (-1);
11416 }
11417
11418 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11419
11420 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11421 {
11422 log_error ("ERROR: remove not supported in native hashfile-format mode");
11423
11424 fclose (fp);
11425
11426 return (-1);
11427 }
11428
11429 fclose (fp);
11430 }
11431 }
11432 else
11433 {
11434 hashlist_mode = HL_MODE_ARG;
11435
11436 hashes_avail = 1;
11437 }
11438
11439 if (hash_mode == 3000) hashes_avail *= 2;
11440
11441 data.hashlist_mode = hashlist_mode;
11442 data.hashlist_format = hashlist_format;
11443
11444 logfile_top_uint (hashlist_mode);
11445 logfile_top_uint (hashlist_format);
11446
11447 /**
11448 * load hashes, part II: allocate required memory, set pointers
11449 */
11450
11451 hash_t *hashes_buf = NULL;
11452 void *digests_buf = NULL;
11453 salt_t *salts_buf = NULL;
11454 void *esalts_buf = NULL;
11455
11456 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11457
11458 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11459
11460 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11461 {
11462 u32 hash_pos;
11463
11464 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11465 {
11466 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11467
11468 hashes_buf[hash_pos].hash_info = hash_info;
11469
11470 if (username && (remove || show || left))
11471 {
11472 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11473 }
11474
11475 if (benchmark)
11476 {
11477 hash_info->orighash = (char *) mymalloc (256);
11478 }
11479 }
11480 }
11481
11482 if (isSalted)
11483 {
11484 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11485
11486 if (esalt_size)
11487 {
11488 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11489 }
11490 }
11491 else
11492 {
11493 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11494 }
11495
11496 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11497 {
11498 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11499
11500 if (isSalted)
11501 {
11502 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11503
11504 if (esalt_size)
11505 {
11506 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11507 }
11508 }
11509 else
11510 {
11511 hashes_buf[hash_pos].salt = &salts_buf[0];
11512 }
11513 }
11514
11515 /**
11516 * load hashes, part III: parse hashes or generate them if benchmark
11517 */
11518
11519 uint hashes_cnt = 0;
11520
11521 if (benchmark == 0)
11522 {
11523 if (keyspace == 1)
11524 {
11525 // useless to read hash file for keyspace, cheat a little bit w/ optind
11526 }
11527 else if (hashes_avail == 0)
11528 {
11529 }
11530 else if (hashlist_mode == HL_MODE_ARG)
11531 {
11532 char *input_buf = myargv[optind];
11533
11534 uint input_len = strlen (input_buf);
11535
11536 logfile_top_var_string ("target", input_buf);
11537
11538 char *hash_buf = NULL;
11539 int hash_len = 0;
11540
11541 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11542
11543 bool hash_fmt_error = 0;
11544
11545 if (hash_len < 1) hash_fmt_error = 1;
11546 if (hash_buf == NULL) hash_fmt_error = 1;
11547
11548 if (hash_fmt_error)
11549 {
11550 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11551 }
11552 else
11553 {
11554 if (opts_type & OPTS_TYPE_HASH_COPY)
11555 {
11556 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11557
11558 hash_info_tmp->orighash = mystrdup (hash_buf);
11559 }
11560
11561 if (isSalted)
11562 {
11563 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11564 }
11565
11566 int parser_status = PARSER_OK;
11567
11568 if (hash_mode == 2500)
11569 {
11570 if (hash_len == 0)
11571 {
11572 log_error ("ERROR: hccap file not specified");
11573
11574 return (-1);
11575 }
11576
11577 hashlist_mode = HL_MODE_FILE;
11578
11579 data.hashlist_mode = hashlist_mode;
11580
11581 FILE *fp = fopen (hash_buf, "rb");
11582
11583 if (fp == NULL)
11584 {
11585 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11586
11587 return (-1);
11588 }
11589
11590 if (hashes_avail < 1)
11591 {
11592 log_error ("ERROR: hccap file is empty or corrupt");
11593
11594 fclose (fp);
11595
11596 return (-1);
11597 }
11598
11599 uint hccap_size = sizeof (hccap_t);
11600
11601 char *in = (char *) mymalloc (hccap_size);
11602
11603 while (!feof (fp))
11604 {
11605 int n = fread (in, hccap_size, 1, fp);
11606
11607 if (n != 1)
11608 {
11609 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11610
11611 break;
11612 }
11613
11614 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11615
11616 if (parser_status != PARSER_OK)
11617 {
11618 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11619
11620 continue;
11621 }
11622
11623 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11624
11625 if ((show == 1) || (left == 1))
11626 {
11627 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11628
11629 char *salt_ptr = (char *) tmp_salt->salt_buf;
11630
11631 int cur_pos = tmp_salt->salt_len;
11632 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11633
11634 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11635
11636 // do the appending task
11637
11638 snprintf (salt_ptr + cur_pos,
11639 rem_len,
11640 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11641 wpa->orig_mac1[0],
11642 wpa->orig_mac1[1],
11643 wpa->orig_mac1[2],
11644 wpa->orig_mac1[3],
11645 wpa->orig_mac1[4],
11646 wpa->orig_mac1[5],
11647 wpa->orig_mac2[0],
11648 wpa->orig_mac2[1],
11649 wpa->orig_mac2[2],
11650 wpa->orig_mac2[3],
11651 wpa->orig_mac2[4],
11652 wpa->orig_mac2[5]);
11653
11654 // memset () the remaining part of the salt
11655
11656 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11657 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11658
11659 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11660
11661 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11662 }
11663
11664 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);
11665 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);
11666
11667 hashes_cnt++;
11668 }
11669
11670 fclose (fp);
11671
11672 myfree (in);
11673 }
11674 else if (hash_mode == 3000)
11675 {
11676 if (hash_len == 32)
11677 {
11678 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11679
11680 hash_t *lm_hash_left = NULL;
11681
11682 if (parser_status == PARSER_OK)
11683 {
11684 lm_hash_left = &hashes_buf[hashes_cnt];
11685
11686 hashes_cnt++;
11687 }
11688 else
11689 {
11690 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11691 }
11692
11693 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11694
11695 hash_t *lm_hash_right = NULL;
11696
11697 if (parser_status == PARSER_OK)
11698 {
11699 lm_hash_right = &hashes_buf[hashes_cnt];
11700
11701 hashes_cnt++;
11702 }
11703 else
11704 {
11705 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11706 }
11707
11708 // show / left
11709
11710 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11711 {
11712 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);
11713 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);
11714 }
11715 }
11716 else
11717 {
11718 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11719
11720 if (parser_status == PARSER_OK)
11721 {
11722 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11723 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11724 }
11725
11726 if (parser_status == PARSER_OK)
11727 {
11728 hashes_cnt++;
11729 }
11730 else
11731 {
11732 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11733 }
11734 }
11735 }
11736 else
11737 {
11738 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11739
11740 if (parser_status == PARSER_OK)
11741 {
11742 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11743 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11744 }
11745
11746 if (parser_status == PARSER_OK)
11747 {
11748 hashes_cnt++;
11749 }
11750 else
11751 {
11752 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11753 }
11754 }
11755 }
11756 }
11757 else if (hashlist_mode == HL_MODE_FILE)
11758 {
11759 char *hashfile = data.hashfile;
11760
11761 FILE *fp;
11762
11763 if ((fp = fopen (hashfile, "rb")) == NULL)
11764 {
11765 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11766
11767 return (-1);
11768 }
11769
11770 uint line_num = 0;
11771
11772 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11773
11774 while (!feof (fp))
11775 {
11776 line_num++;
11777
11778 int line_len = fgetl (fp, line_buf);
11779
11780 if (line_len == 0) continue;
11781
11782 char *hash_buf = NULL;
11783 int hash_len = 0;
11784
11785 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11786
11787 bool hash_fmt_error = 0;
11788
11789 if (hash_len < 1) hash_fmt_error = 1;
11790 if (hash_buf == NULL) hash_fmt_error = 1;
11791
11792 if (hash_fmt_error)
11793 {
11794 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11795
11796 continue;
11797 }
11798
11799 if (username)
11800 {
11801 char *user_buf = NULL;
11802 int user_len = 0;
11803
11804 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11805
11806 if (remove || show)
11807 {
11808 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11809
11810 *user = (user_t *) mymalloc (sizeof (user_t));
11811
11812 user_t *user_ptr = *user;
11813
11814 if (user_buf != NULL)
11815 {
11816 user_ptr->user_name = mystrdup (user_buf);
11817 }
11818 else
11819 {
11820 user_ptr->user_name = mystrdup ("");
11821 }
11822
11823 user_ptr->user_len = user_len;
11824 }
11825 }
11826
11827 if (opts_type & OPTS_TYPE_HASH_COPY)
11828 {
11829 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11830
11831 hash_info_tmp->orighash = mystrdup (hash_buf);
11832 }
11833
11834 if (isSalted)
11835 {
11836 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11837 }
11838
11839 if (hash_mode == 3000)
11840 {
11841 if (hash_len == 32)
11842 {
11843 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11844
11845 if (parser_status < PARSER_GLOBAL_ZERO)
11846 {
11847 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11848
11849 continue;
11850 }
11851
11852 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11853
11854 hashes_cnt++;
11855
11856 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11857
11858 if (parser_status < PARSER_GLOBAL_ZERO)
11859 {
11860 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11861
11862 continue;
11863 }
11864
11865 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11866
11867 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);
11868
11869 hashes_cnt++;
11870
11871 // show / left
11872
11873 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);
11874 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);
11875 }
11876 else
11877 {
11878 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11879
11880 if (parser_status < PARSER_GLOBAL_ZERO)
11881 {
11882 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11883
11884 continue;
11885 }
11886
11887 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);
11888
11889 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11890 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11891
11892 hashes_cnt++;
11893 }
11894 }
11895 else
11896 {
11897 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11898
11899 if (parser_status < PARSER_GLOBAL_ZERO)
11900 {
11901 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11902
11903 continue;
11904 }
11905
11906 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);
11907
11908 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11909 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11910
11911 hashes_cnt++;
11912 }
11913 }
11914
11915 myfree (line_buf);
11916
11917 fclose (fp);
11918
11919 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11920
11921 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11922 }
11923 }
11924 else
11925 {
11926 if (isSalted)
11927 {
11928 hashes_buf[0].salt->salt_len = 8;
11929
11930 // special salt handling
11931
11932 switch (hash_mode)
11933 {
11934 case 1500: hashes_buf[0].salt->salt_len = 2;
11935 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11936 break;
11937 case 1731: hashes_buf[0].salt->salt_len = 4;
11938 break;
11939 case 2410: hashes_buf[0].salt->salt_len = 4;
11940 break;
11941 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11942 break;
11943 case 3100: hashes_buf[0].salt->salt_len = 1;
11944 break;
11945 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11946 break;
11947 case 5800: hashes_buf[0].salt->salt_len = 16;
11948 break;
11949 case 6800: hashes_buf[0].salt->salt_len = 32;
11950 break;
11951 case 8400: hashes_buf[0].salt->salt_len = 40;
11952 break;
11953 case 8800: hashes_buf[0].salt->salt_len = 16;
11954 break;
11955 case 8900: hashes_buf[0].salt->salt_len = 16;
11956 hashes_buf[0].salt->scrypt_N = 1024;
11957 hashes_buf[0].salt->scrypt_r = 1;
11958 hashes_buf[0].salt->scrypt_p = 1;
11959 break;
11960 case 9100: hashes_buf[0].salt->salt_len = 16;
11961 break;
11962 case 9300: hashes_buf[0].salt->salt_len = 14;
11963 hashes_buf[0].salt->scrypt_N = 16384;
11964 hashes_buf[0].salt->scrypt_r = 1;
11965 hashes_buf[0].salt->scrypt_p = 1;
11966 break;
11967 case 9400: hashes_buf[0].salt->salt_len = 16;
11968 break;
11969 case 9500: hashes_buf[0].salt->salt_len = 16;
11970 break;
11971 case 9600: hashes_buf[0].salt->salt_len = 16;
11972 break;
11973 case 9700: hashes_buf[0].salt->salt_len = 16;
11974 break;
11975 case 9710: hashes_buf[0].salt->salt_len = 16;
11976 break;
11977 case 9720: hashes_buf[0].salt->salt_len = 16;
11978 break;
11979 case 9800: hashes_buf[0].salt->salt_len = 16;
11980 break;
11981 case 9810: hashes_buf[0].salt->salt_len = 16;
11982 break;
11983 case 9820: hashes_buf[0].salt->salt_len = 16;
11984 break;
11985 case 10300: hashes_buf[0].salt->salt_len = 12;
11986 break;
11987 case 11500: hashes_buf[0].salt->salt_len = 4;
11988 break;
11989 case 11600: hashes_buf[0].salt->salt_len = 4;
11990 break;
11991 case 12400: hashes_buf[0].salt->salt_len = 4;
11992 break;
11993 case 12500: hashes_buf[0].salt->salt_len = 8;
11994 break;
11995 case 12600: hashes_buf[0].salt->salt_len = 64;
11996 break;
11997 }
11998
11999 // special esalt handling
12000
12001 switch (hash_mode)
12002 {
12003 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12004 break;
12005 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12006 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12007 break;
12008 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12009 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12010 break;
12011 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12012 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12013 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12014 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12015 break;
12016 case 5600: ((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 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12022 break;
12023 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12024 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12025 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12026 break;
12027 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12028 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12029 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12030 break;
12031 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12032 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12033 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12034 break;
12035 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12036 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12037 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12038 break;
12039 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12040 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12041 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12042 break;
12043 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12044 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12045 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12046 break;
12047 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12048 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12049 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12050 break;
12051 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12052 break;
12053 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12054 break;
12055 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12056 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12057 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12058 break;
12059 }
12060 }
12061
12062 // set hashfile
12063
12064 switch (hash_mode)
12065 {
12066 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12067 break;
12068 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12069 break;
12070 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12071 break;
12072 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12073 break;
12074 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12075 break;
12076 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12077 break;
12078 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12079 break;
12080 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12081 break;
12082 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12083 break;
12084 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12085 break;
12086 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12087 break;
12088 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12089 break;
12090 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12091 break;
12092 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12093 break;
12094 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12095 break;
12096 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12097 break;
12098 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12099 break;
12100 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12101 break;
12102 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12103 break;
12104 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12105 break;
12106 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12107 break;
12108 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12109 break;
12110 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12111 break;
12112 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12113 break;
12114 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12115 break;
12116 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12117 break;
12118 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12119 break;
12120 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12121 break;
12122 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12123 break;
12124 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12125 break;
12126 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12127 break;
12128 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12129 break;
12130 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12131 break;
12132 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12133 break;
12134 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12135 break;
12136 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12137 break;
12138 }
12139
12140 // set default iterations
12141
12142 switch (hash_mode)
12143 {
12144 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12145 break;
12146 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12147 break;
12148 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12149 break;
12150 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12151 break;
12152 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12153 break;
12154 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12155 break;
12156 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12157 break;
12158 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12159 break;
12160 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12161 break;
12162 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12163 break;
12164 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12165 break;
12166 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12167 break;
12168 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12169 break;
12170 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12171 break;
12172 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12173 break;
12174 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12175 break;
12176 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12177 break;
12178 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12179 break;
12180 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12181 break;
12182 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12183 break;
12184 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12185 break;
12186 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12187 break;
12188 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12189 break;
12190 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12191 break;
12192 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12193 break;
12194 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12195 break;
12196 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12197 break;
12198 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12199 break;
12200 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12201 break;
12202 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12203 break;
12204 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12205 break;
12206 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12207 break;
12208 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12209 break;
12210 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12211 break;
12212 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12213 break;
12214 case 8900: hashes_buf[0].salt->salt_iter = 1;
12215 break;
12216 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12217 break;
12218 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12219 break;
12220 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12221 break;
12222 case 9300: hashes_buf[0].salt->salt_iter = 1;
12223 break;
12224 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12225 break;
12226 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12227 break;
12228 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12229 break;
12230 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12231 break;
12232 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12233 break;
12234 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12235 break;
12236 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12237 break;
12238 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12239 break;
12240 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12241 break;
12242 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12243 break;
12244 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12245 break;
12246 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12247 break;
12248 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12249 break;
12250 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12251 break;
12252 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12253 break;
12254 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12255 break;
12256 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12257 break;
12258 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12259 break;
12260 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12261 break;
12262 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12263 break;
12264 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12265 break;
12266 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12267 break;
12268 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12269 break;
12270 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12271 break;
12272 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12273 break;
12274 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12275 break;
12276 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12277 break;
12278 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12279 break;
12280 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12281 break;
12282 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12283 break;
12284 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12285 break;
12286 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12287 break;
12288 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12289 break;
12290 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12291 break;
12292 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12293 break;
12294 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12295 break;
12296 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12297 break;
12298 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12299 break;
12300 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12301 break;
12302 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12303 break;
12304 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12305 break;
12306 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12307 break;
12308 }
12309
12310 hashes_cnt = 1;
12311 }
12312
12313 if (show == 1 || left == 1)
12314 {
12315 for (uint i = 0; i < pot_cnt; i++)
12316 {
12317 pot_t *pot_ptr = &pot[i];
12318
12319 hash_t *hashes_buf = &pot_ptr->hash;
12320
12321 local_free (hashes_buf->digest);
12322
12323 if (isSalted)
12324 {
12325 local_free (hashes_buf->salt);
12326 }
12327 }
12328
12329 local_free (pot);
12330
12331 if (data.quiet == 0) log_info_nn ("");
12332
12333 return (0);
12334 }
12335
12336 if (keyspace == 0)
12337 {
12338 if (hashes_cnt == 0)
12339 {
12340 log_error ("ERROR: No hashes loaded");
12341
12342 return (-1);
12343 }
12344 }
12345
12346 /**
12347 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12348 */
12349
12350 if (data.outfile != NULL)
12351 {
12352 if (data.hashfile != NULL)
12353 {
12354 #ifdef _POSIX
12355 struct stat tmpstat_outfile;
12356 struct stat tmpstat_hashfile;
12357 #endif
12358
12359 #ifdef _WIN
12360 struct stat64 tmpstat_outfile;
12361 struct stat64 tmpstat_hashfile;
12362 #endif
12363
12364 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12365
12366 if (tmp_outfile_fp)
12367 {
12368 #ifdef _POSIX
12369 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12370 #endif
12371
12372 #ifdef _WIN
12373 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12374 #endif
12375
12376 fclose (tmp_outfile_fp);
12377 }
12378
12379 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12380
12381 if (tmp_hashfile_fp)
12382 {
12383 #ifdef _POSIX
12384 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12385 #endif
12386
12387 #ifdef _WIN
12388 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12389 #endif
12390
12391 fclose (tmp_hashfile_fp);
12392 }
12393
12394 if (tmp_outfile_fp && tmp_outfile_fp)
12395 {
12396 tmpstat_outfile.st_mode = 0;
12397 tmpstat_outfile.st_nlink = 0;
12398 tmpstat_outfile.st_uid = 0;
12399 tmpstat_outfile.st_gid = 0;
12400 tmpstat_outfile.st_rdev = 0;
12401 tmpstat_outfile.st_atime = 0;
12402
12403 tmpstat_hashfile.st_mode = 0;
12404 tmpstat_hashfile.st_nlink = 0;
12405 tmpstat_hashfile.st_uid = 0;
12406 tmpstat_hashfile.st_gid = 0;
12407 tmpstat_hashfile.st_rdev = 0;
12408 tmpstat_hashfile.st_atime = 0;
12409
12410 #ifdef _POSIX
12411 tmpstat_outfile.st_blksize = 0;
12412 tmpstat_outfile.st_blocks = 0;
12413
12414 tmpstat_hashfile.st_blksize = 0;
12415 tmpstat_hashfile.st_blocks = 0;
12416 #endif
12417
12418 #ifdef _POSIX
12419 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12420 {
12421 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12422
12423 return (-1);
12424 }
12425 #endif
12426
12427 #ifdef _WIN
12428 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12429 {
12430 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12431
12432 return (-1);
12433 }
12434 #endif
12435 }
12436 }
12437 }
12438
12439 /**
12440 * Remove duplicates
12441 */
12442
12443 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12444
12445 if (isSalted)
12446 {
12447 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12448 }
12449 else
12450 {
12451 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12452 }
12453
12454 uint hashes_cnt_orig = hashes_cnt;
12455
12456 hashes_cnt = 1;
12457
12458 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12459 {
12460 if (isSalted)
12461 {
12462 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12463 {
12464 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12465 }
12466 }
12467 else
12468 {
12469 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12470 }
12471
12472 if (hashes_pos > hashes_cnt)
12473 {
12474 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12475 }
12476
12477 hashes_cnt++;
12478 }
12479
12480 /**
12481 * Potfile removes
12482 */
12483
12484 uint potfile_remove_cracks = 0;
12485
12486 if (potfile_disable == 0)
12487 {
12488 hash_t hash_buf;
12489
12490 hash_buf.digest = mymalloc (dgst_size);
12491 hash_buf.salt = NULL;
12492 hash_buf.esalt = NULL;
12493 hash_buf.hash_info = NULL;
12494 hash_buf.cracked = 0;
12495
12496 if (isSalted)
12497 {
12498 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12499 }
12500
12501 if (esalt_size)
12502 {
12503 hash_buf.esalt = mymalloc (esalt_size);
12504 }
12505
12506 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12507
12508 // no solution for these special hash types (for instane because they use hashfile in output etc)
12509 if ((hash_mode != 5200) &&
12510 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12511 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12512 (hash_mode != 9000))
12513 {
12514 FILE *fp = fopen (potfile, "rb");
12515
12516 if (fp != NULL)
12517 {
12518 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12519
12520 // to be safe work with a copy (because of line_len loop, i etc)
12521 // moved up here because it's easier to handle continue case
12522 // it's just 64kb
12523
12524 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12525
12526 while (!feof (fp))
12527 {
12528 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12529
12530 if (ptr == NULL) break;
12531
12532 int line_len = strlen (line_buf);
12533
12534 if (line_len == 0) continue;
12535
12536 int iter = MAX_CUT_TRIES;
12537
12538 for (int i = line_len - 1; i && iter; i--, line_len--)
12539 {
12540 if (line_buf[i] != ':') continue;
12541
12542 if (isSalted)
12543 {
12544 memset (hash_buf.salt, 0, sizeof (salt_t));
12545 }
12546
12547 hash_t *found = NULL;
12548
12549 if (hash_mode == 6800)
12550 {
12551 if (i < 64) // 64 = 16 * uint in salt_buf[]
12552 {
12553 // manipulate salt_buf
12554 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12555
12556 hash_buf.salt->salt_len = i;
12557
12558 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12559 }
12560 }
12561 else if (hash_mode == 2500)
12562 {
12563 if (i < 64) // 64 = 16 * uint in salt_buf[]
12564 {
12565 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12566 // manipulate salt_buf
12567
12568 memcpy (line_buf_cpy, line_buf, i);
12569
12570 char *mac2_pos = strrchr (line_buf_cpy, ':');
12571
12572 if (mac2_pos == NULL) continue;
12573
12574 mac2_pos[0] = 0;
12575 mac2_pos++;
12576
12577 if (strlen (mac2_pos) != 12) continue;
12578
12579 char *mac1_pos = strrchr (line_buf_cpy, ':');
12580
12581 if (mac1_pos == NULL) continue;
12582
12583 mac1_pos[0] = 0;
12584 mac1_pos++;
12585
12586 if (strlen (mac1_pos) != 12) continue;
12587
12588 uint essid_length = mac1_pos - line_buf_cpy - 1;
12589
12590 // here we need the ESSID
12591 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12592
12593 hash_buf.salt->salt_len = essid_length;
12594
12595 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12596
12597 if (found)
12598 {
12599 wpa_t *wpa = (wpa_t *) found->esalt;
12600
12601 // compare hex string(s) vs binary MAC address(es)
12602
12603 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12604 {
12605 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12606 {
12607 found = NULL;
12608
12609 break;
12610 }
12611 }
12612
12613 // early skip ;)
12614 if (!found) continue;
12615
12616 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12617 {
12618 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12619 {
12620 found = NULL;
12621
12622 break;
12623 }
12624 }
12625 }
12626 }
12627 }
12628 else
12629 {
12630 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12631
12632 if (parser_status == PARSER_OK)
12633 {
12634 if (isSalted)
12635 {
12636 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12637 }
12638 else
12639 {
12640 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12641 }
12642 }
12643 }
12644
12645 if (found == NULL) continue;
12646
12647 if (!found->cracked) potfile_remove_cracks++;
12648
12649 found->cracked = 1;
12650
12651 if (found) break;
12652
12653 iter--;
12654 }
12655 }
12656
12657 myfree (line_buf_cpy);
12658
12659 myfree (line_buf);
12660
12661 fclose (fp);
12662 }
12663 }
12664
12665 if (esalt_size)
12666 {
12667 local_free (hash_buf.esalt);
12668 }
12669
12670 if (isSalted)
12671 {
12672 local_free (hash_buf.salt);
12673 }
12674
12675 local_free (hash_buf.digest);
12676 }
12677
12678 /**
12679 * Now generate all the buffers required for later
12680 */
12681
12682 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12683
12684 salt_t *salts_buf_new = NULL;
12685 void *esalts_buf_new = NULL;
12686
12687 if (isSalted)
12688 {
12689 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12690
12691 if (esalt_size)
12692 {
12693 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12694 }
12695 }
12696 else
12697 {
12698 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12699 }
12700
12701 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12702
12703 uint digests_cnt = hashes_cnt;
12704 uint digests_done = 0;
12705
12706 size_t size_digests = digests_cnt * dgst_size;
12707 size_t size_shown = digests_cnt * sizeof (uint);
12708
12709 uint *digests_shown = (uint *) mymalloc (size_shown);
12710 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12711
12712 uint salts_cnt = 0;
12713 uint salts_done = 0;
12714
12715 hashinfo_t **hash_info = NULL;
12716
12717 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12718 {
12719 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12720
12721 if (username && (remove || show))
12722 {
12723 uint user_pos;
12724
12725 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12726 {
12727 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12728
12729 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12730 }
12731 }
12732 }
12733
12734 uint *salts_shown = (uint *) mymalloc (size_shown);
12735
12736 salt_t *salt_buf;
12737
12738 {
12739 // copied from inner loop
12740
12741 salt_buf = &salts_buf_new[salts_cnt];
12742
12743 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12744
12745 if (esalt_size)
12746 {
12747 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12748 }
12749
12750 salt_buf->digests_cnt = 0;
12751 salt_buf->digests_done = 0;
12752 salt_buf->digests_offset = 0;
12753
12754 salts_cnt++;
12755 }
12756
12757 if (hashes_buf[0].cracked == 1)
12758 {
12759 digests_shown[0] = 1;
12760
12761 digests_done++;
12762
12763 salt_buf->digests_done++;
12764 }
12765
12766 salt_buf->digests_cnt++;
12767
12768 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12769
12770 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12771 {
12772 hash_info[0] = hashes_buf[0].hash_info;
12773 }
12774
12775 // copy from inner loop
12776
12777 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12778 {
12779 if (isSalted)
12780 {
12781 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12782 {
12783 salt_buf = &salts_buf_new[salts_cnt];
12784
12785 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12786
12787 if (esalt_size)
12788 {
12789 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12790 }
12791
12792 salt_buf->digests_cnt = 0;
12793 salt_buf->digests_done = 0;
12794 salt_buf->digests_offset = hashes_pos;
12795
12796 salts_cnt++;
12797 }
12798 }
12799
12800 if (hashes_buf[hashes_pos].cracked == 1)
12801 {
12802 digests_shown[hashes_pos] = 1;
12803
12804 digests_done++;
12805
12806 salt_buf->digests_done++;
12807 }
12808
12809 salt_buf->digests_cnt++;
12810
12811 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12812
12813 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12814 {
12815 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12816 }
12817 }
12818
12819 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12820 {
12821 salt_t *salt_buf = &salts_buf_new[salt_pos];
12822
12823 if (salt_buf->digests_done == salt_buf->digests_cnt)
12824 {
12825 salts_shown[salt_pos] = 1;
12826
12827 salts_done++;
12828 }
12829
12830 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12831 }
12832
12833 local_free (digests_buf);
12834 local_free (salts_buf);
12835 local_free (esalts_buf);
12836
12837 digests_buf = digests_buf_new;
12838 salts_buf = salts_buf_new;
12839 esalts_buf = esalts_buf_new;
12840
12841 local_free (hashes_buf);
12842
12843 /**
12844 * special modification not set from parser
12845 */
12846
12847 switch (hash_mode)
12848 {
12849 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12850 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12851 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12852 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12853 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12854 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12855 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12856 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12857 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12858 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12859 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12860 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12861 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12862 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12863 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12864 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12865 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12866 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12867 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12868 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12869 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12870 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12871 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12872 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12873 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12874 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12875 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12876 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12877 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12878 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12879 }
12880
12881 if (truecrypt_keyfiles)
12882 {
12883 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12884
12885 char *keyfiles = strdup (truecrypt_keyfiles);
12886
12887 char *keyfile = strtok (keyfiles, ",");
12888
12889 do
12890 {
12891 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12892
12893 } while ((keyfile = strtok (NULL, ",")) != NULL);
12894
12895 free (keyfiles);
12896 }
12897
12898 if (veracrypt_keyfiles)
12899 {
12900 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12901
12902 char *keyfiles = strdup (veracrypt_keyfiles);
12903
12904 char *keyfile = strtok (keyfiles, ",");
12905
12906 do
12907 {
12908 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12909
12910 } while ((keyfile = strtok (NULL, ",")) != NULL);
12911
12912 free (keyfiles);
12913 }
12914
12915 data.digests_cnt = digests_cnt;
12916 data.digests_done = digests_done;
12917 data.digests_buf = digests_buf;
12918 data.digests_shown = digests_shown;
12919 data.digests_shown_tmp = digests_shown_tmp;
12920
12921 data.salts_cnt = salts_cnt;
12922 data.salts_done = salts_done;
12923 data.salts_buf = salts_buf;
12924 data.salts_shown = salts_shown;
12925
12926 data.esalts_buf = esalts_buf;
12927 data.hash_info = hash_info;
12928
12929 /**
12930 * Automatic Optimizers
12931 */
12932
12933 if (salts_cnt == 1)
12934 opti_type |= OPTI_TYPE_SINGLE_SALT;
12935
12936 if (digests_cnt == 1)
12937 opti_type |= OPTI_TYPE_SINGLE_HASH;
12938
12939 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12940 opti_type |= OPTI_TYPE_NOT_ITERATED;
12941
12942 if (attack_mode == ATTACK_MODE_BF)
12943 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12944
12945 data.opti_type = opti_type;
12946
12947 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12948 {
12949 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12950 {
12951 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12952 {
12953 if (opts_type & OPTS_TYPE_ST_ADD80)
12954 {
12955 opts_type &= ~OPTS_TYPE_ST_ADD80;
12956 opts_type |= OPTS_TYPE_PT_ADD80;
12957 }
12958
12959 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12960 {
12961 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12962 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12963 }
12964
12965 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12966 {
12967 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12968 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12969 }
12970 }
12971 }
12972 }
12973
12974 /**
12975 * Some algorithm, like descrypt, can benefit from JIT compilation
12976 */
12977
12978 int force_jit_compilation = -1;
12979
12980 if (hash_mode == 8900)
12981 {
12982 force_jit_compilation = 8900;
12983 }
12984 else if (hash_mode == 9300)
12985 {
12986 force_jit_compilation = 8900;
12987 }
12988 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12989 {
12990 force_jit_compilation = 1500;
12991 }
12992
12993 /**
12994 * generate bitmap tables
12995 */
12996
12997 const uint bitmap_shift1 = 5;
12998 const uint bitmap_shift2 = 13;
12999
13000 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13001
13002 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13003 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13004 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13005 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13006 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13007 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13008 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13009 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13010
13011 uint bitmap_bits;
13012 uint bitmap_nums;
13013 uint bitmap_mask;
13014 uint bitmap_size;
13015
13016 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13017 {
13018 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13019
13020 bitmap_nums = 1 << bitmap_bits;
13021
13022 bitmap_mask = bitmap_nums - 1;
13023
13024 bitmap_size = bitmap_nums * sizeof (uint);
13025
13026 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13027
13028 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;
13029 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;
13030
13031 break;
13032 }
13033
13034 bitmap_nums = 1 << bitmap_bits;
13035
13036 bitmap_mask = bitmap_nums - 1;
13037
13038 bitmap_size = bitmap_nums * sizeof (uint);
13039
13040 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);
13041 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);
13042
13043 /**
13044 * prepare quick rule
13045 */
13046
13047 data.rule_buf_l = rule_buf_l;
13048 data.rule_buf_r = rule_buf_r;
13049
13050 int rule_len_l = (int) strlen (rule_buf_l);
13051 int rule_len_r = (int) strlen (rule_buf_r);
13052
13053 data.rule_len_l = rule_len_l;
13054 data.rule_len_r = rule_len_r;
13055
13056 /**
13057 * load rules
13058 */
13059
13060 uint *all_kernel_rules_cnt = NULL;
13061
13062 kernel_rule_t **all_kernel_rules_buf = NULL;
13063
13064 if (rp_files_cnt)
13065 {
13066 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13067
13068 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13069 }
13070
13071 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13072
13073 int rule_len = 0;
13074
13075 for (uint i = 0; i < rp_files_cnt; i++)
13076 {
13077 uint kernel_rules_avail = 0;
13078
13079 uint kernel_rules_cnt = 0;
13080
13081 kernel_rule_t *kernel_rules_buf = NULL;
13082
13083 char *rp_file = rp_files[i];
13084
13085 char in[BLOCK_SIZE] = { 0 };
13086 char out[BLOCK_SIZE] = { 0 };
13087
13088 FILE *fp = NULL;
13089
13090 uint rule_line = 0;
13091
13092 if ((fp = fopen (rp_file, "rb")) == NULL)
13093 {
13094 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13095
13096 return (-1);
13097 }
13098
13099 while (!feof (fp))
13100 {
13101 memset (rule_buf, 0, HCBUFSIZ);
13102
13103 rule_len = fgetl (fp, rule_buf);
13104
13105 rule_line++;
13106
13107 if (rule_len == 0) continue;
13108
13109 if (rule_buf[0] == '#') continue;
13110
13111 if (kernel_rules_avail == kernel_rules_cnt)
13112 {
13113 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13114
13115 kernel_rules_avail += INCR_RULES;
13116 }
13117
13118 memset (in, 0, BLOCK_SIZE);
13119 memset (out, 0, BLOCK_SIZE);
13120
13121 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13122
13123 if (result == -1)
13124 {
13125 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13126
13127 continue;
13128 }
13129
13130 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13131 {
13132 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13133
13134 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13135
13136 continue;
13137 }
13138
13139 /* its so slow
13140 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13141 {
13142 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13143
13144 continue;
13145 }
13146 */
13147
13148 kernel_rules_cnt++;
13149 }
13150
13151 fclose (fp);
13152
13153 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13154
13155 all_kernel_rules_buf[i] = kernel_rules_buf;
13156 }
13157
13158 /**
13159 * merge rules or automatic rule generator
13160 */
13161
13162 uint kernel_rules_cnt = 0;
13163
13164 kernel_rule_t *kernel_rules_buf = NULL;
13165
13166 if (attack_mode == ATTACK_MODE_STRAIGHT)
13167 {
13168 if (rp_files_cnt)
13169 {
13170 kernel_rules_cnt = 1;
13171
13172 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13173
13174 repeats[0] = kernel_rules_cnt;
13175
13176 for (uint i = 0; i < rp_files_cnt; i++)
13177 {
13178 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13179
13180 repeats[i + 1] = kernel_rules_cnt;
13181 }
13182
13183 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13184
13185 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13186
13187 for (uint i = 0; i < kernel_rules_cnt; i++)
13188 {
13189 uint out_pos = 0;
13190
13191 kernel_rule_t *out = &kernel_rules_buf[i];
13192
13193 for (uint j = 0; j < rp_files_cnt; j++)
13194 {
13195 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13196 uint in_pos;
13197
13198 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13199
13200 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13201 {
13202 if (out_pos == RULES_MAX - 1)
13203 {
13204 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13205
13206 break;
13207 }
13208
13209 out->cmds[out_pos] = in->cmds[in_pos];
13210 }
13211 }
13212 }
13213
13214 local_free (repeats);
13215 }
13216 else if (rp_gen)
13217 {
13218 uint kernel_rules_avail = 0;
13219
13220 while (kernel_rules_cnt < rp_gen)
13221 {
13222 if (kernel_rules_avail == kernel_rules_cnt)
13223 {
13224 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13225
13226 kernel_rules_avail += INCR_RULES;
13227 }
13228
13229 memset (rule_buf, 0, HCBUFSIZ);
13230
13231 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13232
13233 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13234
13235 kernel_rules_cnt++;
13236 }
13237 }
13238 }
13239
13240 myfree (rule_buf);
13241
13242 /**
13243 * generate NOP rules
13244 */
13245
13246 if (kernel_rules_cnt == 0)
13247 {
13248 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13249
13250 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13251
13252 kernel_rules_cnt++;
13253 }
13254
13255 data.kernel_rules_cnt = kernel_rules_cnt;
13256 data.kernel_rules_buf = kernel_rules_buf;
13257
13258 /**
13259 * OpenCL platforms: detect
13260 */
13261
13262 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13263 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13264
13265 cl_uint platforms_cnt = 0;
13266 cl_uint platform_devices_cnt = 0;
13267
13268 if (keyspace == 0)
13269 {
13270 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13271
13272 if (platforms_cnt == 0)
13273 {
13274 log_info ("");
13275 log_info ("ATTENTION! No OpenCL compatible platform found");
13276 log_info ("");
13277 log_info ("You're probably missing the OpenCL runtime installation");
13278 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13279 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13280 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13281 log_info ("");
13282
13283 return (-1);
13284 }
13285
13286 if (opencl_platforms_filter != (uint) -1)
13287 {
13288 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13289
13290 if (opencl_platforms_filter > platform_cnt_mask)
13291 {
13292 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13293
13294 return (-1);
13295 }
13296 }
13297 }
13298
13299 /**
13300 * OpenCL device types:
13301 * 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.
13302 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13303 */
13304
13305 if (opencl_device_types == NULL)
13306 {
13307 cl_device_type device_types_all = 0;
13308
13309 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13310 {
13311 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13312
13313 cl_platform_id platform = platforms[platform_id];
13314
13315 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13316
13317 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13318 {
13319 cl_device_id device = platform_devices[platform_devices_id];
13320
13321 cl_device_type device_type;
13322
13323 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13324
13325 device_types_all |= device_type;
13326 }
13327 }
13328
13329 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13330 {
13331 device_types_filter |= CL_DEVICE_TYPE_CPU;
13332 }
13333 }
13334
13335 /**
13336 * OpenCL devices: simply push all devices from all platforms into the same device array
13337 */
13338
13339 int need_adl = 0;
13340 int need_nvapi = 0;
13341 int need_nvml = 0;
13342
13343 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13344
13345 data.devices_param = devices_param;
13346
13347 uint devices_cnt = 0;
13348
13349 uint devices_active = 0;
13350
13351 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13352 {
13353 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13354
13355 cl_platform_id platform = platforms[platform_id];
13356
13357 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13358
13359 char platform_vendor[INFOSZ] = { 0 };
13360
13361 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13362
13363 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13364 // this causes trouble with vendor id based macros
13365 // we'll assign generic to those without special optimization available
13366
13367 cl_uint platform_vendor_id = 0;
13368
13369 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13370 {
13371 platform_vendor_id = VENDOR_ID_AMD;
13372 }
13373 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13374 {
13375 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13376 }
13377 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13378 {
13379 platform_vendor_id = VENDOR_ID_APPLE;
13380 }
13381 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13382 {
13383 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13384 }
13385 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13386 {
13387 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13388 }
13389 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13390 {
13391 platform_vendor_id = VENDOR_ID_MESA;
13392 }
13393 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13394 {
13395 platform_vendor_id = VENDOR_ID_NV;
13396 }
13397 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13398 {
13399 platform_vendor_id = VENDOR_ID_POCL;
13400 }
13401 else
13402 {
13403 platform_vendor_id = VENDOR_ID_GENERIC;
13404 }
13405
13406 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13407 {
13408 size_t param_value_size = 0;
13409
13410 const uint device_id = devices_cnt;
13411
13412 hc_device_param_t *device_param = &data.devices_param[device_id];
13413
13414 device_param->platform_vendor_id = platform_vendor_id;
13415
13416 device_param->device = platform_devices[platform_devices_id];
13417
13418 device_param->device_id = device_id;
13419
13420 device_param->platform_devices_id = platform_devices_id;
13421
13422 // device_type
13423
13424 cl_device_type device_type;
13425
13426 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13427
13428 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13429
13430 device_param->device_type = device_type;
13431
13432 // device_name
13433
13434 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13435
13436 char *device_name = (char *) mymalloc (param_value_size);
13437
13438 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13439
13440 device_param->device_name = device_name;
13441
13442 // device_vendor
13443
13444 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13445
13446 char *device_vendor = (char *) mymalloc (param_value_size);
13447
13448 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13449
13450 device_param->device_vendor = device_vendor;
13451
13452 cl_uint device_vendor_id = 0;
13453
13454 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13455 {
13456 device_vendor_id = VENDOR_ID_AMD;
13457 }
13458 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13459 {
13460 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13461 }
13462 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13463 {
13464 device_vendor_id = VENDOR_ID_APPLE;
13465 }
13466 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13467 {
13468 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13469 }
13470 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13471 {
13472 device_vendor_id = VENDOR_ID_INTEL_SDK;
13473 }
13474 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13475 {
13476 device_vendor_id = VENDOR_ID_MESA;
13477 }
13478 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13479 {
13480 device_vendor_id = VENDOR_ID_NV;
13481 }
13482 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13483 {
13484 device_vendor_id = VENDOR_ID_POCL;
13485 }
13486 else
13487 {
13488 device_vendor_id = VENDOR_ID_GENERIC;
13489 }
13490
13491 device_param->device_vendor_id = device_vendor_id;
13492
13493 // tuning db
13494
13495 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13496
13497 // device_version
13498
13499 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13500
13501 char *device_version = (char *) mymalloc (param_value_size);
13502
13503 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13504
13505 device_param->device_version = device_version;
13506
13507 // device_opencl_version
13508
13509 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13510
13511 char *device_opencl_version = (char *) mymalloc (param_value_size);
13512
13513 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13514
13515 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13516
13517 myfree (device_opencl_version);
13518
13519 // vector_width
13520
13521 cl_uint vector_width;
13522
13523 if (opencl_vector_width_chgd == 0)
13524 {
13525 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13526 {
13527 if (opti_type & OPTI_TYPE_USES_BITS_64)
13528 {
13529 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13530 }
13531 else
13532 {
13533 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13534 }
13535 }
13536 else
13537 {
13538 vector_width = (cl_uint) tuningdb_entry->vector_width;
13539 }
13540 }
13541 else
13542 {
13543 vector_width = opencl_vector_width;
13544 }
13545
13546 if (vector_width > 16) vector_width = 16;
13547
13548 device_param->vector_width = vector_width;
13549
13550 // max_compute_units
13551
13552 cl_uint device_processors;
13553
13554 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13555
13556 device_param->device_processors = device_processors;
13557
13558 // device_maxmem_alloc
13559 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13560
13561 cl_ulong device_maxmem_alloc;
13562
13563 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13564
13565 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13566
13567 // device_global_mem
13568
13569 cl_ulong device_global_mem;
13570
13571 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13572
13573 device_param->device_global_mem = device_global_mem;
13574
13575 // max_work_group_size
13576
13577 size_t device_maxworkgroup_size;
13578
13579 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13580
13581 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13582
13583 // max_clock_frequency
13584
13585 cl_uint device_maxclock_frequency;
13586
13587 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13588
13589 device_param->device_maxclock_frequency = device_maxclock_frequency;
13590
13591 // device_endian_little
13592
13593 cl_bool device_endian_little;
13594
13595 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13596
13597 if (device_endian_little == CL_FALSE)
13598 {
13599 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13600
13601 device_param->skipped = 1;
13602 }
13603
13604 // device_available
13605
13606 cl_bool device_available;
13607
13608 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13609
13610 if (device_available == CL_FALSE)
13611 {
13612 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13613
13614 device_param->skipped = 1;
13615 }
13616
13617 // device_compiler_available
13618
13619 cl_bool device_compiler_available;
13620
13621 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13622
13623 if (device_compiler_available == CL_FALSE)
13624 {
13625 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13626
13627 device_param->skipped = 1;
13628 }
13629
13630 // device_execution_capabilities
13631
13632 cl_device_exec_capabilities device_execution_capabilities;
13633
13634 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13635
13636 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13637 {
13638 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13639
13640 device_param->skipped = 1;
13641 }
13642
13643 // device_extensions
13644
13645 size_t device_extensions_size;
13646
13647 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13648
13649 char *device_extensions = mymalloc (device_extensions_size + 1);
13650
13651 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13652
13653 if (strstr (device_extensions, "base_atomics") == 0)
13654 {
13655 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13656
13657 device_param->skipped = 1;
13658 }
13659
13660 if (strstr (device_extensions, "byte_addressable_store") == 0)
13661 {
13662 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13663
13664 device_param->skipped = 1;
13665 }
13666
13667 myfree (device_extensions);
13668
13669 // device_local_mem_size
13670
13671 cl_ulong device_local_mem_size;
13672
13673 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13674
13675 if (device_local_mem_size < 32768)
13676 {
13677 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13678
13679 device_param->skipped = 1;
13680 }
13681
13682 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13683 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13684 // This results in both utilizing it for 50%
13685 // However, Intel has much better SIMD control over their own hardware
13686 // It makes sense to give them full control over their own hardware
13687
13688 if (device_type & CL_DEVICE_TYPE_CPU)
13689 {
13690 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13691 {
13692 if (data.force == 0)
13693 {
13694 if (algorithm_pos == 0)
13695 {
13696 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
13697 log_info (" You can use --force to override this but do not post error reports if you do so");
13698 }
13699
13700 device_param->skipped = 1;
13701 }
13702 }
13703 }
13704
13705 // skipped
13706
13707 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13708 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13709
13710 // driver_version
13711
13712 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13713
13714 char *driver_version = (char *) mymalloc (param_value_size);
13715
13716 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13717
13718 device_param->driver_version = driver_version;
13719
13720 // device_name_chksum
13721
13722 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13723
13724 #if __x86_64__
13725 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);
13726 #else
13727 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);
13728 #endif
13729
13730 uint device_name_digest[4] = { 0 };
13731
13732 md5_64 ((uint *) device_name_chksum, device_name_digest);
13733
13734 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13735
13736 device_param->device_name_chksum = device_name_chksum;
13737
13738 // device_processor_cores
13739
13740 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
13741 {
13742 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
13743 {
13744 need_adl = 1;
13745 }
13746
13747 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
13748 {
13749 need_nvml = 1;
13750
13751 #ifdef _WIN
13752 need_nvapi = 1;
13753 #endif
13754 }
13755 }
13756
13757 // device_processor_cores
13758
13759 if (device_type & CL_DEVICE_TYPE_CPU)
13760 {
13761 cl_uint device_processor_cores = 1;
13762
13763 device_param->device_processor_cores = device_processor_cores;
13764 }
13765
13766 if (device_type & CL_DEVICE_TYPE_GPU)
13767 {
13768 if (device_vendor_id == VENDOR_ID_AMD)
13769 {
13770 cl_uint device_processor_cores = 0;
13771
13772 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13773
13774 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13775
13776 device_param->device_processor_cores = device_processor_cores;
13777 }
13778 else if (device_vendor_id == VENDOR_ID_NV)
13779 {
13780 cl_uint kernel_exec_timeout = 0;
13781
13782 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13783
13784 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13785
13786 device_param->kernel_exec_timeout = kernel_exec_timeout;
13787
13788 cl_uint device_processor_cores = 0;
13789
13790 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13791
13792 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13793
13794 device_param->device_processor_cores = device_processor_cores;
13795
13796 cl_uint sm_minor = 0;
13797 cl_uint sm_major = 0;
13798
13799 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13800 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13801
13802 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13803 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13804
13805 device_param->sm_minor = sm_minor;
13806 device_param->sm_major = sm_major;
13807 }
13808 else
13809 {
13810 cl_uint device_processor_cores = 1;
13811
13812 device_param->device_processor_cores = device_processor_cores;
13813 }
13814 }
13815
13816 // display results
13817
13818 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13819 {
13820 if (machine_readable == 0)
13821 {
13822 if (device_param->skipped == 0)
13823 {
13824 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13825 device_id + 1,
13826 device_name,
13827 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13828 (unsigned int) (device_global_mem / 1024 / 1024),
13829 (unsigned int) device_processors);
13830 }
13831 else
13832 {
13833 log_info ("Device #%u: %s, skipped",
13834 device_id + 1,
13835 device_name);
13836 }
13837 }
13838 }
13839
13840 // common driver check
13841
13842 if (device_param->skipped == 0)
13843 {
13844 if (device_type & CL_DEVICE_TYPE_GPU)
13845 {
13846 if (platform_vendor_id == VENDOR_ID_AMD)
13847 {
13848 int catalyst_check = (force == 1) ? 0 : 1;
13849
13850 int catalyst_warn = 0;
13851
13852 int catalyst_broken = 0;
13853
13854 if (catalyst_check == 1)
13855 {
13856 catalyst_warn = 1;
13857
13858 // v14.9 and higher
13859 if (atoi (device_param->driver_version) >= 1573)
13860 {
13861 catalyst_warn = 0;
13862 }
13863
13864 catalyst_check = 0;
13865 }
13866
13867 if (catalyst_broken == 1)
13868 {
13869 log_info ("");
13870 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13871 log_info ("It will pass over cracked hashes and does not report them as cracked");
13872 log_info ("You are STRONGLY encouraged not to use it");
13873 log_info ("You can use --force to override this but do not post error reports if you do so");
13874 log_info ("");
13875
13876 return (-1);
13877 }
13878
13879 if (catalyst_warn == 1)
13880 {
13881 log_info ("");
13882 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13883 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13884 log_info ("See hashcat's homepage for official supported catalyst drivers");
13885 #ifdef _WIN
13886 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13887 #endif
13888 log_info ("You can use --force to override this but do not post error reports if you do so");
13889 log_info ("");
13890
13891 return (-1);
13892 }
13893 }
13894 else if (platform_vendor_id == VENDOR_ID_NV)
13895 {
13896 if (device_param->kernel_exec_timeout != 0)
13897 {
13898 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);
13899 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13900 }
13901 }
13902 }
13903
13904 /* turns out pocl still creates segfaults (because of llvm)
13905 if (device_type & CL_DEVICE_TYPE_CPU)
13906 {
13907 if (platform_vendor_id == VENDOR_ID_AMD)
13908 {
13909 if (force == 0)
13910 {
13911 log_info ("");
13912 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13913 log_info ("You are STRONGLY encouraged not to use it");
13914 log_info ("You can use --force to override this but do not post error reports if you do so");
13915 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13916 log_info ("");
13917
13918 return (-1);
13919 }
13920 }
13921 }
13922 */
13923
13924 /**
13925 * kernel accel and loops tuning db adjustment
13926 */
13927
13928 device_param->kernel_accel_min = 1;
13929 device_param->kernel_accel_max = 1024;
13930
13931 device_param->kernel_loops_min = 1;
13932 device_param->kernel_loops_max = 1024;
13933
13934 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13935
13936 if (tuningdb_entry)
13937 {
13938 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13939 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13940
13941 if (_kernel_accel)
13942 {
13943 device_param->kernel_accel_min = _kernel_accel;
13944 device_param->kernel_accel_max = _kernel_accel;
13945 }
13946
13947 if (_kernel_loops)
13948 {
13949 if (workload_profile == 1)
13950 {
13951 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13952 }
13953 else if (workload_profile == 2)
13954 {
13955 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13956 }
13957
13958 device_param->kernel_loops_min = _kernel_loops;
13959 device_param->kernel_loops_max = _kernel_loops;
13960 }
13961 }
13962
13963 // commandline parameters overwrite tuningdb entries
13964
13965 if (kernel_accel)
13966 {
13967 device_param->kernel_accel_min = kernel_accel;
13968 device_param->kernel_accel_max = kernel_accel;
13969 }
13970
13971 if (kernel_loops)
13972 {
13973 device_param->kernel_loops_min = kernel_loops;
13974 device_param->kernel_loops_max = kernel_loops;
13975 }
13976
13977 /**
13978 * activate device
13979 */
13980
13981 devices_active++;
13982 }
13983
13984 // next please
13985
13986 devices_cnt++;
13987 }
13988 }
13989
13990 if (keyspace == 0 && devices_active == 0)
13991 {
13992 log_error ("ERROR: No devices found/left");
13993
13994 return (-1);
13995 }
13996
13997 // 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)
13998
13999 if (devices_filter != (uint) -1)
14000 {
14001 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14002
14003 if (devices_filter > devices_cnt_mask)
14004 {
14005 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14006
14007 return (-1);
14008 }
14009 }
14010
14011 data.devices_cnt = devices_cnt;
14012
14013 data.devices_active = devices_active;
14014
14015 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14016 {
14017 if (machine_readable == 0)
14018 {
14019 log_info ("");
14020 }
14021 }
14022
14023 /**
14024 * HM devices: init
14025 */
14026
14027 #ifdef HAVE_HWMON
14028 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14029 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14030 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14031
14032 if (gpu_temp_disable == 0)
14033 {
14034 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14035 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14036 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14037
14038 data.hm_adl = NULL;
14039 data.hm_nvapi = NULL;
14040 data.hm_nvml = NULL;
14041
14042 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14043 {
14044 data.hm_nvml = nvml;
14045 }
14046
14047 if (data.hm_nvml)
14048 {
14049 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14050 {
14051 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14052
14053 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14054
14055 int tmp_out = 0;
14056
14057 for (int i = 0; i < tmp_in; i++)
14058 {
14059 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14060 }
14061
14062 for (int i = 0; i < tmp_out; i++)
14063 {
14064 unsigned int speed;
14065
14066 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14067
14068 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14069
14070 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14071 }
14072 }
14073 }
14074
14075 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14076 {
14077 data.hm_nvapi = nvapi;
14078 }
14079
14080 if (data.hm_nvapi)
14081 {
14082 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14083 {
14084 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14085
14086 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14087
14088 int tmp_out = 0;
14089
14090 for (int i = 0; i < tmp_in; i++)
14091 {
14092 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14093 }
14094 }
14095 }
14096
14097 if ((need_adl == 1) && (adl_init (adl) == 0))
14098 {
14099 data.hm_adl = adl;
14100 }
14101
14102 if (data.hm_adl)
14103 {
14104 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14105 {
14106 // total number of adapters
14107
14108 int hm_adapters_num;
14109
14110 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14111
14112 // adapter info
14113
14114 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14115
14116 if (lpAdapterInfo == NULL) return (-1);
14117
14118 // get a list (of ids of) valid/usable adapters
14119
14120 int num_adl_adapters = 0;
14121
14122 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14123
14124 if (num_adl_adapters > 0)
14125 {
14126 hc_thread_mutex_lock (mux_adl);
14127
14128 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14129
14130 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14131
14132 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14133 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14134
14135 hc_thread_mutex_unlock (mux_adl);
14136 }
14137
14138 myfree (valid_adl_device_list);
14139 myfree (lpAdapterInfo);
14140 }
14141 }
14142
14143 if (data.hm_adl == NULL && data.hm_nvml == NULL)
14144 {
14145 gpu_temp_disable = 1;
14146 }
14147 }
14148
14149 /**
14150 * OpenCL devices: allocate buffer for device specific information
14151 */
14152
14153 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14154 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14155
14156 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14157
14158 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14159
14160 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14161
14162 /**
14163 * User-defined GPU temp handling
14164 */
14165
14166 if (gpu_temp_disable == 1)
14167 {
14168 gpu_temp_abort = 0;
14169 gpu_temp_retain = 0;
14170 }
14171
14172 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14173 {
14174 if (gpu_temp_abort < gpu_temp_retain)
14175 {
14176 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14177
14178 return (-1);
14179 }
14180 }
14181
14182 data.gpu_temp_disable = gpu_temp_disable;
14183 data.gpu_temp_abort = gpu_temp_abort;
14184 data.gpu_temp_retain = gpu_temp_retain;
14185 #endif
14186
14187 /**
14188 * enable custom signal handler(s)
14189 */
14190
14191 if (benchmark == 0)
14192 {
14193 hc_signal (sigHandler_default);
14194 }
14195 else
14196 {
14197 hc_signal (sigHandler_benchmark);
14198 }
14199
14200 /**
14201 * inform the user
14202 */
14203
14204 if (data.quiet == 0)
14205 {
14206 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14207
14208 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);
14209
14210 if (attack_mode == ATTACK_MODE_STRAIGHT)
14211 {
14212 log_info ("Rules: %u", kernel_rules_cnt);
14213 }
14214
14215 if (opti_type)
14216 {
14217 log_info ("Applicable Optimizers:");
14218
14219 for (uint i = 0; i < 32; i++)
14220 {
14221 const uint opti_bit = 1u << i;
14222
14223 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14224 }
14225 }
14226
14227 /**
14228 * Watchdog and Temperature balance
14229 */
14230
14231 #ifdef HAVE_HWMON
14232 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
14233 {
14234 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14235 }
14236
14237 if (gpu_temp_abort == 0)
14238 {
14239 log_info ("Watchdog: Temperature abort trigger disabled");
14240 }
14241 else
14242 {
14243 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14244 }
14245
14246 if (gpu_temp_retain == 0)
14247 {
14248 log_info ("Watchdog: Temperature retain trigger disabled");
14249 }
14250 else
14251 {
14252 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14253 }
14254
14255 if (data.quiet == 0) log_info ("");
14256 #endif
14257 }
14258
14259 #ifdef HAVE_HWMON
14260
14261 /**
14262 * HM devices: copy
14263 */
14264
14265 if (gpu_temp_disable == 0)
14266 {
14267 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14268 {
14269 hc_device_param_t *device_param = &data.devices_param[device_id];
14270
14271 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14272
14273 if (device_param->skipped) continue;
14274
14275 const uint platform_devices_id = device_param->platform_devices_id;
14276
14277 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14278 {
14279 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14280 data.hm_device[device_id].nvapi = 0;
14281 data.hm_device[device_id].nvml = 0;
14282 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14283 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14284 data.hm_device[device_id].fan_set_supported = hm_adapters_adl[platform_devices_id].fan_set_supported;
14285 }
14286
14287 if (device_param->device_vendor_id == VENDOR_ID_NV)
14288 {
14289 data.hm_device[device_id].adl = 0;
14290 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14291 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14292 data.hm_device[device_id].od_version = 0;
14293 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14294 data.hm_device[device_id].fan_set_supported = 0;
14295 }
14296 }
14297 }
14298
14299 /**
14300 * powertune on user request
14301 */
14302
14303 if (powertune_enable == 1)
14304 {
14305 hc_thread_mutex_lock (mux_adl);
14306
14307 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14308 {
14309 hc_device_param_t *device_param = &data.devices_param[device_id];
14310
14311 if (device_param->skipped) continue;
14312
14313 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14314 {
14315 /**
14316 * Temporary fix:
14317 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14318 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14319 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14320 * Driver / ADL bug?
14321 */
14322
14323 if (data.hm_device[device_id].od_version == 6)
14324 {
14325 int ADL_rc;
14326
14327 // check powertune capabilities first, if not available then skip device
14328
14329 int powertune_supported = 0;
14330
14331 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14332 {
14333 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14334
14335 return (-1);
14336 }
14337
14338 // first backup current value, we will restore it later
14339
14340 if (powertune_supported != 0)
14341 {
14342 // powercontrol settings
14343
14344 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14345
14346 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14347 {
14348 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14349 }
14350
14351 if (ADL_rc != ADL_OK)
14352 {
14353 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14354
14355 return (-1);
14356 }
14357
14358 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14359 {
14360 log_error ("ERROR: Failed to set new ADL PowerControl values");
14361
14362 return (-1);
14363 }
14364
14365 // clocks
14366
14367 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14368
14369 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14370
14371 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)
14372 {
14373 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14374
14375 return (-1);
14376 }
14377
14378 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14379
14380 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14381
14382 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14383 {
14384 log_error ("ERROR: Failed to get ADL device capabilities");
14385
14386 return (-1);
14387 }
14388
14389 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14390 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14391
14392 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14393 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14394
14395 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14396 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14397
14398 // warning if profile has too low max values
14399
14400 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14401 {
14402 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14403 }
14404
14405 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14406 {
14407 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14408 }
14409
14410 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14411
14412 performance_state->iNumberOfPerformanceLevels = 2;
14413
14414 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14415 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14416 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14417 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14418
14419 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)
14420 {
14421 log_info ("ERROR: Failed to set ADL performance state");
14422
14423 return (-1);
14424 }
14425
14426 local_free (performance_state);
14427 }
14428
14429 // set powertune value only
14430
14431 if (powertune_supported != 0)
14432 {
14433 // powertune set
14434 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14435
14436 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14437 {
14438 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14439
14440 return (-1);
14441 }
14442
14443 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14444 {
14445 log_error ("ERROR: Failed to set new ADL PowerControl values");
14446
14447 return (-1);
14448 }
14449 }
14450 }
14451 }
14452
14453 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14454 {
14455 // first backup current value, we will restore it later
14456
14457 unsigned int limit;
14458
14459 int powertune_supported = 0;
14460
14461 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14462 {
14463 powertune_supported = 1;
14464 }
14465
14466 // if backup worked, activate the maximum allowed
14467
14468 if (powertune_supported != 0)
14469 {
14470 unsigned int minLimit;
14471 unsigned int maxLimit;
14472
14473 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14474 {
14475 if (maxLimit > 0)
14476 {
14477 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14478 {
14479 // now we can be sure we need to reset later
14480
14481 nvml_power_limit[device_id] = limit;
14482 }
14483 }
14484 }
14485 }
14486 }
14487 }
14488
14489 hc_thread_mutex_unlock (mux_adl);
14490 }
14491
14492 #endif // HAVE_HWMON
14493
14494 #ifdef DEBUG
14495 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14496 #endif
14497
14498 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14499
14500 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14501 {
14502 /**
14503 * host buffer
14504 */
14505
14506 hc_device_param_t *device_param = &data.devices_param[device_id];
14507
14508 if (device_param->skipped) continue;
14509
14510 /**
14511 * device properties
14512 */
14513
14514 const char *device_name_chksum = device_param->device_name_chksum;
14515 const u32 device_processors = device_param->device_processors;
14516 const u32 device_processor_cores = device_param->device_processor_cores;
14517
14518 /**
14519 * create context for each device
14520 */
14521
14522 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14523
14524 /**
14525 * create command-queue
14526 */
14527
14528 // not supported with NV
14529 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14530
14531 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14532
14533 /**
14534 * kernel threads: some algorithms need a fixed kernel-threads count
14535 * because of shared memory usage or bitslice
14536 * there needs to be some upper limit, otherwise there's too much overhead
14537 */
14538
14539 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14540
14541 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14542 {
14543 kernel_threads = KERNEL_THREADS_MAX_CPU;
14544 }
14545
14546 if (hash_mode == 1500) kernel_threads = 64; // DES
14547 if (hash_mode == 3000) kernel_threads = 64; // DES
14548 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14549 if (hash_mode == 7500) kernel_threads = 64; // RC4
14550 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14551 if (hash_mode == 9700) kernel_threads = 64; // RC4
14552 if (hash_mode == 9710) kernel_threads = 64; // RC4
14553 if (hash_mode == 9800) kernel_threads = 64; // RC4
14554 if (hash_mode == 9810) kernel_threads = 64; // RC4
14555 if (hash_mode == 10400) kernel_threads = 64; // RC4
14556 if (hash_mode == 10410) kernel_threads = 64; // RC4
14557 if (hash_mode == 10500) kernel_threads = 64; // RC4
14558 if (hash_mode == 13100) kernel_threads = 64; // RC4
14559
14560 device_param->kernel_threads = kernel_threads;
14561
14562 /**
14563 * create input buffers on device : calculate size of fixed memory buffers
14564 */
14565
14566 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14567 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14568
14569 device_param->size_root_css = size_root_css;
14570 device_param->size_markov_css = size_markov_css;
14571
14572 size_t size_results = sizeof (uint);
14573
14574 device_param->size_results = size_results;
14575
14576 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14577 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14578
14579 size_t size_plains = digests_cnt * sizeof (plain_t);
14580 size_t size_salts = salts_cnt * sizeof (salt_t);
14581 size_t size_esalts = salts_cnt * esalt_size;
14582
14583 device_param->size_plains = size_plains;
14584 device_param->size_digests = size_digests;
14585 device_param->size_shown = size_shown;
14586 device_param->size_salts = size_salts;
14587
14588 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14589 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14590 size_t size_tm = 32 * sizeof (bs_word_t);
14591
14592 // scryptV stuff
14593
14594 size_t size_scryptV = 1;
14595
14596 if ((hash_mode == 8900) || (hash_mode == 9300))
14597 {
14598 uint tmto_start = 0;
14599 uint tmto_stop = 10;
14600
14601 if (scrypt_tmto)
14602 {
14603 tmto_start = scrypt_tmto;
14604 }
14605 else
14606 {
14607 // in case the user did not specify the tmto manually
14608 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14609 // but set the lower end only in case the user has a device with too less memory
14610
14611 if (hash_mode == 8900)
14612 {
14613 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14614 {
14615 tmto_start = 1;
14616 }
14617 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14618 {
14619 tmto_start = 2;
14620 }
14621 }
14622 else if (hash_mode == 9300)
14623 {
14624 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14625 {
14626 tmto_start = 2;
14627 }
14628 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14629 {
14630 tmto_start = 2;
14631 }
14632 }
14633 }
14634
14635 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14636 {
14637 // TODO: in theory the following calculation needs to be done per salt, not global
14638 // we assume all hashes have the same scrypt settings
14639
14640 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14641
14642 size_scryptV /= 1 << tmto;
14643
14644 size_scryptV *= device_processors * device_processor_cores;
14645
14646 if (size_scryptV > device_param->device_maxmem_alloc)
14647 {
14648 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14649
14650 continue;
14651 }
14652
14653 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14654 {
14655 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14656 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14657 }
14658
14659 break;
14660 }
14661
14662 if (data.salts_buf[0].scrypt_phy == 0)
14663 {
14664 log_error ("ERROR: can't allocate enough device memory");
14665
14666 return -1;
14667 }
14668
14669 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14670 }
14671
14672 /**
14673 * some algorithms need a fixed kernel-loops count
14674 */
14675
14676 if (hash_mode == 1500)
14677 {
14678 const u32 kernel_loops_fixed = 1024;
14679
14680 device_param->kernel_loops_min = kernel_loops_fixed;
14681 device_param->kernel_loops_max = kernel_loops_fixed;
14682 }
14683
14684 if (hash_mode == 3000)
14685 {
14686 const u32 kernel_loops_fixed = 1024;
14687
14688 device_param->kernel_loops_min = kernel_loops_fixed;
14689 device_param->kernel_loops_max = kernel_loops_fixed;
14690 }
14691
14692 if (hash_mode == 8900)
14693 {
14694 const u32 kernel_loops_fixed = 1;
14695
14696 device_param->kernel_loops_min = kernel_loops_fixed;
14697 device_param->kernel_loops_max = kernel_loops_fixed;
14698 }
14699
14700 if (hash_mode == 9300)
14701 {
14702 const u32 kernel_loops_fixed = 1;
14703
14704 device_param->kernel_loops_min = kernel_loops_fixed;
14705 device_param->kernel_loops_max = kernel_loops_fixed;
14706 }
14707
14708 if (hash_mode == 12500)
14709 {
14710 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14711
14712 device_param->kernel_loops_min = kernel_loops_fixed;
14713 device_param->kernel_loops_max = kernel_loops_fixed;
14714 }
14715
14716 /**
14717 * some algorithms have a maximum kernel-loops count
14718 */
14719
14720 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14721 {
14722 u32 innerloop_cnt = 0;
14723
14724 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14725 {
14726 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14727 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14728 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14729 }
14730 else
14731 {
14732 innerloop_cnt = data.salts_buf[0].salt_iter;
14733 }
14734
14735 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14736 (innerloop_cnt <= device_param->kernel_loops_max))
14737 {
14738 device_param->kernel_loops_max = innerloop_cnt;
14739 }
14740 }
14741
14742 u32 kernel_accel_min = device_param->kernel_accel_min;
14743 u32 kernel_accel_max = device_param->kernel_accel_max;
14744
14745 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14746
14747 size_t size_pws = 4;
14748 size_t size_tmps = 4;
14749 size_t size_hooks = 4;
14750
14751 while (kernel_accel_max >= kernel_accel_min)
14752 {
14753 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14754
14755 // size_pws
14756
14757 size_pws = kernel_power_max * sizeof (pw_t);
14758
14759 // size_tmps
14760
14761 switch (hash_mode)
14762 {
14763 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14764 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14765 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14766 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14767 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14768 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14769 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14770 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14771 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14772 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14773 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14774 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14775 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14776 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14777 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14778 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14779 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14780 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14781 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14782 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14783 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14784 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14785 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14786 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14787 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14788 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14789 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14790 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14791 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14792 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14793 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14794 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14795 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14796 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14797 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14798 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14799 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14800 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14801 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14802 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14803 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14804 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14805 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14806 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14807 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14808 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14809 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14810 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14811 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14812 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14813 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14814 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14815 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14816 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14817 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14818 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14819 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14820 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14821 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14822 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14823 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14824 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14825 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14826 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14827 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14828 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14829 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14830 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14831 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14832 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14833 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14834 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14835 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14836 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14837 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14838 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14839 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14840 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14841 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14842 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14843 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14844 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14845 };
14846
14847 // size_hooks
14848
14849 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14850 {
14851 // none yet
14852 }
14853
14854 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14855 // if not, decrease amplifier and try again
14856
14857 int skip = 0;
14858
14859 const u64 size_total
14860 = bitmap_size
14861 + bitmap_size
14862 + bitmap_size
14863 + bitmap_size
14864 + bitmap_size
14865 + bitmap_size
14866 + bitmap_size
14867 + bitmap_size
14868 + size_bfs
14869 + size_combs
14870 + size_digests
14871 + size_esalts
14872 + size_hooks
14873 + size_markov_css
14874 + size_plains
14875 + size_pws
14876 + size_pws // not a bug
14877 + size_results
14878 + size_root_css
14879 + size_rules
14880 + size_rules_c
14881 + size_salts
14882 + size_scryptV
14883 + size_shown
14884 + size_tm
14885 + size_tmps;
14886
14887 // Don't ask me, ask AMD!
14888
14889 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14890 if (size_total > device_param->device_global_mem) skip = 1;
14891
14892 if (skip == 1)
14893 {
14894 kernel_accel_max--;
14895
14896 continue;
14897 }
14898
14899 break;
14900 }
14901
14902 /*
14903 if (kernel_accel_max == 0)
14904 {
14905 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14906
14907 return -1;
14908 }
14909 */
14910
14911 device_param->kernel_accel_min = kernel_accel_min;
14912 device_param->kernel_accel_max = kernel_accel_max;
14913
14914 /*
14915 if (kernel_accel_max < kernel_accel)
14916 {
14917 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14918
14919 device_param->kernel_accel = kernel_accel_max;
14920 }
14921 */
14922
14923 device_param->size_bfs = size_bfs;
14924 device_param->size_combs = size_combs;
14925 device_param->size_rules = size_rules;
14926 device_param->size_rules_c = size_rules_c;
14927 device_param->size_pws = size_pws;
14928 device_param->size_tmps = size_tmps;
14929 device_param->size_hooks = size_hooks;
14930
14931 /**
14932 * default building options
14933 */
14934
14935 char build_opts[1024] = { 0 };
14936
14937 // we don't have sm_* on vendors not NV but it doesn't matter
14938
14939 #if _WIN
14940 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);
14941 #else
14942 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);
14943 #endif
14944
14945 char build_opts_new[1024] = { 0 };
14946
14947 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);
14948
14949 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14950
14951 /*
14952 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14953 {
14954 // we do vectorizing much better than the auto-vectorizer
14955
14956 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14957
14958 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14959 }
14960 */
14961
14962 #ifdef DEBUG
14963 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14964 #endif
14965
14966 /**
14967 * main kernel
14968 */
14969
14970 {
14971 /**
14972 * kernel source filename
14973 */
14974
14975 char source_file[256] = { 0 };
14976
14977 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14978
14979 struct stat sst;
14980
14981 if (stat (source_file, &sst) == -1)
14982 {
14983 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14984
14985 return -1;
14986 }
14987
14988 /**
14989 * kernel cached filename
14990 */
14991
14992 char cached_file[256] = { 0 };
14993
14994 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14995
14996 int cached = 1;
14997
14998 struct stat cst;
14999
15000 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15001 {
15002 cached = 0;
15003 }
15004
15005 /**
15006 * kernel compile or load
15007 */
15008
15009 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15010
15011 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15012
15013 if (force_jit_compilation == -1)
15014 {
15015 if (cached == 0)
15016 {
15017 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15018
15019 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15020
15021 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15022
15023 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15024
15025 #ifdef DEBUG
15026 size_t build_log_size = 0;
15027
15028 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15029
15030 if (build_log_size > 1)
15031 {
15032 char *build_log = (char *) malloc (build_log_size + 1);
15033
15034 memset (build_log, 0, build_log_size + 1);
15035
15036 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15037
15038 puts (build_log);
15039
15040 free (build_log);
15041 }
15042 #endif
15043
15044 if (rc != 0)
15045 {
15046 device_param->skipped = true;
15047
15048 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15049
15050 continue;
15051 }
15052
15053 size_t binary_size;
15054
15055 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15056
15057 u8 *binary = (u8 *) mymalloc (binary_size);
15058
15059 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15060
15061 writeProgramBin (cached_file, binary, binary_size);
15062
15063 local_free (binary);
15064 }
15065 else
15066 {
15067 #ifdef DEBUG
15068 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15069 #endif
15070
15071 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15072
15073 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15074
15075 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15076 }
15077 }
15078 else
15079 {
15080 #ifdef DEBUG
15081 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15082 #endif
15083
15084 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15085
15086 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15087
15088 char build_opts_update[1024] = { 0 };
15089
15090 if (force_jit_compilation == 1500)
15091 {
15092 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15093 }
15094 else if (force_jit_compilation == 8900)
15095 {
15096 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);
15097 }
15098 else
15099 {
15100 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15101 }
15102
15103 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15104
15105 #ifdef DEBUG
15106 size_t build_log_size = 0;
15107
15108 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15109
15110 if (build_log_size > 1)
15111 {
15112 char *build_log = (char *) malloc (build_log_size + 1);
15113
15114 memset (build_log, 0, build_log_size + 1);
15115
15116 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15117
15118 puts (build_log);
15119
15120 free (build_log);
15121 }
15122 #endif
15123
15124 if (rc != 0)
15125 {
15126 device_param->skipped = true;
15127
15128 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15129 }
15130 }
15131
15132 local_free (kernel_lengths);
15133 local_free (kernel_sources[0]);
15134 local_free (kernel_sources);
15135 }
15136
15137 /**
15138 * word generator kernel
15139 */
15140
15141 if (attack_mode != ATTACK_MODE_STRAIGHT)
15142 {
15143 /**
15144 * kernel mp source filename
15145 */
15146
15147 char source_file[256] = { 0 };
15148
15149 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15150
15151 struct stat sst;
15152
15153 if (stat (source_file, &sst) == -1)
15154 {
15155 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15156
15157 return -1;
15158 }
15159
15160 /**
15161 * kernel mp cached filename
15162 */
15163
15164 char cached_file[256] = { 0 };
15165
15166 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15167
15168 int cached = 1;
15169
15170 struct stat cst;
15171
15172 if (stat (cached_file, &cst) == -1)
15173 {
15174 cached = 0;
15175 }
15176
15177 /**
15178 * kernel compile or load
15179 */
15180
15181 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15182
15183 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15184
15185 if (cached == 0)
15186 {
15187 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15188 if (quiet == 0) log_info ("");
15189
15190 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15191
15192 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15193
15194 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15195
15196 if (rc != 0)
15197 {
15198 device_param->skipped = true;
15199
15200 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15201
15202 continue;
15203 }
15204
15205 size_t binary_size;
15206
15207 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15208
15209 u8 *binary = (u8 *) mymalloc (binary_size);
15210
15211 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15212
15213 writeProgramBin (cached_file, binary, binary_size);
15214
15215 local_free (binary);
15216 }
15217 else
15218 {
15219 #ifdef DEBUG
15220 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15221 #endif
15222
15223 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15224
15225 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15226
15227 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15228 }
15229
15230 local_free (kernel_lengths);
15231 local_free (kernel_sources[0]);
15232 local_free (kernel_sources);
15233 }
15234
15235 /**
15236 * amplifier kernel
15237 */
15238
15239 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15240 {
15241
15242 }
15243 else
15244 {
15245 /**
15246 * kernel amp source filename
15247 */
15248
15249 char source_file[256] = { 0 };
15250
15251 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15252
15253 struct stat sst;
15254
15255 if (stat (source_file, &sst) == -1)
15256 {
15257 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15258
15259 return -1;
15260 }
15261
15262 /**
15263 * kernel amp cached filename
15264 */
15265
15266 char cached_file[256] = { 0 };
15267
15268 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15269
15270 int cached = 1;
15271
15272 struct stat cst;
15273
15274 if (stat (cached_file, &cst) == -1)
15275 {
15276 cached = 0;
15277 }
15278
15279 /**
15280 * kernel compile or load
15281 */
15282
15283 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15284
15285 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15286
15287 if (cached == 0)
15288 {
15289 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15290 if (quiet == 0) log_info ("");
15291
15292 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15293
15294 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15295
15296 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15297
15298 if (rc != 0)
15299 {
15300 device_param->skipped = true;
15301
15302 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15303
15304 continue;
15305 }
15306
15307 size_t binary_size;
15308
15309 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15310
15311 u8 *binary = (u8 *) mymalloc (binary_size);
15312
15313 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15314
15315 writeProgramBin (cached_file, binary, binary_size);
15316
15317 local_free (binary);
15318 }
15319 else
15320 {
15321 #ifdef DEBUG
15322 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15323 #endif
15324
15325 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15326
15327 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15328
15329 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15330 }
15331
15332 local_free (kernel_lengths);
15333 local_free (kernel_sources[0]);
15334 local_free (kernel_sources);
15335 }
15336
15337 // some algorithm collide too fast, make that impossible
15338
15339 if (benchmark == 1)
15340 {
15341 ((uint *) digests_buf)[0] = -1;
15342 ((uint *) digests_buf)[1] = -1;
15343 ((uint *) digests_buf)[2] = -1;
15344 ((uint *) digests_buf)[3] = -1;
15345 }
15346
15347 /**
15348 * global buffers
15349 */
15350
15351 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15352 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15353 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15354 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15355 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15356 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15357 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15358 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15359 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15360 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15361 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15362 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15363 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15364 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15365 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15366 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15367 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15368 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15369
15370 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);
15371 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);
15372 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);
15373 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);
15374 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);
15375 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);
15376 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);
15377 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);
15378 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15379 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15380 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15381
15382 /**
15383 * special buffers
15384 */
15385
15386 if (attack_kern == ATTACK_KERN_STRAIGHT)
15387 {
15388 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15389 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15390
15391 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15392 }
15393 else if (attack_kern == ATTACK_KERN_COMBI)
15394 {
15395 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15396 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15397 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15398 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15399 }
15400 else if (attack_kern == ATTACK_KERN_BF)
15401 {
15402 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15403 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15404 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15405 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15406 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15407 }
15408
15409 if (size_esalts)
15410 {
15411 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15412
15413 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15414 }
15415
15416 /**
15417 * main host data
15418 */
15419
15420 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15421
15422 device_param->pws_buf = pws_buf;
15423
15424 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15425
15426 device_param->combs_buf = combs_buf;
15427
15428 void *hooks_buf = mymalloc (size_hooks);
15429
15430 device_param->hooks_buf = hooks_buf;
15431
15432 /**
15433 * kernel args
15434 */
15435
15436 device_param->kernel_params_buf32[21] = bitmap_mask;
15437 device_param->kernel_params_buf32[22] = bitmap_shift1;
15438 device_param->kernel_params_buf32[23] = bitmap_shift2;
15439 device_param->kernel_params_buf32[24] = 0; // salt_pos
15440 device_param->kernel_params_buf32[25] = 0; // loop_pos
15441 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15442 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15443 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15444 device_param->kernel_params_buf32[29] = 0; // digests_offset
15445 device_param->kernel_params_buf32[30] = 0; // combs_mode
15446 device_param->kernel_params_buf32[31] = 0; // gid_max
15447
15448 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15449 ? &device_param->d_pws_buf
15450 : &device_param->d_pws_amp_buf;
15451 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15452 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15453 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15454 device_param->kernel_params[ 4] = &device_param->d_tmps;
15455 device_param->kernel_params[ 5] = &device_param->d_hooks;
15456 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15457 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15458 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15459 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15460 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15461 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15462 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15463 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15464 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15465 device_param->kernel_params[15] = &device_param->d_digests_buf;
15466 device_param->kernel_params[16] = &device_param->d_digests_shown;
15467 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15468 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15469 device_param->kernel_params[19] = &device_param->d_result;
15470 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15471 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15472 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15473 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15474 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15475 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15476 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15477 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15478 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15479 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15480 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15481 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15482
15483 device_param->kernel_params_mp_buf64[3] = 0;
15484 device_param->kernel_params_mp_buf32[4] = 0;
15485 device_param->kernel_params_mp_buf32[5] = 0;
15486 device_param->kernel_params_mp_buf32[6] = 0;
15487 device_param->kernel_params_mp_buf32[7] = 0;
15488 device_param->kernel_params_mp_buf32[8] = 0;
15489
15490 device_param->kernel_params_mp[0] = NULL;
15491 device_param->kernel_params_mp[1] = NULL;
15492 device_param->kernel_params_mp[2] = NULL;
15493 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15494 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15495 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15496 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15497 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15498 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15499
15500 device_param->kernel_params_mp_l_buf64[3] = 0;
15501 device_param->kernel_params_mp_l_buf32[4] = 0;
15502 device_param->kernel_params_mp_l_buf32[5] = 0;
15503 device_param->kernel_params_mp_l_buf32[6] = 0;
15504 device_param->kernel_params_mp_l_buf32[7] = 0;
15505 device_param->kernel_params_mp_l_buf32[8] = 0;
15506 device_param->kernel_params_mp_l_buf32[9] = 0;
15507
15508 device_param->kernel_params_mp_l[0] = NULL;
15509 device_param->kernel_params_mp_l[1] = NULL;
15510 device_param->kernel_params_mp_l[2] = NULL;
15511 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15512 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15513 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15514 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15515 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15516 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15517 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15518
15519 device_param->kernel_params_mp_r_buf64[3] = 0;
15520 device_param->kernel_params_mp_r_buf32[4] = 0;
15521 device_param->kernel_params_mp_r_buf32[5] = 0;
15522 device_param->kernel_params_mp_r_buf32[6] = 0;
15523 device_param->kernel_params_mp_r_buf32[7] = 0;
15524 device_param->kernel_params_mp_r_buf32[8] = 0;
15525
15526 device_param->kernel_params_mp_r[0] = NULL;
15527 device_param->kernel_params_mp_r[1] = NULL;
15528 device_param->kernel_params_mp_r[2] = NULL;
15529 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15530 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15531 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15532 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15533 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15534 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15535
15536 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15537 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15538
15539 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15540 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15541 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15542 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15543 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15544 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15545 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15546
15547 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15548 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15549
15550 device_param->kernel_params_memset_buf32[1] = 0; // value
15551 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15552
15553 device_param->kernel_params_memset[0] = NULL;
15554 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15555 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15556
15557 /**
15558 * kernel name
15559 */
15560
15561 size_t kernel_wgs_tmp;
15562
15563 char kernel_name[64] = { 0 };
15564
15565 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15566 {
15567 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15568 {
15569 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15570
15571 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15572
15573 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15574
15575 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15576
15577 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15578
15579 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15580 }
15581 else
15582 {
15583 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15584
15585 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15586
15587 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15588
15589 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15590
15591 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15592
15593 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15594 }
15595
15596 if (data.attack_mode == ATTACK_MODE_BF)
15597 {
15598 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15599 {
15600 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15601
15602 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15603
15604 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);
15605 }
15606 }
15607 }
15608 else
15609 {
15610 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15611
15612 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15613
15614 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15615
15616 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15617
15618 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15619
15620 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15621
15622 if (opts_type & OPTS_TYPE_HOOK12)
15623 {
15624 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15625
15626 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15627
15628 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);
15629 }
15630
15631 if (opts_type & OPTS_TYPE_HOOK23)
15632 {
15633 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15634
15635 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15636
15637 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);
15638 }
15639 }
15640
15641 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);
15642 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);
15643 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);
15644
15645 for (uint i = 0; i <= 20; i++)
15646 {
15647 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15648 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15649 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15650
15651 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15652 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15653 }
15654
15655 for (uint i = 21; i <= 31; i++)
15656 {
15657 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15658 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15659 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15660
15661 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15662 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15663 }
15664
15665 // GPU memset
15666
15667 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15668
15669 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);
15670
15671 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15672 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15673 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15674
15675 // MP start
15676
15677 if (attack_mode == ATTACK_MODE_BF)
15678 {
15679 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15680 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15681
15682 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);
15683 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);
15684
15685 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15686 {
15687 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15688 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15689 }
15690 }
15691 else if (attack_mode == ATTACK_MODE_HYBRID1)
15692 {
15693 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15694
15695 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);
15696 }
15697 else if (attack_mode == ATTACK_MODE_HYBRID2)
15698 {
15699 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15700
15701 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);
15702 }
15703
15704 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15705 {
15706 // nothing to do
15707 }
15708 else
15709 {
15710 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15711
15712 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);
15713 }
15714
15715 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15716 {
15717 // nothing to do
15718 }
15719 else
15720 {
15721 for (uint i = 0; i < 5; i++)
15722 {
15723 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15724 }
15725
15726 for (uint i = 5; i < 7; i++)
15727 {
15728 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15729 }
15730 }
15731
15732 // maybe this has been updated by clGetKernelWorkGroupInfo()
15733 // value can only be decreased, so we don't need to reallocate buffers
15734
15735 device_param->kernel_threads = kernel_threads;
15736
15737 // zero some data buffers
15738
15739 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15740 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15741 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15742 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15743 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15744 run_kernel_bzero (device_param, device_param->d_result, size_results);
15745
15746 /**
15747 * special buffers
15748 */
15749
15750 if (attack_kern == ATTACK_KERN_STRAIGHT)
15751 {
15752 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15753 }
15754 else if (attack_kern == ATTACK_KERN_COMBI)
15755 {
15756 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15757 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15758 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15759 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15760 }
15761 else if (attack_kern == ATTACK_KERN_BF)
15762 {
15763 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15764 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15765 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15766 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15767 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15768 }
15769
15770 #if defined(HAVE_HWMON)
15771
15772 /**
15773 * Store initial fanspeed if gpu_temp_retain is enabled
15774 */
15775
15776 if (gpu_temp_disable == 0)
15777 {
15778 if (gpu_temp_retain != 0)
15779 {
15780 hc_thread_mutex_lock (mux_adl);
15781
15782 if (data.hm_device[device_id].fan_get_supported == 1)
15783 {
15784 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15785 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15786
15787 temp_retain_fanspeed_value[device_id] = fanspeed;
15788 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15789
15790 // we also set it to tell the OS we take control over the fan and it's automatic controller
15791 // if it was set to automatic. we do not control user-defined fanspeeds.
15792
15793 if (fanpolicy == 1)
15794 {
15795 data.hm_device[device_id].fan_set_supported = 1;
15796
15797 int rc = -1;
15798
15799 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15800 {
15801 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
15802 }
15803 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15804 {
15805
15806 }
15807
15808 if (rc == 0)
15809 {
15810 data.hm_device[device_id].fan_set_supported = 1;
15811 }
15812 else
15813 {
15814 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15815
15816 data.hm_device[device_id].fan_set_supported = 0;
15817 }
15818 }
15819 else
15820 {
15821 data.hm_device[device_id].fan_set_supported = 0;
15822 }
15823 }
15824
15825 hc_thread_mutex_unlock (mux_adl);
15826 }
15827 }
15828
15829 #endif // HAVE_HWMON
15830 }
15831
15832 if (data.quiet == 0) log_info_nn ("");
15833
15834 /**
15835 * In benchmark-mode, inform user which algorithm is checked
15836 */
15837
15838 if (benchmark == 1)
15839 {
15840 if (machine_readable == 0)
15841 {
15842 quiet = 0;
15843
15844 data.quiet = quiet;
15845
15846 char *hash_type = strhashtype (data.hash_mode); // not a bug
15847
15848 log_info ("Hashtype: %s", hash_type);
15849 log_info ("");
15850 }
15851 }
15852
15853 /**
15854 * keep track of the progress
15855 */
15856
15857 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15858 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15859 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15860
15861 /**
15862 * open filehandles
15863 */
15864
15865 #if _WIN
15866 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15867 {
15868 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15869
15870 return (-1);
15871 }
15872
15873 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15874 {
15875 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15876
15877 return (-1);
15878 }
15879
15880 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15881 {
15882 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15883
15884 return (-1);
15885 }
15886 #endif
15887
15888 /**
15889 * dictionary pad
15890 */
15891
15892 segment_size *= (1024 * 1024);
15893
15894 data.segment_size = segment_size;
15895
15896 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15897
15898 wl_data->buf = (char *) mymalloc (segment_size);
15899 wl_data->avail = segment_size;
15900 wl_data->incr = segment_size;
15901 wl_data->cnt = 0;
15902 wl_data->pos = 0;
15903
15904 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15905
15906 data.wordlist_mode = wordlist_mode;
15907
15908 cs_t *css_buf = NULL;
15909 uint css_cnt = 0;
15910 uint dictcnt = 0;
15911 uint maskcnt = 1;
15912 char **masks = NULL;
15913 char **dictfiles = NULL;
15914
15915 uint mask_from_file = 0;
15916
15917 if (attack_mode == ATTACK_MODE_STRAIGHT)
15918 {
15919 if (wordlist_mode == WL_MODE_FILE)
15920 {
15921 int wls_left = myargc - (optind + 1);
15922
15923 for (int i = 0; i < wls_left; i++)
15924 {
15925 char *l0_filename = myargv[optind + 1 + i];
15926
15927 struct stat l0_stat;
15928
15929 if (stat (l0_filename, &l0_stat) == -1)
15930 {
15931 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15932
15933 return (-1);
15934 }
15935
15936 uint is_dir = S_ISDIR (l0_stat.st_mode);
15937
15938 if (is_dir == 0)
15939 {
15940 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15941
15942 dictcnt++;
15943
15944 dictfiles[dictcnt - 1] = l0_filename;
15945 }
15946 else
15947 {
15948 // do not allow --keyspace w/ a directory
15949
15950 if (keyspace == 1)
15951 {
15952 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15953
15954 return (-1);
15955 }
15956
15957 char **dictionary_files = NULL;
15958
15959 dictionary_files = scan_directory (l0_filename);
15960
15961 if (dictionary_files != NULL)
15962 {
15963 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15964
15965 for (int d = 0; dictionary_files[d] != NULL; d++)
15966 {
15967 char *l1_filename = dictionary_files[d];
15968
15969 struct stat l1_stat;
15970
15971 if (stat (l1_filename, &l1_stat) == -1)
15972 {
15973 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15974
15975 return (-1);
15976 }
15977
15978 if (S_ISREG (l1_stat.st_mode))
15979 {
15980 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15981
15982 dictcnt++;
15983
15984 dictfiles[dictcnt - 1] = strdup (l1_filename);
15985 }
15986 }
15987 }
15988
15989 local_free (dictionary_files);
15990 }
15991 }
15992
15993 if (dictcnt < 1)
15994 {
15995 log_error ("ERROR: No usable dictionary file found.");
15996
15997 return (-1);
15998 }
15999 }
16000 else if (wordlist_mode == WL_MODE_STDIN)
16001 {
16002 dictcnt = 1;
16003 }
16004 }
16005 else if (attack_mode == ATTACK_MODE_COMBI)
16006 {
16007 // display
16008
16009 char *dictfile1 = myargv[optind + 1 + 0];
16010 char *dictfile2 = myargv[optind + 1 + 1];
16011
16012 // find the bigger dictionary and use as base
16013
16014 FILE *fp1 = NULL;
16015 FILE *fp2 = NULL;
16016
16017 struct stat tmp_stat;
16018
16019 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16020 {
16021 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16022
16023 return (-1);
16024 }
16025
16026 if (stat (dictfile1, &tmp_stat) == -1)
16027 {
16028 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16029
16030 fclose (fp1);
16031
16032 return (-1);
16033 }
16034
16035 if (S_ISDIR (tmp_stat.st_mode))
16036 {
16037 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16038
16039 fclose (fp1);
16040
16041 return (-1);
16042 }
16043
16044 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16045 {
16046 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16047
16048 fclose (fp1);
16049
16050 return (-1);
16051 }
16052
16053 if (stat (dictfile2, &tmp_stat) == -1)
16054 {
16055 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16056
16057 fclose (fp1);
16058 fclose (fp2);
16059
16060 return (-1);
16061 }
16062
16063 if (S_ISDIR (tmp_stat.st_mode))
16064 {
16065 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16066
16067 fclose (fp1);
16068 fclose (fp2);
16069
16070 return (-1);
16071 }
16072
16073 data.combs_cnt = 1;
16074
16075 data.quiet = 1;
16076
16077 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16078
16079 data.quiet = quiet;
16080
16081 if (words1_cnt == 0)
16082 {
16083 log_error ("ERROR: %s: empty file", dictfile1);
16084
16085 fclose (fp1);
16086 fclose (fp2);
16087
16088 return (-1);
16089 }
16090
16091 data.combs_cnt = 1;
16092
16093 data.quiet = 1;
16094
16095 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16096
16097 data.quiet = quiet;
16098
16099 if (words2_cnt == 0)
16100 {
16101 log_error ("ERROR: %s: empty file", dictfile2);
16102
16103 fclose (fp1);
16104 fclose (fp2);
16105
16106 return (-1);
16107 }
16108
16109 fclose (fp1);
16110 fclose (fp2);
16111
16112 data.dictfile = dictfile1;
16113 data.dictfile2 = dictfile2;
16114
16115 if (words1_cnt >= words2_cnt)
16116 {
16117 data.combs_cnt = words2_cnt;
16118 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16119
16120 dictfiles = &data.dictfile;
16121
16122 dictcnt = 1;
16123 }
16124 else
16125 {
16126 data.combs_cnt = words1_cnt;
16127 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16128
16129 dictfiles = &data.dictfile2;
16130
16131 dictcnt = 1;
16132
16133 // we also have to switch wordlist related rules!
16134
16135 char *tmpc = data.rule_buf_l;
16136
16137 data.rule_buf_l = data.rule_buf_r;
16138 data.rule_buf_r = tmpc;
16139
16140 int tmpi = data.rule_len_l;
16141
16142 data.rule_len_l = data.rule_len_r;
16143 data.rule_len_r = tmpi;
16144 }
16145 }
16146 else if (attack_mode == ATTACK_MODE_BF)
16147 {
16148 char *mask = NULL;
16149
16150 maskcnt = 0;
16151
16152 if (benchmark == 0)
16153 {
16154 mask = myargv[optind + 1];
16155
16156 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16157
16158 if ((optind + 2) <= myargc)
16159 {
16160 struct stat file_stat;
16161
16162 if (stat (mask, &file_stat) == -1)
16163 {
16164 maskcnt = 1;
16165
16166 masks[maskcnt - 1] = mystrdup (mask);
16167 }
16168 else
16169 {
16170 int wls_left = myargc - (optind + 1);
16171
16172 uint masks_avail = INCR_MASKS;
16173
16174 for (int i = 0; i < wls_left; i++)
16175 {
16176 if (i != 0)
16177 {
16178 mask = myargv[optind + 1 + i];
16179
16180 if (stat (mask, &file_stat) == -1)
16181 {
16182 log_error ("ERROR: %s: %s", mask, strerror (errno));
16183
16184 return (-1);
16185 }
16186 }
16187
16188 uint is_file = S_ISREG (file_stat.st_mode);
16189
16190 if (is_file == 1)
16191 {
16192 FILE *mask_fp;
16193
16194 if ((mask_fp = fopen (mask, "r")) == NULL)
16195 {
16196 log_error ("ERROR: %s: %s", mask, strerror (errno));
16197
16198 return (-1);
16199 }
16200
16201 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16202
16203 while (!feof (mask_fp))
16204 {
16205 memset (line_buf, 0, HCBUFSIZ);
16206
16207 int line_len = fgetl (mask_fp, line_buf);
16208
16209 if (line_len == 0) continue;
16210
16211 if (line_buf[0] == '#') continue;
16212
16213 if (masks_avail == maskcnt)
16214 {
16215 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16216
16217 masks_avail += INCR_MASKS;
16218 }
16219
16220 masks[maskcnt] = mystrdup (line_buf);
16221
16222 maskcnt++;
16223 }
16224
16225 myfree (line_buf);
16226
16227 fclose (mask_fp);
16228 }
16229 else
16230 {
16231 log_error ("ERROR: %s: unsupported file-type", mask);
16232
16233 return (-1);
16234 }
16235 }
16236
16237 mask_from_file = 1;
16238 }
16239 }
16240 else
16241 {
16242 custom_charset_1 = (char *) "?l?d?u";
16243 custom_charset_2 = (char *) "?l?d";
16244 custom_charset_3 = (char *) "?l?d*!$@_";
16245
16246 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16247 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16248 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16249
16250 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16251
16252 wordlist_mode = WL_MODE_MASK;
16253
16254 data.wordlist_mode = wordlist_mode;
16255
16256 increment = 1;
16257
16258 maskcnt = 1;
16259 }
16260 }
16261 else
16262 {
16263 /**
16264 * generate full masks and charsets
16265 */
16266
16267 masks = (char **) mymalloc (sizeof (char *));
16268
16269 switch (hash_mode)
16270 {
16271 case 1731: pw_min = 5;
16272 pw_max = 5;
16273 mask = mystrdup ("?b?b?b?b?b");
16274 break;
16275 case 12500: pw_min = 5;
16276 pw_max = 5;
16277 mask = mystrdup ("?b?b?b?b?b");
16278 break;
16279 default: pw_min = 7;
16280 pw_max = 7;
16281 mask = mystrdup ("?b?b?b?b?b?b?b");
16282 break;
16283 }
16284
16285 maskcnt = 1;
16286
16287 masks[maskcnt - 1] = mystrdup (mask);
16288
16289 wordlist_mode = WL_MODE_MASK;
16290
16291 data.wordlist_mode = wordlist_mode;
16292
16293 increment = 1;
16294 }
16295
16296 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16297
16298 if (increment)
16299 {
16300 if (increment_min > pw_min) pw_min = increment_min;
16301
16302 if (increment_max < pw_max) pw_max = increment_max;
16303 }
16304 }
16305 else if (attack_mode == ATTACK_MODE_HYBRID1)
16306 {
16307 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16308
16309 // display
16310
16311 char *mask = myargv[myargc - 1];
16312
16313 maskcnt = 0;
16314
16315 masks = (char **) mymalloc (1 * sizeof (char *));
16316
16317 // mod
16318
16319 struct stat file_stat;
16320
16321 if (stat (mask, &file_stat) == -1)
16322 {
16323 maskcnt = 1;
16324
16325 masks[maskcnt - 1] = mystrdup (mask);
16326 }
16327 else
16328 {
16329 uint is_file = S_ISREG (file_stat.st_mode);
16330
16331 if (is_file == 1)
16332 {
16333 FILE *mask_fp;
16334
16335 if ((mask_fp = fopen (mask, "r")) == NULL)
16336 {
16337 log_error ("ERROR: %s: %s", mask, strerror (errno));
16338
16339 return (-1);
16340 }
16341
16342 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16343
16344 uint masks_avail = 1;
16345
16346 while (!feof (mask_fp))
16347 {
16348 memset (line_buf, 0, HCBUFSIZ);
16349
16350 int line_len = fgetl (mask_fp, line_buf);
16351
16352 if (line_len == 0) continue;
16353
16354 if (line_buf[0] == '#') continue;
16355
16356 if (masks_avail == maskcnt)
16357 {
16358 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16359
16360 masks_avail += INCR_MASKS;
16361 }
16362
16363 masks[maskcnt] = mystrdup (line_buf);
16364
16365 maskcnt++;
16366 }
16367
16368 myfree (line_buf);
16369
16370 fclose (mask_fp);
16371
16372 mask_from_file = 1;
16373 }
16374 else
16375 {
16376 maskcnt = 1;
16377
16378 masks[maskcnt - 1] = mystrdup (mask);
16379 }
16380 }
16381
16382 // base
16383
16384 int wls_left = myargc - (optind + 2);
16385
16386 for (int i = 0; i < wls_left; i++)
16387 {
16388 char *filename = myargv[optind + 1 + i];
16389
16390 struct stat file_stat;
16391
16392 if (stat (filename, &file_stat) == -1)
16393 {
16394 log_error ("ERROR: %s: %s", filename, strerror (errno));
16395
16396 return (-1);
16397 }
16398
16399 uint is_dir = S_ISDIR (file_stat.st_mode);
16400
16401 if (is_dir == 0)
16402 {
16403 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16404
16405 dictcnt++;
16406
16407 dictfiles[dictcnt - 1] = filename;
16408 }
16409 else
16410 {
16411 // do not allow --keyspace w/ a directory
16412
16413 if (keyspace == 1)
16414 {
16415 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16416
16417 return (-1);
16418 }
16419
16420 char **dictionary_files = NULL;
16421
16422 dictionary_files = scan_directory (filename);
16423
16424 if (dictionary_files != NULL)
16425 {
16426 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16427
16428 for (int d = 0; dictionary_files[d] != NULL; d++)
16429 {
16430 char *l1_filename = dictionary_files[d];
16431
16432 struct stat l1_stat;
16433
16434 if (stat (l1_filename, &l1_stat) == -1)
16435 {
16436 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16437
16438 return (-1);
16439 }
16440
16441 if (S_ISREG (l1_stat.st_mode))
16442 {
16443 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16444
16445 dictcnt++;
16446
16447 dictfiles[dictcnt - 1] = strdup (l1_filename);
16448 }
16449 }
16450 }
16451
16452 local_free (dictionary_files);
16453 }
16454 }
16455
16456 if (dictcnt < 1)
16457 {
16458 log_error ("ERROR: No usable dictionary file found.");
16459
16460 return (-1);
16461 }
16462
16463 if (increment)
16464 {
16465 maskcnt = 0;
16466
16467 uint mask_min = increment_min; // we can't reject smaller masks here
16468 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16469
16470 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16471 {
16472 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16473
16474 if (cur_mask == NULL) break;
16475
16476 masks[maskcnt] = cur_mask;
16477
16478 maskcnt++;
16479
16480 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16481 }
16482 }
16483 }
16484 else if (attack_mode == ATTACK_MODE_HYBRID2)
16485 {
16486 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16487
16488 // display
16489
16490 char *mask = myargv[optind + 1 + 0];
16491
16492 maskcnt = 0;
16493
16494 masks = (char **) mymalloc (1 * sizeof (char *));
16495
16496 // mod
16497
16498 struct stat file_stat;
16499
16500 if (stat (mask, &file_stat) == -1)
16501 {
16502 maskcnt = 1;
16503
16504 masks[maskcnt - 1] = mystrdup (mask);
16505 }
16506 else
16507 {
16508 uint is_file = S_ISREG (file_stat.st_mode);
16509
16510 if (is_file == 1)
16511 {
16512 FILE *mask_fp;
16513
16514 if ((mask_fp = fopen (mask, "r")) == NULL)
16515 {
16516 log_error ("ERROR: %s: %s", mask, strerror (errno));
16517
16518 return (-1);
16519 }
16520
16521 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16522
16523 uint masks_avail = 1;
16524
16525 while (!feof (mask_fp))
16526 {
16527 memset (line_buf, 0, HCBUFSIZ);
16528
16529 int line_len = fgetl (mask_fp, line_buf);
16530
16531 if (line_len == 0) continue;
16532
16533 if (line_buf[0] == '#') continue;
16534
16535 if (masks_avail == maskcnt)
16536 {
16537 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16538
16539 masks_avail += INCR_MASKS;
16540 }
16541
16542 masks[maskcnt] = mystrdup (line_buf);
16543
16544 maskcnt++;
16545 }
16546
16547 myfree (line_buf);
16548
16549 fclose (mask_fp);
16550
16551 mask_from_file = 1;
16552 }
16553 else
16554 {
16555 maskcnt = 1;
16556
16557 masks[maskcnt - 1] = mystrdup (mask);
16558 }
16559 }
16560
16561 // base
16562
16563 int wls_left = myargc - (optind + 2);
16564
16565 for (int i = 0; i < wls_left; i++)
16566 {
16567 char *filename = myargv[optind + 2 + i];
16568
16569 struct stat file_stat;
16570
16571 if (stat (filename, &file_stat) == -1)
16572 {
16573 log_error ("ERROR: %s: %s", filename, strerror (errno));
16574
16575 return (-1);
16576 }
16577
16578 uint is_dir = S_ISDIR (file_stat.st_mode);
16579
16580 if (is_dir == 0)
16581 {
16582 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16583
16584 dictcnt++;
16585
16586 dictfiles[dictcnt - 1] = filename;
16587 }
16588 else
16589 {
16590 // do not allow --keyspace w/ a directory
16591
16592 if (keyspace == 1)
16593 {
16594 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16595
16596 return (-1);
16597 }
16598
16599 char **dictionary_files = NULL;
16600
16601 dictionary_files = scan_directory (filename);
16602
16603 if (dictionary_files != NULL)
16604 {
16605 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16606
16607 for (int d = 0; dictionary_files[d] != NULL; d++)
16608 {
16609 char *l1_filename = dictionary_files[d];
16610
16611 struct stat l1_stat;
16612
16613 if (stat (l1_filename, &l1_stat) == -1)
16614 {
16615 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16616
16617 return (-1);
16618 }
16619
16620 if (S_ISREG (l1_stat.st_mode))
16621 {
16622 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16623
16624 dictcnt++;
16625
16626 dictfiles[dictcnt - 1] = strdup (l1_filename);
16627 }
16628 }
16629 }
16630
16631 local_free (dictionary_files);
16632 }
16633 }
16634
16635 if (dictcnt < 1)
16636 {
16637 log_error ("ERROR: No usable dictionary file found.");
16638
16639 return (-1);
16640 }
16641
16642 if (increment)
16643 {
16644 maskcnt = 0;
16645
16646 uint mask_min = increment_min; // we can't reject smaller masks here
16647 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16648
16649 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16650 {
16651 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16652
16653 if (cur_mask == NULL) break;
16654
16655 masks[maskcnt] = cur_mask;
16656
16657 maskcnt++;
16658
16659 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16660 }
16661 }
16662 }
16663
16664 data.pw_min = pw_min;
16665 data.pw_max = pw_max;
16666
16667 /**
16668 * weak hash check
16669 */
16670
16671 if (weak_hash_threshold >= salts_cnt)
16672 {
16673 hc_device_param_t *device_param = NULL;
16674
16675 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16676 {
16677 device_param = &data.devices_param[device_id];
16678
16679 if (device_param->skipped) continue;
16680
16681 break;
16682 }
16683
16684 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16685
16686 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16687 {
16688 weak_hash_check (device_param, salt_pos);
16689 }
16690
16691 // Display hack, guarantee that there is at least one \r before real start
16692
16693 //if (data.quiet == 0) log_info ("");
16694 }
16695
16696 /**
16697 * status and monitor threads
16698 */
16699
16700 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16701
16702 hc_thread_t i_thread = 0;
16703
16704 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16705 {
16706 hc_thread_create (i_thread, thread_keypress, &benchmark);
16707 }
16708
16709 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16710
16711 uint ni_threads_cnt = 0;
16712
16713 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16714
16715 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16716
16717 ni_threads_cnt++;
16718
16719 /**
16720 * Outfile remove
16721 */
16722
16723 if (keyspace == 0)
16724 {
16725 if (outfile_check_timer != 0)
16726 {
16727 if (data.outfile_check_directory != NULL)
16728 {
16729 if ((hash_mode != 5200) &&
16730 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16731 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16732 (hash_mode != 9000))
16733 {
16734 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16735
16736 ni_threads_cnt++;
16737 }
16738 else
16739 {
16740 outfile_check_timer = 0;
16741 }
16742 }
16743 else
16744 {
16745 outfile_check_timer = 0;
16746 }
16747 }
16748 }
16749
16750 /**
16751 * Inform the user if we got some hashes remove because of the pot file remove feature
16752 */
16753
16754 if (data.quiet == 0)
16755 {
16756 if (potfile_remove_cracks > 0)
16757 {
16758 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16759 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16760 }
16761 }
16762
16763 data.outfile_check_timer = outfile_check_timer;
16764
16765 /**
16766 * main loop
16767 */
16768
16769 char **induction_dictionaries = NULL;
16770
16771 int induction_dictionaries_cnt = 0;
16772
16773 hcstat_table_t *root_table_buf = NULL;
16774 hcstat_table_t *markov_table_buf = NULL;
16775
16776 uint initial_restore_done = 0;
16777
16778 data.maskcnt = maskcnt;
16779
16780 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16781 {
16782 if (data.devices_status == STATUS_CRACKED) break;
16783
16784 data.devices_status = STATUS_INIT;
16785
16786 if (maskpos > rd->maskpos)
16787 {
16788 rd->dictpos = 0;
16789 }
16790
16791 rd->maskpos = maskpos;
16792 data.maskpos = maskpos;
16793
16794 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16795 {
16796 char *mask = masks[maskpos];
16797
16798 if (mask_from_file == 1)
16799 {
16800 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16801
16802 char *str_ptr;
16803 uint str_pos;
16804
16805 uint mask_offset = 0;
16806
16807 uint separator_cnt;
16808
16809 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16810 {
16811 str_ptr = strstr (mask + mask_offset, ",");
16812
16813 if (str_ptr == NULL) break;
16814
16815 str_pos = str_ptr - mask;
16816
16817 // escaped separator, i.e. "\,"
16818
16819 if (str_pos > 0)
16820 {
16821 if (mask[str_pos - 1] == '\\')
16822 {
16823 separator_cnt --;
16824
16825 mask_offset = str_pos + 1;
16826
16827 continue;
16828 }
16829 }
16830
16831 // reset the offset
16832
16833 mask_offset = 0;
16834
16835 mask[str_pos] = '\0';
16836
16837 switch (separator_cnt)
16838 {
16839 case 0:
16840 mp_reset_usr (mp_usr, 0);
16841
16842 custom_charset_1 = mask;
16843 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16844 break;
16845
16846 case 1:
16847 mp_reset_usr (mp_usr, 1);
16848
16849 custom_charset_2 = mask;
16850 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16851 break;
16852
16853 case 2:
16854 mp_reset_usr (mp_usr, 2);
16855
16856 custom_charset_3 = mask;
16857 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16858 break;
16859
16860 case 3:
16861 mp_reset_usr (mp_usr, 3);
16862
16863 custom_charset_4 = mask;
16864 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16865 break;
16866 }
16867
16868 mask = mask + str_pos + 1;
16869 }
16870 }
16871
16872 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16873 {
16874 if (maskpos > 0)
16875 {
16876 local_free (css_buf);
16877 local_free (data.root_css_buf);
16878 local_free (data.markov_css_buf);
16879
16880 local_free (masks[maskpos - 1]);
16881 }
16882
16883 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16884
16885 data.mask = mask;
16886 data.css_cnt = css_cnt;
16887 data.css_buf = css_buf;
16888
16889 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16890
16891 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16892
16893 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16894 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16895
16896 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16897
16898 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16899
16900 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16901 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16902
16903 data.root_css_buf = root_css_buf;
16904 data.markov_css_buf = markov_css_buf;
16905
16906 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16907
16908 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16909
16910 local_free (root_table_buf);
16911 local_free (markov_table_buf);
16912
16913 // args
16914
16915 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16916 {
16917 hc_device_param_t *device_param = &data.devices_param[device_id];
16918
16919 if (device_param->skipped) continue;
16920
16921 device_param->kernel_params_mp[0] = &device_param->d_combs;
16922 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16923 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16924
16925 device_param->kernel_params_mp_buf64[3] = 0;
16926 device_param->kernel_params_mp_buf32[4] = css_cnt;
16927 device_param->kernel_params_mp_buf32[5] = 0;
16928 device_param->kernel_params_mp_buf32[6] = 0;
16929 device_param->kernel_params_mp_buf32[7] = 0;
16930
16931 if (attack_mode == ATTACK_MODE_HYBRID1)
16932 {
16933 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16934 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16935 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16936 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16937 }
16938 else if (attack_mode == ATTACK_MODE_HYBRID2)
16939 {
16940 device_param->kernel_params_mp_buf32[5] = 0;
16941 device_param->kernel_params_mp_buf32[6] = 0;
16942 device_param->kernel_params_mp_buf32[7] = 0;
16943 }
16944
16945 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]);
16946 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]);
16947 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]);
16948
16949 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);
16950 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);
16951 }
16952 }
16953 else if (attack_mode == ATTACK_MODE_BF)
16954 {
16955 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16956
16957 if (increment)
16958 {
16959 for (uint i = 0; i < dictcnt; i++)
16960 {
16961 local_free (dictfiles[i]);
16962 }
16963
16964 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16965 {
16966 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16967
16968 if (l1_filename == NULL) break;
16969
16970 dictcnt++;
16971
16972 dictfiles[dictcnt - 1] = l1_filename;
16973 }
16974 }
16975 else
16976 {
16977 dictcnt++;
16978
16979 dictfiles[dictcnt - 1] = mask;
16980 }
16981
16982 if (dictcnt == 0)
16983 {
16984 log_error ("ERROR: Mask is too small");
16985
16986 return (-1);
16987 }
16988 }
16989 }
16990
16991 free (induction_dictionaries);
16992
16993 // induction_dictionaries_cnt = 0; // implied
16994
16995 if (attack_mode != ATTACK_MODE_BF)
16996 {
16997 if (keyspace == 0)
16998 {
16999 induction_dictionaries = scan_directory (induction_directory);
17000
17001 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17002 }
17003 }
17004
17005 if (induction_dictionaries_cnt)
17006 {
17007 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17008 }
17009
17010 /**
17011 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17012 */
17013 if (keyspace == 1)
17014 {
17015 if ((maskcnt > 1) || (dictcnt > 1))
17016 {
17017 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17018
17019 return (-1);
17020 }
17021 }
17022
17023 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17024 {
17025 char *subid = logfile_generate_subid ();
17026
17027 data.subid = subid;
17028
17029 logfile_sub_msg ("START");
17030
17031 data.devices_status = STATUS_INIT;
17032
17033 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17034 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17035 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17036
17037 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17038
17039 data.cpt_pos = 0;
17040
17041 data.cpt_start = time (NULL);
17042
17043 data.cpt_total = 0;
17044
17045 if (data.restore == 0)
17046 {
17047 rd->words_cur = skip;
17048
17049 skip = 0;
17050
17051 data.skip = 0;
17052 }
17053
17054 data.ms_paused = 0;
17055
17056 data.kernel_power_div = 0;
17057
17058 data.words_cur = rd->words_cur;
17059
17060 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17061 {
17062 hc_device_param_t *device_param = &data.devices_param[device_id];
17063
17064 if (device_param->skipped) continue;
17065
17066 device_param->speed_pos = 0;
17067
17068 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17069 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17070
17071 device_param->exec_pos = 0;
17072
17073 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17074
17075 device_param->outerloop_pos = 0;
17076 device_param->outerloop_left = 0;
17077 device_param->innerloop_pos = 0;
17078 device_param->innerloop_left = 0;
17079
17080 // some more resets:
17081
17082 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17083
17084 device_param->pws_cnt = 0;
17085
17086 device_param->words_off = 0;
17087 device_param->words_done = 0;
17088 }
17089
17090 // figure out some workload
17091
17092 if (attack_mode == ATTACK_MODE_STRAIGHT)
17093 {
17094 if (data.wordlist_mode == WL_MODE_FILE)
17095 {
17096 char *dictfile = NULL;
17097
17098 if (induction_dictionaries_cnt)
17099 {
17100 dictfile = induction_dictionaries[0];
17101 }
17102 else
17103 {
17104 dictfile = dictfiles[dictpos];
17105 }
17106
17107 data.dictfile = dictfile;
17108
17109 logfile_sub_string (dictfile);
17110
17111 for (uint i = 0; i < rp_files_cnt; i++)
17112 {
17113 logfile_sub_var_string ("rulefile", rp_files[i]);
17114 }
17115
17116 FILE *fd2 = fopen (dictfile, "rb");
17117
17118 if (fd2 == NULL)
17119 {
17120 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17121
17122 return (-1);
17123 }
17124
17125 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17126
17127 fclose (fd2);
17128
17129 if (data.words_cnt == 0)
17130 {
17131 if (data.devices_status == STATUS_CRACKED) break;
17132 if (data.devices_status == STATUS_ABORTED) break;
17133
17134 dictpos++;
17135
17136 continue;
17137 }
17138 }
17139 }
17140 else if (attack_mode == ATTACK_MODE_COMBI)
17141 {
17142 char *dictfile = data.dictfile;
17143 char *dictfile2 = data.dictfile2;
17144
17145 logfile_sub_string (dictfile);
17146 logfile_sub_string (dictfile2);
17147
17148 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17149 {
17150 FILE *fd2 = fopen (dictfile, "rb");
17151
17152 if (fd2 == NULL)
17153 {
17154 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17155
17156 return (-1);
17157 }
17158
17159 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17160
17161 fclose (fd2);
17162 }
17163 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17164 {
17165 FILE *fd2 = fopen (dictfile2, "rb");
17166
17167 if (fd2 == NULL)
17168 {
17169 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17170
17171 return (-1);
17172 }
17173
17174 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17175
17176 fclose (fd2);
17177 }
17178
17179 if (data.words_cnt == 0)
17180 {
17181 if (data.devices_status == STATUS_CRACKED) break;
17182 if (data.devices_status == STATUS_ABORTED) break;
17183
17184 dictpos++;
17185
17186 continue;
17187 }
17188 }
17189 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17190 {
17191 char *dictfile = NULL;
17192
17193 if (induction_dictionaries_cnt)
17194 {
17195 dictfile = induction_dictionaries[0];
17196 }
17197 else
17198 {
17199 dictfile = dictfiles[dictpos];
17200 }
17201
17202 data.dictfile = dictfile;
17203
17204 char *mask = data.mask;
17205
17206 logfile_sub_string (dictfile);
17207 logfile_sub_string (mask);
17208
17209 FILE *fd2 = fopen (dictfile, "rb");
17210
17211 if (fd2 == NULL)
17212 {
17213 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17214
17215 return (-1);
17216 }
17217
17218 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17219
17220 fclose (fd2);
17221
17222 if (data.words_cnt == 0)
17223 {
17224 if (data.devices_status == STATUS_CRACKED) break;
17225 if (data.devices_status == STATUS_ABORTED) break;
17226
17227 dictpos++;
17228
17229 continue;
17230 }
17231 }
17232 else if (attack_mode == ATTACK_MODE_BF)
17233 {
17234 local_free (css_buf);
17235 local_free (data.root_css_buf);
17236 local_free (data.markov_css_buf);
17237
17238 char *mask = dictfiles[dictpos];
17239
17240 logfile_sub_string (mask);
17241
17242 // base
17243
17244 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17245
17246 if (opts_type & OPTS_TYPE_PT_UNICODE)
17247 {
17248 uint css_cnt_unicode = css_cnt * 2;
17249
17250 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17251
17252 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17253 {
17254 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17255
17256 css_buf_unicode[j + 1].cs_buf[0] = 0;
17257 css_buf_unicode[j + 1].cs_len = 1;
17258 }
17259
17260 free (css_buf);
17261
17262 css_buf = css_buf_unicode;
17263 css_cnt = css_cnt_unicode;
17264 }
17265
17266 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17267
17268 uint mask_min = pw_min;
17269 uint mask_max = pw_max;
17270
17271 if (opts_type & OPTS_TYPE_PT_UNICODE)
17272 {
17273 mask_min *= 2;
17274 mask_max *= 2;
17275 }
17276
17277 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17278 {
17279 if (css_cnt < mask_min)
17280 {
17281 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17282 }
17283
17284 if (css_cnt > mask_max)
17285 {
17286 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17287 }
17288
17289 // skip to next mask
17290
17291 dictpos++;
17292
17293 rd->dictpos = dictpos;
17294
17295 logfile_sub_msg ("STOP");
17296
17297 continue;
17298 }
17299
17300 uint save_css_cnt = css_cnt;
17301
17302 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17303 {
17304 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17305 {
17306 uint salt_len = (uint) data.salts_buf[0].salt_len;
17307 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17308
17309 uint css_cnt_salt = css_cnt + salt_len;
17310
17311 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17312
17313 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17314
17315 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17316 {
17317 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17318 css_buf_salt[j].cs_len = 1;
17319 }
17320
17321 free (css_buf);
17322
17323 css_buf = css_buf_salt;
17324 css_cnt = css_cnt_salt;
17325 }
17326 }
17327
17328 data.mask = mask;
17329 data.css_cnt = css_cnt;
17330 data.css_buf = css_buf;
17331
17332 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17333
17334 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17335
17336 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17337
17338 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17339 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17340
17341 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17342
17343 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17344
17345 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17346 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17347
17348 data.root_css_buf = root_css_buf;
17349 data.markov_css_buf = markov_css_buf;
17350
17351 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17352
17353 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17354
17355 local_free (root_table_buf);
17356 local_free (markov_table_buf);
17357
17358 // copy + args
17359
17360 uint css_cnt_l = css_cnt;
17361 uint css_cnt_r;
17362
17363 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17364 {
17365 if (save_css_cnt < 6)
17366 {
17367 css_cnt_r = 1;
17368 }
17369 else if (save_css_cnt == 6)
17370 {
17371 css_cnt_r = 2;
17372 }
17373 else
17374 {
17375 if (opts_type & OPTS_TYPE_PT_UNICODE)
17376 {
17377 if (save_css_cnt == 8 || save_css_cnt == 10)
17378 {
17379 css_cnt_r = 2;
17380 }
17381 else
17382 {
17383 css_cnt_r = 4;
17384 }
17385 }
17386 else
17387 {
17388 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17389 {
17390 css_cnt_r = 3;
17391 }
17392 else
17393 {
17394 css_cnt_r = 4;
17395 }
17396 }
17397 }
17398 }
17399 else
17400 {
17401 css_cnt_r = 1;
17402
17403 /* unfinished code?
17404 int sum = css_buf[css_cnt_r - 1].cs_len;
17405
17406 for (uint i = 1; i < 4 && i < css_cnt; i++)
17407 {
17408 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17409
17410 css_cnt_r++;
17411
17412 sum *= css_buf[css_cnt_r - 1].cs_len;
17413 }
17414 */
17415 }
17416
17417 css_cnt_l -= css_cnt_r;
17418
17419 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17420
17421 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17422 {
17423 hc_device_param_t *device_param = &data.devices_param[device_id];
17424
17425 if (device_param->skipped) continue;
17426
17427 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17428 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17429 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17430
17431 device_param->kernel_params_mp_l_buf64[3] = 0;
17432 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17433 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17434 device_param->kernel_params_mp_l_buf32[6] = 0;
17435 device_param->kernel_params_mp_l_buf32[7] = 0;
17436 device_param->kernel_params_mp_l_buf32[8] = 0;
17437
17438 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17439 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17440 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17441 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17442
17443 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17444 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17445 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17446
17447 device_param->kernel_params_mp_r_buf64[3] = 0;
17448 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17449 device_param->kernel_params_mp_r_buf32[5] = 0;
17450 device_param->kernel_params_mp_r_buf32[6] = 0;
17451 device_param->kernel_params_mp_r_buf32[7] = 0;
17452
17453 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]);
17454 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]);
17455 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]);
17456
17457 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]);
17458 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]);
17459 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]);
17460
17461 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);
17462 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);
17463 }
17464 }
17465
17466 u64 words_base = data.words_cnt;
17467
17468 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17469 {
17470 if (data.kernel_rules_cnt)
17471 {
17472 words_base /= data.kernel_rules_cnt;
17473 }
17474 }
17475 else if (data.attack_kern == ATTACK_KERN_COMBI)
17476 {
17477 if (data.combs_cnt)
17478 {
17479 words_base /= data.combs_cnt;
17480 }
17481 }
17482 else if (data.attack_kern == ATTACK_KERN_BF)
17483 {
17484 if (data.bfs_cnt)
17485 {
17486 words_base /= data.bfs_cnt;
17487 }
17488 }
17489
17490 data.words_base = words_base;
17491
17492 if (keyspace == 1)
17493 {
17494 log_info ("%llu", (unsigned long long int) words_base);
17495
17496 return (0);
17497 }
17498
17499 if (data.words_cur > data.words_base)
17500 {
17501 log_error ("ERROR: restore value greater keyspace");
17502
17503 return (-1);
17504 }
17505
17506 if (data.words_cur)
17507 {
17508 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17509 {
17510 for (uint i = 0; i < data.salts_cnt; i++)
17511 {
17512 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17513 }
17514 }
17515 else if (data.attack_kern == ATTACK_KERN_COMBI)
17516 {
17517 for (uint i = 0; i < data.salts_cnt; i++)
17518 {
17519 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17520 }
17521 }
17522 else if (data.attack_kern == ATTACK_KERN_BF)
17523 {
17524 for (uint i = 0; i < data.salts_cnt; i++)
17525 {
17526 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17527 }
17528 }
17529 }
17530
17531 /*
17532 * Update loopback file
17533 */
17534
17535 if (loopback == 1)
17536 {
17537 time_t now;
17538
17539 time (&now);
17540
17541 uint random_num = get_random_num (0, 9999);
17542
17543 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17544
17545 data.loopback_file = loopback_file;
17546 }
17547
17548 /*
17549 * Update dictionary statistic
17550 */
17551
17552 if (keyspace == 0)
17553 {
17554 dictstat_fp = fopen (dictstat, "wb");
17555
17556 if (dictstat_fp)
17557 {
17558 lock_file (dictstat_fp);
17559
17560 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17561
17562 fclose (dictstat_fp);
17563 }
17564 }
17565
17566 /**
17567 * create autotune threads
17568 */
17569
17570 data.devices_status = STATUS_AUTOTUNE;
17571
17572 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17573
17574 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17575 {
17576 hc_device_param_t *device_param = &devices_param[device_id];
17577
17578 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17579 }
17580
17581 hc_thread_wait (data.devices_cnt, c_threads);
17582
17583 /*
17584 * Inform user about possible slow speeds
17585 */
17586
17587 uint kernel_power_all = 0;
17588
17589 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17590 {
17591 hc_device_param_t *device_param = &devices_param[device_id];
17592
17593 kernel_power_all += device_param->kernel_power;
17594 }
17595
17596 data.kernel_power_all = kernel_power_all;
17597
17598 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17599 {
17600 if (data.words_base < kernel_power_all)
17601 {
17602 if (quiet == 0)
17603 {
17604 log_info ("ATTENTION!");
17605 log_info (" The wordlist or mask you are using is too small.");
17606 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17607 log_info (" The cracking speed will drop.");
17608 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17609 log_info ("");
17610 }
17611 }
17612 }
17613
17614 /**
17615 * create cracker threads
17616 */
17617
17618 data.devices_status = STATUS_RUNNING;
17619
17620 if (initial_restore_done == 0)
17621 {
17622 if (data.restore_disable == 0) cycle_restore ();
17623
17624 initial_restore_done = 1;
17625 }
17626
17627 hc_timer_set (&data.timer_running);
17628
17629 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17630 {
17631 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17632 {
17633 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17634 if (quiet == 0) fflush (stdout);
17635 }
17636 }
17637 else if (wordlist_mode == WL_MODE_STDIN)
17638 {
17639 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17640 if (data.quiet == 0) log_info ("");
17641 }
17642
17643 time_t runtime_start;
17644
17645 time (&runtime_start);
17646
17647 data.runtime_start = runtime_start;
17648
17649 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17650 {
17651 hc_device_param_t *device_param = &devices_param[device_id];
17652
17653 if (wordlist_mode == WL_MODE_STDIN)
17654 {
17655 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17656 }
17657 else
17658 {
17659 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17660 }
17661 }
17662
17663 hc_thread_wait (data.devices_cnt, c_threads);
17664
17665 local_free (c_threads);
17666
17667 data.restore = 0;
17668
17669 // finalize task
17670
17671 logfile_sub_var_uint ("status-after-work", data.devices_status);
17672
17673 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17674
17675 if (data.devices_status == STATUS_CRACKED) break;
17676 if (data.devices_status == STATUS_ABORTED) break;
17677
17678 if (data.devices_status == STATUS_BYPASS)
17679 {
17680 data.devices_status = STATUS_RUNNING;
17681 }
17682
17683 if (induction_dictionaries_cnt)
17684 {
17685 unlink (induction_dictionaries[0]);
17686 }
17687
17688 free (induction_dictionaries);
17689
17690 if (attack_mode != ATTACK_MODE_BF)
17691 {
17692 induction_dictionaries = scan_directory (induction_directory);
17693
17694 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17695 }
17696
17697 if (benchmark == 0)
17698 {
17699 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17700 {
17701 if (quiet == 0) clear_prompt ();
17702
17703 if (quiet == 0) log_info ("");
17704
17705 if (status == 1)
17706 {
17707 status_display ();
17708 }
17709 else
17710 {
17711 if (quiet == 0) status_display ();
17712 }
17713
17714 if (quiet == 0) log_info ("");
17715 }
17716 }
17717
17718 if (attack_mode == ATTACK_MODE_BF)
17719 {
17720 dictpos++;
17721
17722 rd->dictpos = dictpos;
17723 }
17724 else
17725 {
17726 if (induction_dictionaries_cnt)
17727 {
17728 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17729 }
17730 else
17731 {
17732 dictpos++;
17733
17734 rd->dictpos = dictpos;
17735 }
17736 }
17737
17738 time_t runtime_stop;
17739
17740 time (&runtime_stop);
17741
17742 data.runtime_stop = runtime_stop;
17743
17744 logfile_sub_uint (runtime_start);
17745 logfile_sub_uint (runtime_stop);
17746
17747 logfile_sub_msg ("STOP");
17748
17749 global_free (subid);
17750 }
17751
17752 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17753
17754 if (data.devices_status == STATUS_CRACKED) break;
17755 if (data.devices_status == STATUS_ABORTED) break;
17756 if (data.devices_status == STATUS_QUIT) break;
17757
17758 if (data.devices_status == STATUS_BYPASS)
17759 {
17760 data.devices_status = STATUS_RUNNING;
17761 }
17762 }
17763
17764 // 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
17765
17766 if (attack_mode == ATTACK_MODE_STRAIGHT)
17767 {
17768 if (data.wordlist_mode == WL_MODE_FILE)
17769 {
17770 if (data.dictfile == NULL)
17771 {
17772 if (dictfiles != NULL)
17773 {
17774 data.dictfile = dictfiles[0];
17775
17776 hc_timer_set (&data.timer_running);
17777 }
17778 }
17779 }
17780 }
17781 // NOTE: combi is okay because it is already set beforehand
17782 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17783 {
17784 if (data.dictfile == NULL)
17785 {
17786 if (dictfiles != NULL)
17787 {
17788 hc_timer_set (&data.timer_running);
17789
17790 data.dictfile = dictfiles[0];
17791 }
17792 }
17793 }
17794 else if (attack_mode == ATTACK_MODE_BF)
17795 {
17796 if (data.mask == NULL)
17797 {
17798 hc_timer_set (&data.timer_running);
17799
17800 data.mask = masks[0];
17801 }
17802 }
17803
17804 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17805 {
17806 data.devices_status = STATUS_EXHAUSTED;
17807 }
17808
17809 // if cracked / aborted remove last induction dictionary
17810
17811 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17812 {
17813 struct stat induct_stat;
17814
17815 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17816 {
17817 unlink (induction_dictionaries[file_pos]);
17818 }
17819 }
17820
17821 // wait for non-interactive threads
17822
17823 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17824 {
17825 hc_thread_wait (1, &ni_threads[thread_idx]);
17826 }
17827
17828 local_free (ni_threads);
17829
17830 // wait for interactive threads
17831
17832 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17833 {
17834 hc_thread_wait (1, &i_thread);
17835 }
17836
17837 // we dont need restore file anymore
17838 if (data.restore_disable == 0)
17839 {
17840 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17841 {
17842 unlink (eff_restore_file);
17843 unlink (new_restore_file);
17844 }
17845 else
17846 {
17847 cycle_restore ();
17848 }
17849 }
17850
17851 // finally save left hashes
17852
17853 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17854 {
17855 save_hash ();
17856 }
17857
17858 /**
17859 * Clean up
17860 */
17861
17862 if (benchmark == 1)
17863 {
17864 status_benchmark ();
17865
17866 if (machine_readable == 0)
17867 {
17868 log_info ("");
17869 }
17870 }
17871 else
17872 {
17873 if (quiet == 0) clear_prompt ();
17874
17875 if (quiet == 0) log_info ("");
17876
17877 if (status == 1)
17878 {
17879 status_display ();
17880 }
17881 else
17882 {
17883 if (quiet == 0) status_display ();
17884 }
17885
17886 if (quiet == 0) log_info ("");
17887 }
17888
17889 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17890 {
17891 hc_device_param_t *device_param = &data.devices_param[device_id];
17892
17893 if (device_param->skipped) continue;
17894
17895 local_free (device_param->combs_buf);
17896
17897 local_free (device_param->hooks_buf);
17898
17899 local_free (device_param->device_name);
17900
17901 local_free (device_param->device_name_chksum);
17902
17903 local_free (device_param->device_version);
17904
17905 local_free (device_param->driver_version);
17906
17907 if (device_param->pws_buf) myfree (device_param->pws_buf);
17908 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17909 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17910 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17911 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17912 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17913 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17914 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17915 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17916 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17917 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17918 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17919 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17920 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17921 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17922 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17923 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17924 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17925 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17926 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17927 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17928 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17929 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17930 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17931 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17932 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17933 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17934 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17935 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17936
17937 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17938 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17939 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17940 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17941 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17942 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17943 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17944 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17945 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17946 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17947 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17948
17949 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17950 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17951 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17952
17953 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17954 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17955 }
17956
17957 // reset default fan speed
17958
17959 #ifdef HAVE_HWMON
17960 if (gpu_temp_disable == 0)
17961 {
17962 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17963 {
17964 hc_thread_mutex_lock (mux_adl);
17965
17966 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17967 {
17968 hc_device_param_t *device_param = &data.devices_param[device_id];
17969
17970 if (device_param->skipped) continue;
17971
17972 if (data.hm_device[device_id].fan_set_supported == 1)
17973 {
17974 int fanspeed = temp_retain_fanspeed_value[device_id];
17975 int fanpolicy = temp_retain_fanpolicy_value[device_id];
17976
17977 if (fanpolicy == 1)
17978 {
17979 int rc = -1;
17980
17981 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17982 {
17983 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
17984 }
17985 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17986 {
17987
17988 }
17989
17990 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
17991 }
17992 }
17993 }
17994
17995 hc_thread_mutex_unlock (mux_adl);
17996 }
17997 }
17998
17999 // reset power tuning
18000
18001 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18002 {
18003 hc_thread_mutex_lock (mux_adl);
18004
18005 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18006 {
18007 hc_device_param_t *device_param = &data.devices_param[device_id];
18008
18009 if (device_param->skipped) continue;
18010
18011 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18012 {
18013 if (data.hm_device[device_id].od_version == 6)
18014 {
18015 // check powertune capabilities first, if not available then skip device
18016
18017 int powertune_supported = 0;
18018
18019 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18020 {
18021 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18022
18023 return (-1);
18024 }
18025
18026 if (powertune_supported != 0)
18027 {
18028 // powercontrol settings
18029
18030 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18031 {
18032 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18033
18034 return (-1);
18035 }
18036
18037 // clocks
18038
18039 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18040
18041 performance_state->iNumberOfPerformanceLevels = 2;
18042
18043 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18044 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18045 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18046 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18047
18048 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18049 {
18050 log_info ("ERROR: Failed to restore ADL performance state");
18051
18052 return (-1);
18053 }
18054
18055 local_free (performance_state);
18056 }
18057 }
18058 }
18059
18060 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18061 {
18062 unsigned int limit = nvml_power_limit[device_id];
18063
18064 if (limit > 0)
18065 {
18066 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18067 }
18068 }
18069 }
18070
18071 hc_thread_mutex_unlock (mux_adl);
18072 }
18073
18074 if (gpu_temp_disable == 0)
18075 {
18076 if (data.hm_nvml)
18077 {
18078 hm_NVML_nvmlShutdown (data.hm_nvml);
18079
18080 nvml_close (data.hm_nvml);
18081
18082 data.hm_nvml = NULL;
18083 }
18084
18085 if (data.hm_adl)
18086 {
18087 hm_ADL_Main_Control_Destroy (data.hm_adl);
18088
18089 adl_close (data.hm_adl);
18090
18091 data.hm_adl = NULL;
18092 }
18093 }
18094 #endif // HAVE_HWMON
18095
18096 // free memory
18097
18098 local_free (masks);
18099
18100 local_free (dictstat_base);
18101
18102 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18103 {
18104 pot_t *pot_ptr = &pot[pot_pos];
18105
18106 hash_t *hash = &pot_ptr->hash;
18107
18108 local_free (hash->digest);
18109
18110 if (isSalted)
18111 {
18112 local_free (hash->salt);
18113 }
18114 }
18115
18116 local_free (pot);
18117
18118 local_free (all_kernel_rules_cnt);
18119 local_free (all_kernel_rules_buf);
18120
18121 local_free (wl_data->buf);
18122 local_free (wl_data);
18123
18124 local_free (bitmap_s1_a);
18125 local_free (bitmap_s1_b);
18126 local_free (bitmap_s1_c);
18127 local_free (bitmap_s1_d);
18128 local_free (bitmap_s2_a);
18129 local_free (bitmap_s2_b);
18130 local_free (bitmap_s2_c);
18131 local_free (bitmap_s2_d);
18132
18133 #ifdef HAVE_HWMON
18134 local_free (temp_retain_fanspeed_value);
18135 local_free (od_clock_mem_status);
18136 local_free (od_power_control_status);
18137 local_free (nvml_power_limit);
18138 #endif
18139
18140 global_free (devices_param);
18141
18142 global_free (kernel_rules_buf);
18143
18144 global_free (root_css_buf);
18145 global_free (markov_css_buf);
18146
18147 global_free (digests_buf);
18148 global_free (digests_shown);
18149 global_free (digests_shown_tmp);
18150
18151 global_free (salts_buf);
18152 global_free (salts_shown);
18153
18154 global_free (esalts_buf);
18155
18156 global_free (words_progress_done);
18157 global_free (words_progress_rejected);
18158 global_free (words_progress_restored);
18159
18160 if (pot_fp) fclose (pot_fp);
18161
18162 if (data.devices_status == STATUS_QUIT) break;
18163 }
18164
18165 // destroy others mutex
18166
18167 hc_thread_mutex_delete (mux_dispatcher);
18168 hc_thread_mutex_delete (mux_counter);
18169 hc_thread_mutex_delete (mux_display);
18170 hc_thread_mutex_delete (mux_adl);
18171
18172 // free memory
18173
18174 local_free (eff_restore_file);
18175 local_free (new_restore_file);
18176
18177 local_free (rd);
18178
18179 // tuning db
18180
18181 tuning_db_destroy (tuning_db);
18182
18183 // loopback
18184
18185 local_free (loopback_file);
18186
18187 if (loopback == 1) unlink (loopback_file);
18188
18189 // induction directory
18190
18191 if (induction_dir == NULL)
18192 {
18193 if (attack_mode != ATTACK_MODE_BF)
18194 {
18195 if (rmdir (induction_directory) == -1)
18196 {
18197 if (errno == ENOENT)
18198 {
18199 // good, we can ignore
18200 }
18201 else if (errno == ENOTEMPTY)
18202 {
18203 // good, we can ignore
18204 }
18205 else
18206 {
18207 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18208
18209 return (-1);
18210 }
18211 }
18212
18213 local_free (induction_directory);
18214 }
18215 }
18216
18217 // outfile-check directory
18218
18219 if (outfile_check_dir == NULL)
18220 {
18221 if (rmdir (outfile_check_directory) == -1)
18222 {
18223 if (errno == ENOENT)
18224 {
18225 // good, we can ignore
18226 }
18227 else if (errno == ENOTEMPTY)
18228 {
18229 // good, we can ignore
18230 }
18231 else
18232 {
18233 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18234
18235 return (-1);
18236 }
18237 }
18238
18239 local_free (outfile_check_directory);
18240 }
18241
18242 time_t proc_stop;
18243
18244 time (&proc_stop);
18245
18246 logfile_top_uint (proc_start);
18247 logfile_top_uint (proc_stop);
18248
18249 logfile_top_msg ("STOP");
18250
18251 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18252 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18253
18254 if (data.ocl) ocl_close (data.ocl);
18255
18256 if (data.devices_status == STATUS_ABORTED) return 2;
18257 if (data.devices_status == STATUS_QUIT) return 2;
18258 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18259 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18260 if (data.devices_status == STATUS_CRACKED) return 0;
18261
18262 return -1;
18263 }
Hashcat additions to support pwdhash