projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Do not show hardware manager in final status display in case status is EXHAUSTED...
[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
1541 if (data.devices_status == STATUS_EXHAUSTED) return;
1542 if (data.devices_status == STATUS_CRACKED) return;
1543 if (data.devices_status == STATUS_ABORTED) return;
1544 if (data.devices_status == STATUS_QUIT) return;
1545
1546 if (data.gpu_temp_disable == 0)
1547 {
1548 hc_thread_mutex_lock (mux_adl);
1549
1550 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1551 {
1552 hc_device_param_t *device_param = &data.devices_param[device_id];
1553
1554 if (device_param->skipped) continue;
1555
1556 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1557 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1558 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1559 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1560 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1561 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1562 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1563
1564 char output_buf[256] = { 0 };
1565
1566 int output_len = 0;
1567
1568 if (num_temperature >= 0)
1569 {
1570 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1571
1572 output_len = strlen (output_buf);
1573 }
1574
1575 if (num_fanspeed >= 0)
1576 {
1577 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1578
1579 output_len = strlen (output_buf);
1580 }
1581
1582 if (num_utilization >= 0)
1583 {
1584 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1585
1586 output_len = strlen (output_buf);
1587 }
1588
1589 if (num_corespeed >= 0)
1590 {
1591 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1592
1593 output_len = strlen (output_buf);
1594 }
1595
1596 if (num_memoryspeed >= 0)
1597 {
1598 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1599
1600 output_len = strlen (output_buf);
1601 }
1602
1603 if (num_buslanes >= 0)
1604 {
1605 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1606
1607 output_len = strlen (output_buf);
1608 }
1609
1610 if (num_throttle == 1)
1611 {
1612 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1613
1614 output_len = strlen (output_buf);
1615 }
1616
1617 if (output_len == 0)
1618 {
1619 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1620
1621 output_len = strlen (output_buf);
1622 }
1623
1624 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1625 }
1626
1627 hc_thread_mutex_unlock (mux_adl);
1628 }
1629
1630 #endif // HAVE_HWMON
1631 }
1632
1633 static void status_benchmark_automate ()
1634 {
1635 u64 speed_cnt[DEVICES_MAX] = { 0 };
1636 double speed_ms[DEVICES_MAX] = { 0 };
1637
1638 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1639 {
1640 hc_device_param_t *device_param = &data.devices_param[device_id];
1641
1642 if (device_param->skipped) continue;
1643
1644 speed_cnt[device_id] = device_param->speed_cnt[0];
1645 speed_ms[device_id] = device_param->speed_ms[0];
1646 }
1647
1648 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1649
1650 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1651 {
1652 hc_device_param_t *device_param = &data.devices_param[device_id];
1653
1654 if (device_param->skipped) continue;
1655
1656 hashes_dev_ms[device_id] = 0;
1657
1658 if (speed_ms[device_id])
1659 {
1660 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1661 }
1662 }
1663
1664 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1665 {
1666 hc_device_param_t *device_param = &data.devices_param[device_id];
1667
1668 if (device_param->skipped) continue;
1669
1670 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1671 }
1672 }
1673
1674 static void status_benchmark ()
1675 {
1676 if (data.devices_status == STATUS_INIT) return;
1677 if (data.devices_status == STATUS_STARTING) return;
1678 if (data.devices_status == STATUS_BYPASS) return;
1679
1680 if (data.machine_readable == 1)
1681 {
1682 status_benchmark_automate ();
1683
1684 return;
1685 }
1686
1687 u64 speed_cnt[DEVICES_MAX] = { 0 };
1688 double speed_ms[DEVICES_MAX] = { 0 };
1689
1690 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1691 {
1692 hc_device_param_t *device_param = &data.devices_param[device_id];
1693
1694 if (device_param->skipped) continue;
1695
1696 speed_cnt[device_id] = device_param->speed_cnt[0];
1697 speed_ms[device_id] = device_param->speed_ms[0];
1698 }
1699
1700 double hashes_all_ms = 0;
1701
1702 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1703
1704 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1705 {
1706 hc_device_param_t *device_param = &data.devices_param[device_id];
1707
1708 if (device_param->skipped) continue;
1709
1710 hashes_dev_ms[device_id] = 0;
1711
1712 if (speed_ms[device_id])
1713 {
1714 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1715
1716 hashes_all_ms += hashes_dev_ms[device_id];
1717 }
1718 }
1719
1720 /**
1721 * exec time
1722 */
1723
1724 double exec_all_ms[DEVICES_MAX] = { 0 };
1725
1726 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1727 {
1728 hc_device_param_t *device_param = &data.devices_param[device_id];
1729
1730 if (device_param->skipped) continue;
1731
1732 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1733
1734 exec_all_ms[device_id] = exec_ms_avg;
1735 }
1736
1737 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1738 {
1739 hc_device_param_t *device_param = &data.devices_param[device_id];
1740
1741 if (device_param->skipped) continue;
1742
1743 char display_dev_cur[16] = { 0 };
1744
1745 strncpy (display_dev_cur, "0.00", 4);
1746
1747 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1748
1749 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1750 }
1751
1752 char display_all_cur[16] = { 0 };
1753
1754 strncpy (display_all_cur, "0.00", 4);
1755
1756 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1757
1758 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1759 }
1760
1761 /**
1762 * hashcat -only- functions
1763 */
1764
1765 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1766 {
1767 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1768 {
1769 if (attack_kern == ATTACK_KERN_STRAIGHT)
1770 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1771 else if (attack_kern == ATTACK_KERN_COMBI)
1772 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1773 else if (attack_kern == ATTACK_KERN_BF)
1774 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1775 }
1776 else
1777 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1778 }
1779
1780 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)
1781 {
1782 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1783 {
1784 if (attack_kern == ATTACK_KERN_STRAIGHT)
1785 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1786 else if (attack_kern == ATTACK_KERN_COMBI)
1787 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1788 else if (attack_kern == ATTACK_KERN_BF)
1789 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1790 }
1791 else
1792 {
1793 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1794 }
1795 }
1796
1797 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1798 {
1799 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1800 {
1801 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1802 }
1803 else
1804 {
1805 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1806 }
1807 }
1808
1809 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)
1810 {
1811 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1812 {
1813 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1814 }
1815 else
1816 {
1817 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1818 }
1819 }
1820
1821 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1822 {
1823 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1824 }
1825
1826 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1827 {
1828 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1829 }
1830
1831 static uint convert_from_hex (char *line_buf, const uint line_len)
1832 {
1833 if (line_len & 1) return (line_len); // not in hex
1834
1835 if (data.hex_wordlist == 1)
1836 {
1837 uint i;
1838 uint j;
1839
1840 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1841 {
1842 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1843 }
1844
1845 memset (line_buf + i, 0, line_len - i);
1846
1847 return (i);
1848 }
1849 else if (line_len >= 6) // $HEX[] = 6
1850 {
1851 if (line_buf[0] != '$') return (line_len);
1852 if (line_buf[1] != 'H') return (line_len);
1853 if (line_buf[2] != 'E') return (line_len);
1854 if (line_buf[3] != 'X') return (line_len);
1855 if (line_buf[4] != '[') return (line_len);
1856 if (line_buf[line_len - 1] != ']') return (line_len);
1857
1858 uint i;
1859 uint j;
1860
1861 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1862 {
1863 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1864 }
1865
1866 memset (line_buf + i, 0, line_len - i);
1867
1868 return (i);
1869 }
1870
1871 return (line_len);
1872 }
1873
1874 static void clear_prompt ()
1875 {
1876 fputc ('\r', stdout);
1877
1878 for (size_t i = 0; i < strlen (PROMPT); i++)
1879 {
1880 fputc (' ', stdout);
1881 }
1882
1883 fputc ('\r', stdout);
1884
1885 fflush (stdout);
1886 }
1887
1888 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1889 {
1890 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);
1891 }
1892
1893 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1894 {
1895 char *outfile = data.outfile;
1896 uint quiet = data.quiet;
1897 FILE *pot_fp = data.pot_fp;
1898 uint loopback = data.loopback;
1899 uint debug_mode = data.debug_mode;
1900 char *debug_file = data.debug_file;
1901
1902 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1903 int debug_rule_len = 0; // -1 error
1904 uint debug_plain_len = 0;
1905
1906 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1907
1908 // hash
1909
1910 char out_buf[HCBUFSIZ] = { 0 };
1911
1912 const u32 salt_pos = plain->salt_pos;
1913 const u32 digest_pos = plain->digest_pos; // relative
1914 const u32 gidvid = plain->gidvid;
1915 const u32 il_pos = plain->il_pos;
1916
1917 ascii_digest (out_buf, salt_pos, digest_pos);
1918
1919 // plain
1920
1921 u64 crackpos = device_param->words_off;
1922
1923 uint plain_buf[16] = { 0 };
1924
1925 u8 *plain_ptr = (u8 *) plain_buf;
1926
1927 unsigned int plain_len = 0;
1928
1929 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1930 {
1931 pw_t pw;
1932
1933 gidd_to_pw_t (device_param, gidvid, &pw);
1934
1935 for (int i = 0; i < 16; i++)
1936 {
1937 plain_buf[i] = pw.i[i];
1938 }
1939
1940 plain_len = pw.pw_len;
1941
1942 const uint off = device_param->innerloop_pos + il_pos;
1943
1944 if (debug_mode > 0)
1945 {
1946 debug_rule_len = 0;
1947
1948 // save rule
1949 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1950 {
1951 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1952
1953 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1954 }
1955
1956 // save plain
1957 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1958 {
1959 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1960
1961 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1962
1963 debug_plain_len = plain_len;
1964 }
1965 }
1966
1967 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1968
1969 crackpos += gidvid;
1970 crackpos *= data.kernel_rules_cnt;
1971 crackpos += device_param->innerloop_pos + il_pos;
1972
1973 if (plain_len > data.pw_max) plain_len = data.pw_max;
1974 }
1975 else if (data.attack_mode == ATTACK_MODE_COMBI)
1976 {
1977 pw_t pw;
1978
1979 gidd_to_pw_t (device_param, gidvid, &pw);
1980
1981 for (int i = 0; i < 16; i++)
1982 {
1983 plain_buf[i] = pw.i[i];
1984 }
1985
1986 plain_len = pw.pw_len;
1987
1988 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1989 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1990
1991 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1992 {
1993 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1994 }
1995 else
1996 {
1997 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1998
1999 memcpy (plain_ptr, comb_buf, comb_len);
2000 }
2001
2002 plain_len += comb_len;
2003
2004 crackpos += gidvid;
2005 crackpos *= data.combs_cnt;
2006 crackpos += device_param->innerloop_pos + il_pos;
2007
2008 if (data.pw_max != PW_DICTMAX1)
2009 {
2010 if (plain_len > data.pw_max) plain_len = data.pw_max;
2011 }
2012 }
2013 else if (data.attack_mode == ATTACK_MODE_BF)
2014 {
2015 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2016 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2017
2018 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2019 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2020
2021 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2022 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2023
2024 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2025 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2026
2027 plain_len = data.css_cnt;
2028
2029 crackpos += gidvid;
2030 crackpos *= data.bfs_cnt;
2031 crackpos += device_param->innerloop_pos + il_pos;
2032 }
2033 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2034 {
2035 pw_t pw;
2036
2037 gidd_to_pw_t (device_param, gidvid, &pw);
2038
2039 for (int i = 0; i < 16; i++)
2040 {
2041 plain_buf[i] = pw.i[i];
2042 }
2043
2044 plain_len = pw.pw_len;
2045
2046 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2047
2048 uint start = 0;
2049 uint stop = device_param->kernel_params_mp_buf32[4];
2050
2051 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2052
2053 plain_len += start + stop;
2054
2055 crackpos += gidvid;
2056 crackpos *= data.combs_cnt;
2057 crackpos += device_param->innerloop_pos + il_pos;
2058
2059 if (data.pw_max != PW_DICTMAX1)
2060 {
2061 if (plain_len > data.pw_max) plain_len = data.pw_max;
2062 }
2063 }
2064 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2065 {
2066 pw_t pw;
2067
2068 gidd_to_pw_t (device_param, gidvid, &pw);
2069
2070 for (int i = 0; i < 16; i++)
2071 {
2072 plain_buf[i] = pw.i[i];
2073 }
2074
2075 plain_len = pw.pw_len;
2076
2077 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2078
2079 uint start = 0;
2080 uint stop = device_param->kernel_params_mp_buf32[4];
2081
2082 memmove (plain_ptr + stop, plain_ptr, plain_len);
2083
2084 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2085
2086 plain_len += start + stop;
2087
2088 crackpos += gidvid;
2089 crackpos *= data.combs_cnt;
2090 crackpos += device_param->innerloop_pos + il_pos;
2091
2092 if (data.pw_max != PW_DICTMAX1)
2093 {
2094 if (plain_len > data.pw_max) plain_len = data.pw_max;
2095 }
2096 }
2097
2098 if (data.attack_mode == ATTACK_MODE_BF)
2099 {
2100 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2101 {
2102 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2103 {
2104 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2105 {
2106 plain_len = plain_len - data.salts_buf[0].salt_len;
2107 }
2108 }
2109
2110 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2111 {
2112 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2113 {
2114 plain_ptr[j] = plain_ptr[i];
2115 }
2116
2117 plain_len = plain_len / 2;
2118 }
2119 }
2120 }
2121
2122 // if enabled, update also the potfile
2123
2124 if (pot_fp)
2125 {
2126 lock_file (pot_fp);
2127
2128 fprintf (pot_fp, "%s:", out_buf);
2129
2130 format_plain (pot_fp, plain_ptr, plain_len, 1);
2131
2132 fputc ('\n', pot_fp);
2133
2134 fflush (pot_fp);
2135
2136 unlock_file (pot_fp);
2137 }
2138
2139 // outfile
2140
2141 FILE *out_fp = NULL;
2142
2143 if (outfile != NULL)
2144 {
2145 if ((out_fp = fopen (outfile, "ab")) == NULL)
2146 {
2147 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2148
2149 out_fp = stdout;
2150 }
2151
2152 lock_file (out_fp);
2153 }
2154 else
2155 {
2156 out_fp = stdout;
2157
2158 if (quiet == 0) clear_prompt ();
2159 }
2160
2161 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2162
2163 if (outfile != NULL)
2164 {
2165 if (out_fp != stdout)
2166 {
2167 fclose (out_fp);
2168 }
2169 }
2170 else
2171 {
2172 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2173 {
2174 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2175 {
2176 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2177 if (quiet == 0) fflush (stdout);
2178 }
2179 }
2180 }
2181
2182 // loopback
2183
2184 if (loopback)
2185 {
2186 char *loopback_file = data.loopback_file;
2187
2188 FILE *fb_fp = NULL;
2189
2190 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2191 {
2192 lock_file (fb_fp);
2193
2194 format_plain (fb_fp, plain_ptr, plain_len, 1);
2195
2196 fputc ('\n', fb_fp);
2197
2198 fclose (fb_fp);
2199 }
2200 }
2201
2202 // (rule) debug mode
2203
2204 // the next check implies that:
2205 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2206 // - debug_mode > 0
2207
2208 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2209 {
2210 if (debug_rule_len < 0) debug_rule_len = 0;
2211
2212 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2213
2214 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2215
2216 if ((quiet == 0) && (debug_file == NULL))
2217 {
2218 fprintf (stdout, "%s", PROMPT);
2219
2220 fflush (stdout);
2221 }
2222 }
2223 }
2224
2225 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2226 {
2227 salt_t *salt_buf = &data.salts_buf[salt_pos];
2228
2229 u32 num_cracked;
2230
2231 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2232
2233 if (num_cracked)
2234 {
2235 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2236
2237 log_info_nn ("");
2238
2239 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2240
2241 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);
2242
2243 uint cpt_cracked = 0;
2244
2245 for (uint i = 0; i < num_cracked; i++)
2246 {
2247 const uint hash_pos = cracked[i].hash_pos;
2248
2249 if (data.digests_shown[hash_pos] == 1) continue;
2250
2251 hc_thread_mutex_lock (mux_display);
2252
2253 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2254 {
2255 data.digests_shown[hash_pos] = 1;
2256
2257 data.digests_done++;
2258
2259 cpt_cracked++;
2260
2261 salt_buf->digests_done++;
2262
2263 if (salt_buf->digests_done == salt_buf->digests_cnt)
2264 {
2265 data.salts_shown[salt_pos] = 1;
2266
2267 data.salts_done++;
2268 }
2269 }
2270
2271 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2272
2273 hc_thread_mutex_unlock (mux_display);
2274
2275 check_hash (device_param, &cracked[i]);
2276 }
2277
2278 myfree (cracked);
2279
2280 if (cpt_cracked > 0)
2281 {
2282 hc_thread_mutex_lock (mux_display);
2283
2284 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2285 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2286
2287 data.cpt_pos++;
2288
2289 data.cpt_total += cpt_cracked;
2290
2291 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2292
2293 hc_thread_mutex_unlock (mux_display);
2294 }
2295
2296 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2297 {
2298 // we need to reset cracked state on the device
2299 // otherwise host thinks again and again the hash was cracked
2300 // and returns invalid password each time
2301
2302 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2303
2304 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);
2305 }
2306
2307 num_cracked = 0;
2308
2309 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2310 }
2311 }
2312
2313 static void save_hash ()
2314 {
2315 char *hashfile = data.hashfile;
2316
2317 char new_hashfile[256] = { 0 };
2318 char old_hashfile[256] = { 0 };
2319
2320 snprintf (new_hashfile, 255, "%s.new", hashfile);
2321 snprintf (old_hashfile, 255, "%s.old", hashfile);
2322
2323 unlink (new_hashfile);
2324
2325 char separator = data.separator;
2326
2327 FILE *fp = fopen (new_hashfile, "wb");
2328
2329 if (fp == NULL)
2330 {
2331 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2332
2333 exit (-1);
2334 }
2335
2336 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2337 {
2338 if (data.salts_shown[salt_pos] == 1) continue;
2339
2340 salt_t *salt_buf = &data.salts_buf[salt_pos];
2341
2342 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2343 {
2344 uint idx = salt_buf->digests_offset + digest_pos;
2345
2346 if (data.digests_shown[idx] == 1) continue;
2347
2348 if (data.hash_mode != 2500)
2349 {
2350 char out_buf[HCBUFSIZ] = { 0 };
2351
2352 if (data.username == 1)
2353 {
2354 user_t *user = data.hash_info[idx]->user;
2355
2356 uint i;
2357
2358 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2359
2360 fputc (separator, fp);
2361 }
2362
2363 ascii_digest (out_buf, salt_pos, digest_pos);
2364
2365 fputs (out_buf, fp);
2366
2367 log_out (fp, "");
2368 }
2369 else
2370 {
2371 hccap_t hccap;
2372
2373 to_hccap_t (&hccap, salt_pos, digest_pos);
2374
2375 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2376 }
2377 }
2378 }
2379
2380 fflush (fp);
2381
2382 fclose (fp);
2383
2384 unlink (old_hashfile);
2385
2386 if (rename (hashfile, old_hashfile) != 0)
2387 {
2388 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2389
2390 exit (-1);
2391 }
2392
2393 unlink (hashfile);
2394
2395 if (rename (new_hashfile, hashfile) != 0)
2396 {
2397 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2398
2399 exit (-1);
2400 }
2401
2402 unlink (old_hashfile);
2403 }
2404
2405 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2406 {
2407 // function called only in case kernel_power_all > words_left
2408
2409 float kernel_power_div = (float) (total_left) / kernel_power_all;
2410
2411 kernel_power_div += kernel_power_div / 100;
2412
2413 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2414
2415 while (kernel_power_new < total_left)
2416 {
2417 kernel_power_div += kernel_power_div / 100;
2418
2419 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2420 }
2421
2422 if (data.quiet == 0)
2423 {
2424 clear_prompt ();
2425
2426 //log_info ("");
2427
2428 log_info ("INFO: approaching final keyspace, workload adjusted");
2429 log_info ("");
2430
2431 fprintf (stdout, "%s", PROMPT);
2432
2433 fflush (stdout);
2434 }
2435
2436 //if ((kernel_power_all * kernel_power_div) < 8) return 1;
2437
2438 return kernel_power_div;
2439 }
2440
2441 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2442 {
2443 uint num_elements = num;
2444
2445 device_param->kernel_params_buf32[30] = data.combs_mode;
2446 device_param->kernel_params_buf32[31] = num;
2447
2448 uint kernel_threads = device_param->kernel_threads;
2449
2450 while (num_elements % kernel_threads) num_elements++;
2451
2452 cl_kernel kernel = NULL;
2453
2454 switch (kern_run)
2455 {
2456 case KERN_RUN_1: kernel = device_param->kernel1; break;
2457 case KERN_RUN_12: kernel = device_param->kernel12; break;
2458 case KERN_RUN_2: kernel = device_param->kernel2; break;
2459 case KERN_RUN_23: kernel = device_param->kernel23; break;
2460 case KERN_RUN_3: kernel = device_param->kernel3; break;
2461 }
2462
2463 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2464 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2465 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2466 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2467 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2468 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2469 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2470 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2471 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2472 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2473 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2474
2475 cl_event event;
2476
2477 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2478 {
2479 const size_t global_work_size[3] = { num_elements, 32, 1 };
2480 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2481
2482 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2483 }
2484 else
2485 {
2486 if (kern_run == KERN_RUN_2)
2487 {
2488 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2489 {
2490 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2491 }
2492 }
2493
2494 while (num_elements % kernel_threads) num_elements++;
2495
2496 const size_t global_work_size[3] = { num_elements, 1, 1 };
2497 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2498
2499 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2500 }
2501
2502 hc_clFlush (data.ocl, device_param->command_queue);
2503
2504 hc_clWaitForEvents (data.ocl, 1, &event);
2505
2506 if (event_update)
2507 {
2508 cl_ulong time_start;
2509 cl_ulong time_end;
2510
2511 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2512 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2513
2514 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2515
2516 uint exec_pos = device_param->exec_pos;
2517
2518 device_param->exec_ms[exec_pos] = exec_time;
2519
2520 exec_pos++;
2521
2522 if (exec_pos == EXEC_CACHE)
2523 {
2524 exec_pos = 0;
2525 }
2526
2527 device_param->exec_pos = exec_pos;
2528 }
2529
2530 hc_clReleaseEvent (data.ocl, event);
2531
2532 hc_clFinish (data.ocl, device_param->command_queue);
2533 }
2534
2535 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2536 {
2537 uint num_elements = num;
2538
2539 switch (kern_run)
2540 {
2541 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2542 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2543 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2544 }
2545
2546 // causes problems with special threads like in bcrypt
2547 // const uint kernel_threads = device_param->kernel_threads;
2548
2549 uint kernel_threads = device_param->kernel_threads;
2550
2551 while (num_elements % kernel_threads) num_elements++;
2552
2553 cl_kernel kernel = NULL;
2554
2555 switch (kern_run)
2556 {
2557 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2558 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2559 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2560 }
2561
2562 switch (kern_run)
2563 {
2564 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2565 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2566 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2567 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2568 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2569 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2570 break;
2571 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2572 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2573 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2574 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2575 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2576 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2577 break;
2578 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2579 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2580 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2581 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2582 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2583 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2584 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2585 break;
2586 }
2587
2588 const size_t global_work_size[3] = { num_elements, 1, 1 };
2589 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2590
2591 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2592
2593 hc_clFlush (data.ocl, device_param->command_queue);
2594
2595 hc_clFinish (data.ocl, device_param->command_queue);
2596 }
2597
2598 static void run_kernel_tm (hc_device_param_t *device_param)
2599 {
2600 const uint num_elements = 1024; // fixed
2601
2602 uint kernel_threads = 32;
2603
2604 cl_kernel kernel = device_param->kernel_tm;
2605
2606 const size_t global_work_size[3] = { num_elements, 1, 1 };
2607 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2608
2609 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2610
2611 hc_clFlush (data.ocl, device_param->command_queue);
2612
2613 hc_clFinish (data.ocl, device_param->command_queue);
2614 }
2615
2616 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2617 {
2618 uint num_elements = num;
2619
2620 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2621 device_param->kernel_params_amp_buf32[6] = num_elements;
2622
2623 // causes problems with special threads like in bcrypt
2624 // const uint kernel_threads = device_param->kernel_threads;
2625
2626 uint kernel_threads = device_param->kernel_threads;
2627
2628 while (num_elements % kernel_threads) num_elements++;
2629
2630 cl_kernel kernel = device_param->kernel_amp;
2631
2632 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2633 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2634
2635 const size_t global_work_size[3] = { num_elements, 1, 1 };
2636 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2637
2638 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2639
2640 hc_clFlush (data.ocl, device_param->command_queue);
2641
2642 hc_clFinish (data.ocl, device_param->command_queue);
2643 }
2644
2645 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2646 {
2647 const u32 num16d = num / 16;
2648 const u32 num16m = num % 16;
2649
2650 if (num16d)
2651 {
2652 device_param->kernel_params_memset_buf32[1] = value;
2653 device_param->kernel_params_memset_buf32[2] = num16d;
2654
2655 uint kernel_threads = device_param->kernel_threads;
2656
2657 uint num_elements = num16d;
2658
2659 while (num_elements % kernel_threads) num_elements++;
2660
2661 cl_kernel kernel = device_param->kernel_memset;
2662
2663 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2664 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2665 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2666
2667 const size_t global_work_size[3] = { num_elements, 1, 1 };
2668 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2669
2670 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2671
2672 hc_clFlush (data.ocl, device_param->command_queue);
2673
2674 hc_clFinish (data.ocl, device_param->command_queue);
2675 }
2676
2677 if (num16m)
2678 {
2679 u32 tmp[4];
2680
2681 tmp[0] = value;
2682 tmp[1] = value;
2683 tmp[2] = value;
2684 tmp[3] = value;
2685
2686 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2687 }
2688 }
2689
2690 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2691 {
2692 run_kernel_memset (device_param, buf, 0, size);
2693
2694 /*
2695 int rc = -1;
2696
2697 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2698 {
2699 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2700
2701 const cl_uchar zero = 0;
2702
2703 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2704 }
2705
2706 if (rc != 0)
2707 {
2708 // NOTE: clEnqueueFillBuffer () always fails with -59
2709 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2710 // How's that possible, OpenCL 1.2 support is advertised??
2711 // We need to workaround...
2712
2713 #define FILLSZ 0x100000
2714
2715 char *tmp = (char *) mymalloc (FILLSZ);
2716
2717 for (size_t i = 0; i < size; i += FILLSZ)
2718 {
2719 const size_t left = size - i;
2720
2721 const size_t fillsz = MIN (FILLSZ, left);
2722
2723 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2724 }
2725
2726 myfree (tmp);
2727 }
2728 */
2729 }
2730
2731 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)
2732 {
2733 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2734 {
2735 if (attack_mode == ATTACK_MODE_BF)
2736 {
2737 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2738 {
2739 const uint size_tm = 32 * sizeof (bs_word_t);
2740
2741 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2742
2743 run_kernel_tm (device_param);
2744
2745 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);
2746 }
2747 }
2748
2749 if (highest_pw_len < 16)
2750 {
2751 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2752 }
2753 else if (highest_pw_len < 32)
2754 {
2755 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2756 }
2757 else
2758 {
2759 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2760 }
2761 }
2762 else
2763 {
2764 run_kernel_amp (device_param, pws_cnt);
2765
2766 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2767
2768 if (opts_type & OPTS_TYPE_HOOK12)
2769 {
2770 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2771 }
2772
2773 uint iter = salt_buf->salt_iter;
2774
2775 uint loop_step = device_param->kernel_loops;
2776
2777 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2778 {
2779 uint loop_left = iter - loop_pos;
2780
2781 loop_left = MIN (loop_left, loop_step);
2782
2783 device_param->kernel_params_buf32[25] = loop_pos;
2784 device_param->kernel_params_buf32[26] = loop_left;
2785
2786 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2787
2788 if (data.devices_status == STATUS_CRACKED) break;
2789 if (data.devices_status == STATUS_ABORTED) break;
2790 if (data.devices_status == STATUS_QUIT) break;
2791
2792 /**
2793 * speed
2794 */
2795
2796 const float iter_part = (float) (loop_pos + loop_left) / iter;
2797
2798 const u64 perf_sum_all = pws_cnt * iter_part;
2799
2800 double speed_ms;
2801
2802 hc_timer_get (device_param->timer_speed, speed_ms);
2803
2804 const u32 speed_pos = device_param->speed_pos;
2805
2806 device_param->speed_cnt[speed_pos] = perf_sum_all;
2807
2808 device_param->speed_ms[speed_pos] = speed_ms;
2809
2810 if (data.benchmark == 1)
2811 {
2812 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2813 }
2814 }
2815
2816 if (opts_type & OPTS_TYPE_HOOK23)
2817 {
2818 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2819
2820 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);
2821
2822 // do something with data
2823
2824 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);
2825 }
2826
2827 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2828 }
2829 }
2830
2831 static int run_rule_engine (const int rule_len, const char *rule_buf)
2832 {
2833 if (rule_len == 0)
2834 {
2835 return 0;
2836 }
2837 else if (rule_len == 1)
2838 {
2839 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2840 }
2841
2842 return 1;
2843 }
2844
2845 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2846 {
2847 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2848 {
2849 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);
2850 }
2851 else if (data.attack_kern == ATTACK_KERN_COMBI)
2852 {
2853 if (data.attack_mode == ATTACK_MODE_COMBI)
2854 {
2855 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2856 {
2857 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2858 {
2859 for (u32 i = 0; i < pws_cnt; i++)
2860 {
2861 const u32 pw_len = device_param->pws_buf[i].pw_len;
2862
2863 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2864
2865 ptr[pw_len] = 0x01;
2866 }
2867 }
2868 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2869 {
2870 for (u32 i = 0; i < pws_cnt; i++)
2871 {
2872 const u32 pw_len = device_param->pws_buf[i].pw_len;
2873
2874 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2875
2876 ptr[pw_len] = 0x80;
2877 }
2878 }
2879 }
2880 }
2881 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2882 {
2883 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2884 {
2885 for (u32 i = 0; i < pws_cnt; i++)
2886 {
2887 const u32 pw_len = device_param->pws_buf[i].pw_len;
2888
2889 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2890
2891 ptr[pw_len] = 0x01;
2892 }
2893 }
2894 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2895 {
2896 for (u32 i = 0; i < pws_cnt; i++)
2897 {
2898 const u32 pw_len = device_param->pws_buf[i].pw_len;
2899
2900 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2901
2902 ptr[pw_len] = 0x80;
2903 }
2904 }
2905 }
2906
2907 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);
2908 }
2909 else if (data.attack_kern == ATTACK_KERN_BF)
2910 {
2911 const u64 off = device_param->words_off;
2912
2913 device_param->kernel_params_mp_l_buf64[3] = off;
2914
2915 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2916 }
2917 }
2918
2919 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2920 {
2921 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2922
2923 device_param->kernel_params_buf32[25] = 0;
2924 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2925 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2926
2927 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2928 {
2929 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true);
2930 }
2931 else
2932 {
2933 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true);
2934 }
2935
2936 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2937
2938 return exec_ms_prev;
2939 }
2940
2941 static void autotune (hc_device_param_t *device_param)
2942 {
2943 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2944
2945 const u32 kernel_accel_min = device_param->kernel_accel_min;
2946 const u32 kernel_accel_max = device_param->kernel_accel_max;
2947
2948 const u32 kernel_loops_min = device_param->kernel_loops_min;
2949 const u32 kernel_loops_max = device_param->kernel_loops_max;
2950
2951 u32 kernel_accel = kernel_accel_min;
2952 u32 kernel_loops = kernel_loops_min;
2953
2954 // in this case the user specified a fixed -u and -n on the commandline
2955 // no way to tune anything
2956 // but we need to run a few caching rounds
2957
2958 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2959 {
2960 try_run (device_param, kernel_accel, kernel_loops);
2961 try_run (device_param, kernel_accel, kernel_loops);
2962 try_run (device_param, kernel_accel, kernel_loops);
2963 try_run (device_param, kernel_accel, kernel_loops);
2964
2965 device_param->kernel_accel = kernel_accel;
2966 device_param->kernel_loops = kernel_loops;
2967
2968 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2969
2970 device_param->kernel_power = kernel_power;
2971
2972 return;
2973 }
2974
2975 // from here it's clear we are allowed to autotune
2976 // so let's init some fake words
2977
2978 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2979
2980 if (data.attack_kern == ATTACK_KERN_BF)
2981 {
2982 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2983 }
2984 else
2985 {
2986 for (u32 i = 0; i < kernel_power_max; i++)
2987 {
2988 device_param->pws_buf[i].i[0] = i;
2989 device_param->pws_buf[i].i[1] = 0x01234567;
2990 device_param->pws_buf[i].pw_len = 7 + (i & 7);
2991 }
2992
2993 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);
2994 }
2995
2996 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2997 {
2998 if (data.kernel_rules_cnt > 1)
2999 {
3000 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);
3001 }
3002 }
3003 else
3004 {
3005 run_kernel_amp (device_param, kernel_power_max);
3006 }
3007
3008 #define VERIFIER_CNT 1
3009
3010 // first find out highest kernel-loops that stays below target_ms
3011
3012 if (kernel_loops_min < kernel_loops_max)
3013 {
3014 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3015 {
3016 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3017
3018 for (int i = 0; i < VERIFIER_CNT; i++)
3019 {
3020 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3021
3022 exec_ms = MIN (exec_ms, exec_ms_v);
3023 }
3024
3025 if (exec_ms < target_ms) break;
3026 }
3027 }
3028
3029 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3030
3031 #define STEPS_CNT 10
3032
3033 if (kernel_accel_min < kernel_accel_max)
3034 {
3035 for (int i = 0; i < STEPS_CNT; i++)
3036 {
3037 const u32 kernel_accel_try = 1 << i;
3038
3039 if (kernel_accel_try < kernel_accel_min) continue;
3040 if (kernel_accel_try > kernel_accel_max) break;
3041
3042 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3043
3044 for (int i = 0; i < VERIFIER_CNT; i++)
3045 {
3046 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3047
3048 exec_ms = MIN (exec_ms, exec_ms_v);
3049 }
3050
3051 if (exec_ms > target_ms) break;
3052
3053 kernel_accel = kernel_accel_try;
3054 }
3055 }
3056
3057 // at this point we want to know the actual runtime for the following reason:
3058 // we need a reference for the balancing loop following up, and this
3059 // the balancing loop can have an effect that the creates a new opportunity, for example:
3060 // if the target is 95 ms and the current runtime is 48ms the above loop
3061 // stopped the execution because the previous exec_ms was > 95ms
3062 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3063 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3064
3065 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3066
3067 for (int i = 0; i < VERIFIER_CNT; i++)
3068 {
3069 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3070
3071 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3072 }
3073
3074 u32 diff = kernel_loops - kernel_accel;
3075
3076 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3077 {
3078 u32 kernel_accel_orig = kernel_accel;
3079 u32 kernel_loops_orig = kernel_loops;
3080
3081 for (u32 f = 1; f < 1024; f++)
3082 {
3083 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3084 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3085
3086 if (kernel_accel_try > kernel_accel_max) break;
3087 if (kernel_loops_try < kernel_loops_min) break;
3088
3089 u32 diff_new = kernel_loops_try - kernel_accel_try;
3090
3091 if (diff_new > diff) break;
3092
3093 diff_new = diff;
3094
3095 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3096
3097 for (int i = 0; i < VERIFIER_CNT; i++)
3098 {
3099 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3100
3101 exec_ms = MIN (exec_ms, exec_ms_v);
3102 }
3103
3104 if (exec_ms < exec_ms_pre_final)
3105 {
3106 exec_ms_pre_final = exec_ms;
3107
3108 kernel_accel = kernel_accel_try;
3109 kernel_loops = kernel_loops_try;
3110 }
3111 }
3112 }
3113
3114 const double exec_left = target_ms / exec_ms_pre_final;
3115
3116 const double accel_left = kernel_accel_max / kernel_accel;
3117
3118 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3119
3120 if (exec_accel_min >= 1.0)
3121 {
3122 // this is safe to not overflow kernel_accel_max because of accel_left
3123
3124 kernel_accel = (double) kernel_accel * exec_accel_min;
3125 }
3126
3127 // reset them fake words
3128
3129 /*
3130 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3131
3132 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);
3133 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);
3134 */
3135
3136 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3137
3138 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3139 {
3140 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3141 }
3142
3143 // reset timer
3144
3145 device_param->exec_pos = 0;
3146
3147 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3148
3149 // store
3150
3151 device_param->kernel_accel = kernel_accel;
3152 device_param->kernel_loops = kernel_loops;
3153
3154 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3155
3156 device_param->kernel_power = kernel_power;
3157
3158 #ifdef DEBUG
3159
3160 if (data.quiet == 0)
3161 {
3162 clear_prompt ();
3163
3164 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3165 "Device #%u: autotuned kernel-loops to %u\n",
3166 device_param->device_id + 1, kernel_accel,
3167 device_param->device_id + 1, kernel_loops);
3168
3169 fprintf (stdout, "%s", PROMPT);
3170
3171 fflush (stdout);
3172 }
3173
3174 #endif
3175 }
3176
3177 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3178 {
3179 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3180
3181 // init speed timer
3182
3183 uint speed_pos = device_param->speed_pos;
3184
3185 #ifdef _POSIX
3186 if (device_param->timer_speed.tv_sec == 0)
3187 {
3188 hc_timer_set (&device_param->timer_speed);
3189 }
3190 #endif
3191
3192 #ifdef _WIN
3193 if (device_param->timer_speed.QuadPart == 0)
3194 {
3195 hc_timer_set (&device_param->timer_speed);
3196 }
3197 #endif
3198
3199 // find higest password length, this is for optimization stuff
3200
3201 uint highest_pw_len = 0;
3202
3203 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3204 {
3205 }
3206 else if (data.attack_kern == ATTACK_KERN_COMBI)
3207 {
3208 }
3209 else if (data.attack_kern == ATTACK_KERN_BF)
3210 {
3211 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3212 + device_param->kernel_params_mp_l_buf32[5];
3213 }
3214
3215 // iteration type
3216
3217 uint innerloop_step = 0;
3218 uint innerloop_cnt = 0;
3219
3220 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3221 else innerloop_step = 1;
3222
3223 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3224 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3225 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3226
3227 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3228
3229 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3230 {
3231 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3232
3233 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3234
3235 if (data.devices_status == STATUS_CRACKED) break;
3236 if (data.devices_status == STATUS_ABORTED) break;
3237 if (data.devices_status == STATUS_QUIT) break;
3238 if (data.devices_status == STATUS_BYPASS) break;
3239
3240 salt_t *salt_buf = &data.salts_buf[salt_pos];
3241
3242 device_param->kernel_params_buf32[24] = salt_pos;
3243 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3244 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3245
3246 FILE *combs_fp = device_param->combs_fp;
3247
3248 if (data.attack_mode == ATTACK_MODE_COMBI)
3249 {
3250 rewind (combs_fp);
3251 }
3252
3253 // innerloops
3254
3255 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3256 {
3257 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3258
3259 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3260
3261 if (data.devices_status == STATUS_CRACKED) break;
3262 if (data.devices_status == STATUS_ABORTED) break;
3263 if (data.devices_status == STATUS_QUIT) break;
3264 if (data.devices_status == STATUS_BYPASS) break;
3265
3266 uint innerloop_left = innerloop_cnt - innerloop_pos;
3267
3268 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3269
3270 device_param->innerloop_pos = innerloop_pos;
3271 device_param->innerloop_left = innerloop_left;
3272
3273 device_param->kernel_params_buf32[27] = innerloop_left;
3274
3275 // i think we can get rid of this
3276 if (innerloop_left == 0)
3277 {
3278 puts ("bug, how should this happen????\n");
3279
3280 continue;
3281 }
3282
3283 if (data.salts_shown[salt_pos] == 1)
3284 {
3285 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3286
3287 continue;
3288 }
3289
3290 // initialize amplifiers
3291
3292 if (data.attack_mode == ATTACK_MODE_COMBI)
3293 {
3294 uint i = 0;
3295
3296 while (i < innerloop_left)
3297 {
3298 if (feof (combs_fp)) break;
3299
3300 int line_len = fgetl (combs_fp, line_buf);
3301
3302 if (line_len >= PW_MAX1) continue;
3303
3304 line_len = convert_from_hex (line_buf, line_len);
3305
3306 char *line_buf_new = line_buf;
3307
3308 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3309 {
3310 char rule_buf_out[BLOCK_SIZE] = { 0 };
3311
3312 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3313
3314 if (rule_len_out < 0)
3315 {
3316 data.words_progress_rejected[salt_pos] += pws_cnt;
3317
3318 continue;
3319 }
3320
3321 line_len = rule_len_out;
3322
3323 line_buf_new = rule_buf_out;
3324 }
3325
3326 line_len = MIN (line_len, PW_DICTMAX);
3327
3328 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3329
3330 memcpy (ptr, line_buf_new, line_len);
3331
3332 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3333
3334 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3335 {
3336 uppercase (ptr, line_len);
3337 }
3338
3339 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3340 {
3341 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3342 {
3343 ptr[line_len] = 0x80;
3344 }
3345
3346 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3347 {
3348 ptr[line_len] = 0x01;
3349 }
3350 }
3351
3352 device_param->combs_buf[i].pw_len = line_len;
3353
3354 i++;
3355 }
3356
3357 for (uint j = i; j < innerloop_left; j++)
3358 {
3359 device_param->combs_buf[j].i[0] = 0;
3360 device_param->combs_buf[j].i[1] = 0;
3361 device_param->combs_buf[j].i[2] = 0;
3362 device_param->combs_buf[j].i[3] = 0;
3363 device_param->combs_buf[j].i[4] = 0;
3364 device_param->combs_buf[j].i[5] = 0;
3365 device_param->combs_buf[j].i[6] = 0;
3366 device_param->combs_buf[j].i[7] = 0;
3367
3368 device_param->combs_buf[j].pw_len = 0;
3369 }
3370
3371 innerloop_left = i;
3372 }
3373 else if (data.attack_mode == ATTACK_MODE_BF)
3374 {
3375 u64 off = innerloop_pos;
3376
3377 device_param->kernel_params_mp_r_buf64[3] = off;
3378
3379 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3380 }
3381 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3382 {
3383 u64 off = innerloop_pos;
3384
3385 device_param->kernel_params_mp_buf64[3] = off;
3386
3387 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3388 }
3389 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3390 {
3391 u64 off = innerloop_pos;
3392
3393 device_param->kernel_params_mp_buf64[3] = off;
3394
3395 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3396 }
3397
3398 // copy amplifiers
3399
3400 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3401 {
3402 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);
3403 }
3404 else if (data.attack_mode == ATTACK_MODE_COMBI)
3405 {
3406 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);
3407 }
3408 else if (data.attack_mode == ATTACK_MODE_BF)
3409 {
3410 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);
3411 }
3412 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3413 {
3414 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);
3415 }
3416 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3417 {
3418 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);
3419 }
3420
3421 if (data.benchmark == 1)
3422 {
3423 hc_timer_set (&device_param->timer_speed);
3424 }
3425
3426 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3427
3428 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3429
3430 if (data.devices_status == STATUS_CRACKED) break;
3431 if (data.devices_status == STATUS_ABORTED) break;
3432 if (data.devices_status == STATUS_QUIT) break;
3433
3434 /**
3435 * result
3436 */
3437
3438 check_cracked (device_param, salt_pos);
3439
3440 /**
3441 * progress
3442 */
3443
3444 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3445
3446 hc_thread_mutex_lock (mux_counter);
3447
3448 data.words_progress_done[salt_pos] += perf_sum_all;
3449
3450 hc_thread_mutex_unlock (mux_counter);
3451
3452 /**
3453 * speed
3454 */
3455
3456 double speed_ms;
3457
3458 hc_timer_get (device_param->timer_speed, speed_ms);
3459
3460 hc_timer_set (&device_param->timer_speed);
3461
3462 // current speed
3463
3464 //hc_thread_mutex_lock (mux_display);
3465
3466 device_param->speed_cnt[speed_pos] = perf_sum_all;
3467
3468 device_param->speed_ms[speed_pos] = speed_ms;
3469
3470 //hc_thread_mutex_unlock (mux_display);
3471
3472 speed_pos++;
3473
3474 if (speed_pos == SPEED_CACHE)
3475 {
3476 speed_pos = 0;
3477 }
3478
3479 /**
3480 * benchmark
3481 */
3482
3483 if (data.benchmark == 1) break;
3484 }
3485 }
3486
3487 device_param->speed_pos = speed_pos;
3488
3489 myfree (line_buf);
3490 }
3491
3492 static void load_segment (wl_data_t *wl_data, FILE *fd)
3493 {
3494 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3495
3496 wl_data->pos = 0;
3497
3498 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3499
3500 wl_data->buf[wl_data->cnt] = 0;
3501
3502 if (wl_data->cnt == 0) return;
3503
3504 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3505
3506 while (!feof (fd))
3507 {
3508 if (wl_data->cnt == wl_data->avail)
3509 {
3510 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3511
3512 wl_data->avail += wl_data->incr;
3513 }
3514
3515 const int c = fgetc (fd);
3516
3517 if (c == EOF) break;
3518
3519 wl_data->buf[wl_data->cnt] = (char) c;
3520
3521 wl_data->cnt++;
3522
3523 if (c == '\n') break;
3524 }
3525
3526 // ensure stream ends with a newline
3527
3528 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3529 {
3530 wl_data->cnt++;
3531
3532 wl_data->buf[wl_data->cnt - 1] = '\n';
3533 }
3534
3535 return;
3536 }
3537
3538 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3539 {
3540 char *ptr = buf;
3541
3542 for (u32 i = 0; i < sz; i++, ptr++)
3543 {
3544 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3545
3546 if (i == 7)
3547 {
3548 *off = i;
3549 *len = i;
3550
3551 return;
3552 }
3553
3554 if (*ptr != '\n') continue;
3555
3556 *off = i + 1;
3557
3558 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3559
3560 *len = i;
3561
3562 return;
3563 }
3564
3565 *off = sz;
3566 *len = sz;
3567 }
3568
3569 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3570 {
3571 char *ptr = buf;
3572
3573 for (u32 i = 0; i < sz; i++, ptr++)
3574 {
3575 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3576
3577 if (*ptr != '\n') continue;
3578
3579 *off = i + 1;
3580
3581 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3582
3583 *len = i;
3584
3585 return;
3586 }
3587
3588 *off = sz;
3589 *len = sz;
3590 }
3591
3592 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3593 {
3594 char *ptr = buf;
3595
3596 for (u32 i = 0; i < sz; i++, ptr++)
3597 {
3598 if (*ptr != '\n') continue;
3599
3600 *off = i + 1;
3601
3602 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3603
3604 *len = i;
3605
3606 return;
3607 }
3608
3609 *off = sz;
3610 *len = sz;
3611 }
3612
3613 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3614 {
3615 while (wl_data->pos < wl_data->cnt)
3616 {
3617 uint off;
3618 uint len;
3619
3620 char *ptr = wl_data->buf + wl_data->pos;
3621
3622 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3623
3624 wl_data->pos += off;
3625
3626 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3627 {
3628 char rule_buf_out[BLOCK_SIZE] = { 0 };
3629
3630 int rule_len_out = -1;
3631
3632 if (len < BLOCK_SIZE)
3633 {
3634 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3635 }
3636
3637 if (rule_len_out < 0)
3638 {
3639 continue;
3640 }
3641
3642 if (rule_len_out > PW_MAX)
3643 {
3644 continue;
3645 }
3646 }
3647 else
3648 {
3649 if (len > PW_MAX)
3650 {
3651 continue;
3652 }
3653 }
3654
3655 *out_buf = ptr;
3656 *out_len = len;
3657
3658 return;
3659 }
3660
3661 if (feof (fd))
3662 {
3663 fprintf (stderr, "BUG feof()!!\n");
3664
3665 return;
3666 }
3667
3668 load_segment (wl_data, fd);
3669
3670 get_next_word (wl_data, fd, out_buf, out_len);
3671 }
3672
3673 #ifdef _POSIX
3674 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3675 #endif
3676
3677 #ifdef _WIN
3678 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3679 #endif
3680 {
3681 hc_signal (NULL);
3682
3683 dictstat_t d;
3684
3685 d.cnt = 0;
3686
3687 #ifdef _POSIX
3688 fstat (fileno (fd), &d.stat);
3689 #endif
3690
3691 #ifdef _WIN
3692 _fstat64 (fileno (fd), &d.stat);
3693 #endif
3694
3695 d.stat.st_mode = 0;
3696 d.stat.st_nlink = 0;
3697 d.stat.st_uid = 0;
3698 d.stat.st_gid = 0;
3699 d.stat.st_rdev = 0;
3700 d.stat.st_atime = 0;
3701
3702 #ifdef _POSIX
3703 d.stat.st_blksize = 0;
3704 d.stat.st_blocks = 0;
3705 #endif
3706
3707 if (d.stat.st_size == 0) return 0;
3708
3709 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3710
3711 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3712 {
3713 if (d_cache)
3714 {
3715 u64 cnt = d_cache->cnt;
3716
3717 u64 keyspace = cnt;
3718
3719 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3720 {
3721 keyspace *= data.kernel_rules_cnt;
3722 }
3723 else if (data.attack_kern == ATTACK_KERN_COMBI)
3724 {
3725 keyspace *= data.combs_cnt;
3726 }
3727
3728 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);
3729 if (data.quiet == 0) log_info ("");
3730
3731 hc_signal (sigHandler_default);
3732
3733 return (keyspace);
3734 }
3735 }
3736
3737 time_t now = 0;
3738 time_t prev = 0;
3739
3740 u64 comp = 0;
3741 u64 cnt = 0;
3742 u64 cnt2 = 0;
3743
3744 while (!feof (fd))
3745 {
3746 load_segment (wl_data, fd);
3747
3748 comp += wl_data->cnt;
3749
3750 u32 i = 0;
3751
3752 while (i < wl_data->cnt)
3753 {
3754 u32 len;
3755 u32 off;
3756
3757 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3758
3759 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3760 {
3761 char rule_buf_out[BLOCK_SIZE] = { 0 };
3762
3763 int rule_len_out = -1;
3764
3765 if (len < BLOCK_SIZE)
3766 {
3767 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3768 }
3769
3770 if (rule_len_out < 0)
3771 {
3772 len = PW_MAX1;
3773 }
3774 else
3775 {
3776 len = rule_len_out;
3777 }
3778 }
3779
3780 if (len < PW_MAX1)
3781 {
3782 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3783 {
3784 cnt += data.kernel_rules_cnt;
3785 }
3786 else if (data.attack_kern == ATTACK_KERN_COMBI)
3787 {
3788 cnt += data.combs_cnt;
3789 }
3790
3791 d.cnt++;
3792 }
3793
3794 i += off;
3795
3796 cnt2++;
3797 }
3798
3799 time (&now);
3800
3801 if ((now - prev) == 0) continue;
3802
3803 float percent = (float) comp / (float) d.stat.st_size;
3804
3805 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);
3806
3807 time (&prev);
3808 }
3809
3810 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);
3811 if (data.quiet == 0) log_info ("");
3812
3813 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3814
3815 hc_signal (sigHandler_default);
3816
3817 return (cnt);
3818 }
3819
3820 static void *thread_monitor (void *p)
3821 {
3822 uint runtime_check = 0;
3823 uint remove_check = 0;
3824 uint status_check = 0;
3825 uint restore_check = 0;
3826
3827 uint restore_left = data.restore_timer;
3828 uint remove_left = data.remove_timer;
3829 uint status_left = data.status_timer;
3830
3831 #ifdef HAVE_HWMON
3832 uint hwmon_check = 0;
3833
3834 int slowdown_warnings = 0;
3835
3836 // these variables are mainly used for fan control
3837
3838 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3839
3840 // temperature controller "loopback" values
3841
3842 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3843 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3844
3845 int temp_threshold = 1; // degrees celcius
3846
3847 int fan_speed_min = 15; // in percentage
3848 int fan_speed_max = 100;
3849
3850 time_t last_temp_check_time;
3851 #endif // HAVE_HWMON
3852
3853 uint sleep_time = 1;
3854
3855 if (data.runtime)
3856 {
3857 runtime_check = 1;
3858 }
3859
3860 if (data.restore_timer)
3861 {
3862 restore_check = 1;
3863 }
3864
3865 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3866 {
3867 remove_check = 1;
3868 }
3869
3870 if (data.status == 1)
3871 {
3872 status_check = 1;
3873 }
3874
3875 #ifdef HAVE_HWMON
3876 if (data.gpu_temp_disable == 0)
3877 {
3878 time (&last_temp_check_time);
3879
3880 hwmon_check = 1;
3881 }
3882 #endif
3883
3884 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3885 {
3886 #ifdef HAVE_HWMON
3887 if (hwmon_check == 0)
3888 #endif
3889 return (p);
3890 }
3891
3892 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3893 {
3894 hc_sleep (sleep_time);
3895
3896 if (data.devices_status != STATUS_RUNNING) continue;
3897
3898 #ifdef HAVE_HWMON
3899
3900 if (hwmon_check == 1)
3901 {
3902 hc_thread_mutex_lock (mux_adl);
3903
3904 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3905 {
3906 hc_device_param_t *device_param = &data.devices_param[device_id];
3907
3908 if (device_param->skipped) continue;
3909
3910 if (device_param->device_vendor_id == VENDOR_ID_NV)
3911 {
3912 if (data.hm_nvapi)
3913 {
3914 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
3915 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
3916
3917 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
3918 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
3919
3920 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
3921
3922 perfPolicies_status.info_value = perfPolicies_info.info_value;
3923
3924 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
3925
3926 if (perfPolicies_status.throttle & 2)
3927 {
3928 if (slowdown_warnings < 3)
3929 {
3930 if (data.quiet == 0) clear_prompt ();
3931
3932 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
3933
3934 if (slowdown_warnings == 2)
3935 {
3936 log_info ("");
3937 }
3938
3939 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3940 if (data.quiet == 0) fflush (stdout);
3941
3942 slowdown_warnings++;
3943 }
3944 }
3945 else
3946 {
3947 slowdown_warnings = 0;
3948 }
3949 }
3950 }
3951 }
3952
3953 hc_thread_mutex_unlock (mux_adl);
3954 }
3955
3956 if (hwmon_check == 1)
3957 {
3958 hc_thread_mutex_lock (mux_adl);
3959
3960 time_t temp_check_time;
3961
3962 time (&temp_check_time);
3963
3964 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3965
3966 if (Ta == 0) Ta = 1;
3967
3968 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3969 {
3970 hc_device_param_t *device_param = &data.devices_param[device_id];
3971
3972 if (device_param->skipped) continue;
3973
3974 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3975
3976 const int temperature = hm_get_temperature_with_device_id (device_id);
3977
3978 if (temperature > (int) data.gpu_temp_abort)
3979 {
3980 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3981
3982 if (data.devices_status != STATUS_QUIT) myabort ();
3983
3984 break;
3985 }
3986
3987 const int gpu_temp_retain = data.gpu_temp_retain;
3988
3989 if (gpu_temp_retain)
3990 {
3991 if (data.hm_device[device_id].fan_set_supported == 1)
3992 {
3993 int temp_cur = temperature;
3994
3995 int temp_diff_new = gpu_temp_retain - temp_cur;
3996
3997 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3998
3999 // calculate Ta value (time difference in seconds between the last check and this check)
4000
4001 last_temp_check_time = temp_check_time;
4002
4003 float Kp = 1.8;
4004 float Ki = 0.005;
4005 float Kd = 6;
4006
4007 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4008
4009 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);
4010
4011 if (abs (fan_diff_required) >= temp_threshold)
4012 {
4013 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4014
4015 int fan_speed_level = fan_speed_cur;
4016
4017 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4018
4019 int fan_speed_new = fan_speed_level - fan_diff_required;
4020
4021 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4022 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4023
4024 if (fan_speed_new != fan_speed_cur)
4025 {
4026 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4027 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4028
4029 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4030 {
4031 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4032 {
4033 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4034 }
4035 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4036 {
4037
4038 }
4039
4040 fan_speed_chgd[device_id] = 1;
4041 }
4042
4043 temp_diff_old[device_id] = temp_diff_new;
4044 }
4045 }
4046 }
4047 }
4048 }
4049
4050 hc_thread_mutex_unlock (mux_adl);
4051 }
4052 #endif // HAVE_HWMON
4053
4054 if (restore_check == 1)
4055 {
4056 restore_left--;
4057
4058 if (restore_left == 0)
4059 {
4060 if (data.restore_disable == 0) cycle_restore ();
4061
4062 restore_left = data.restore_timer;
4063 }
4064 }
4065
4066 if ((runtime_check == 1) && (data.runtime_start > 0))
4067 {
4068 time_t runtime_cur;
4069
4070 time (&runtime_cur);
4071
4072 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4073
4074 if (runtime_left <= 0)
4075 {
4076 if (data.benchmark == 0)
4077 {
4078 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4079 }
4080
4081 if (data.devices_status != STATUS_QUIT) myabort ();
4082 }
4083 }
4084
4085 if (remove_check == 1)
4086 {
4087 remove_left--;
4088
4089 if (remove_left == 0)
4090 {
4091 if (data.digests_saved != data.digests_done)
4092 {
4093 data.digests_saved = data.digests_done;
4094
4095 save_hash ();
4096 }
4097
4098 remove_left = data.remove_timer;
4099 }
4100 }
4101
4102 if (status_check == 1)
4103 {
4104 status_left--;
4105
4106 if (status_left == 0)
4107 {
4108 //hc_thread_mutex_lock (mux_display);
4109
4110 if (data.quiet == 0) clear_prompt ();
4111
4112 if (data.quiet == 0) log_info ("");
4113
4114 status_display ();
4115
4116 if (data.quiet == 0) log_info ("");
4117
4118 //hc_thread_mutex_unlock (mux_display);
4119
4120 status_left = data.status_timer;
4121 }
4122 }
4123 }
4124
4125 #ifdef HAVE_HWMON
4126 myfree (fan_speed_chgd);
4127
4128 myfree (temp_diff_old);
4129 myfree (temp_diff_sum);
4130 #endif
4131
4132 p = NULL;
4133
4134 return (p);
4135 }
4136
4137 static void *thread_outfile_remove (void *p)
4138 {
4139 // some hash-dependent constants
4140 char *outfile_dir = data.outfile_check_directory;
4141 uint dgst_size = data.dgst_size;
4142 uint isSalted = data.isSalted;
4143 uint esalt_size = data.esalt_size;
4144 uint hash_mode = data.hash_mode;
4145
4146 uint outfile_check_timer = data.outfile_check_timer;
4147
4148 char separator = data.separator;
4149
4150 // some hash-dependent functions
4151 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4152 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4153
4154 // buffers
4155 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4156
4157 hash_buf.digest = mymalloc (dgst_size);
4158
4159 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4160
4161 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4162
4163 uint digest_buf[64] = { 0 };
4164
4165 outfile_data_t *out_info = NULL;
4166
4167 char **out_files = NULL;
4168
4169 time_t folder_mtime = 0;
4170
4171 int out_cnt = 0;
4172
4173 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4174
4175 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4176 {
4177 hc_sleep (1);
4178
4179 if (data.devices_status != STATUS_RUNNING) continue;
4180
4181 check_left--;
4182
4183 if (check_left == 0)
4184 {
4185 struct stat outfile_check_stat;
4186
4187 if (stat (outfile_dir, &outfile_check_stat) == 0)
4188 {
4189 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4190
4191 if (is_dir == 1)
4192 {
4193 if (outfile_check_stat.st_mtime > folder_mtime)
4194 {
4195 char **out_files_new = scan_directory (outfile_dir);
4196
4197 int out_cnt_new = count_dictionaries (out_files_new);
4198
4199 outfile_data_t *out_info_new = NULL;
4200
4201 if (out_cnt_new > 0)
4202 {
4203 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4204
4205 for (int i = 0; i < out_cnt_new; i++)
4206 {
4207 out_info_new[i].file_name = out_files_new[i];
4208
4209 // check if there are files that we have seen/checked before (and not changed)
4210
4211 for (int j = 0; j < out_cnt; j++)
4212 {
4213 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4214 {
4215 struct stat outfile_stat;
4216
4217 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4218 {
4219 if (outfile_stat.st_ctime == out_info[j].ctime)
4220 {
4221 out_info_new[i].ctime = out_info[j].ctime;
4222 out_info_new[i].seek = out_info[j].seek;
4223 }
4224 }
4225 }
4226 }
4227 }
4228 }
4229
4230 local_free (out_info);
4231 local_free (out_files);
4232
4233 out_files = out_files_new;
4234 out_cnt = out_cnt_new;
4235 out_info = out_info_new;
4236
4237 folder_mtime = outfile_check_stat.st_mtime;
4238 }
4239
4240 for (int j = 0; j < out_cnt; j++)
4241 {
4242 FILE *fp = fopen (out_info[j].file_name, "rb");
4243
4244 if (fp != NULL)
4245 {
4246 //hc_thread_mutex_lock (mux_display);
4247
4248 #ifdef _POSIX
4249 struct stat outfile_stat;
4250
4251 fstat (fileno (fp), &outfile_stat);
4252 #endif
4253
4254 #ifdef _WIN
4255 struct stat64 outfile_stat;
4256
4257 _fstat64 (fileno (fp), &outfile_stat);
4258 #endif
4259
4260 if (outfile_stat.st_ctime > out_info[j].ctime)
4261 {
4262 out_info[j].ctime = outfile_stat.st_ctime;
4263 out_info[j].seek = 0;
4264 }
4265
4266 fseek (fp, out_info[j].seek, SEEK_SET);
4267
4268 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4269
4270 while (!feof (fp))
4271 {
4272 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4273
4274 if (ptr == NULL) break;
4275
4276 int line_len = strlen (line_buf);
4277
4278 if (line_len <= 0) continue;
4279
4280 int iter = MAX_CUT_TRIES;
4281
4282 for (uint i = line_len - 1; i && iter; i--, line_len--)
4283 {
4284 if (line_buf[i] != separator) continue;
4285
4286 int parser_status = PARSER_OK;
4287
4288 if ((hash_mode != 2500) && (hash_mode != 6800))
4289 {
4290 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4291 }
4292
4293 uint found = 0;
4294
4295 if (parser_status == PARSER_OK)
4296 {
4297 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4298 {
4299 if (data.salts_shown[salt_pos] == 1) continue;
4300
4301 salt_t *salt_buf = &data.salts_buf[salt_pos];
4302
4303 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4304 {
4305 uint idx = salt_buf->digests_offset + digest_pos;
4306
4307 if (data.digests_shown[idx] == 1) continue;
4308
4309 uint cracked = 0;
4310
4311 if (hash_mode == 6800)
4312 {
4313 if (i == salt_buf->salt_len)
4314 {
4315 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4316 }
4317 }
4318 else if (hash_mode == 2500)
4319 {
4320 // BSSID : MAC1 : MAC2 (:plain)
4321 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4322 {
4323 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4324
4325 if (!cracked) continue;
4326
4327 // now compare MAC1 and MAC2 too, since we have this additional info
4328 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4329 char *mac2_pos = mac1_pos + 12 + 1;
4330
4331 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4332 wpa_t *wpa = &wpas[salt_pos];
4333
4334 // compare hex string(s) vs binary MAC address(es)
4335
4336 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4337 {
4338 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4339 {
4340 cracked = 0;
4341
4342 break;
4343 }
4344 }
4345
4346 // early skip ;)
4347 if (!cracked) continue;
4348
4349 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4350 {
4351 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4352 {
4353 cracked = 0;
4354
4355 break;
4356 }
4357 }
4358 }
4359 }
4360 else
4361 {
4362 char *digests_buf_ptr = (char *) data.digests_buf;
4363
4364 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4365
4366 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4367 }
4368
4369 if (cracked == 1)
4370 {
4371 found = 1;
4372
4373 data.digests_shown[idx] = 1;
4374
4375 data.digests_done++;
4376
4377 salt_buf->digests_done++;
4378
4379 if (salt_buf->digests_done == salt_buf->digests_cnt)
4380 {
4381 data.salts_shown[salt_pos] = 1;
4382
4383 data.salts_done++;
4384
4385 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4386 }
4387 }
4388 }
4389
4390 if (data.devices_status == STATUS_CRACKED) break;
4391 }
4392 }
4393
4394 if (found) break;
4395
4396 if (data.devices_status == STATUS_CRACKED) break;
4397
4398 iter--;
4399 }
4400
4401 if (data.devices_status == STATUS_CRACKED) break;
4402 }
4403
4404 myfree (line_buf);
4405
4406 out_info[j].seek = ftell (fp);
4407
4408 //hc_thread_mutex_unlock (mux_display);
4409
4410 fclose (fp);
4411 }
4412 }
4413 }
4414 }
4415
4416 check_left = outfile_check_timer;
4417 }
4418 }
4419
4420 if (esalt_size) local_free (hash_buf.esalt);
4421
4422 if (isSalted) local_free (hash_buf.salt);
4423
4424 local_free (hash_buf.digest);
4425
4426 local_free (out_info);
4427
4428 local_free (out_files);
4429
4430 p = NULL;
4431
4432 return (p);
4433 }
4434
4435 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4436 {
4437 //if (device_param->pws_cnt < device_param->kernel_power)
4438 //{
4439 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4440
4441 u8 *ptr = (u8 *) pw->i;
4442
4443 memcpy (ptr, pw_buf, pw_len);
4444
4445 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4446
4447 pw->pw_len = pw_len;
4448
4449 device_param->pws_cnt++;
4450 //}
4451 //else
4452 //{
4453 // fprintf (stderr, "BUG pw_add()!!\n");
4454 //
4455 // return;
4456 //}
4457 }
4458
4459 static u32 get_power (const u32 kernel_power)
4460 {
4461 if (data.kernel_power_div)
4462 {
4463 return (float) kernel_power * data.kernel_power_div;
4464 }
4465
4466 return kernel_power;
4467 }
4468
4469 static uint get_work (hc_device_param_t *device_param, const u64 max)
4470 {
4471 hc_thread_mutex_lock (mux_dispatcher);
4472
4473 const u64 words_cur = data.words_cur;
4474 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4475
4476 device_param->words_off = words_cur;
4477
4478 const u64 words_left = words_base - words_cur;
4479
4480 if (data.kernel_power_all > words_left)
4481 {
4482 if (data.kernel_power_div == 0)
4483 {
4484 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4485 }
4486 }
4487
4488 const u32 kernel_power = get_power (device_param->kernel_power);
4489
4490 uint work = MIN (words_left, kernel_power);
4491
4492 work = MIN (work, max);
4493
4494 data.words_cur += work;
4495
4496 hc_thread_mutex_unlock (mux_dispatcher);
4497
4498 return work;
4499 }
4500
4501 static void *thread_autotune (void *p)
4502 {
4503 hc_device_param_t *device_param = (hc_device_param_t *) p;
4504
4505 if (device_param->skipped) return NULL;
4506
4507 autotune (device_param);
4508
4509 return NULL;
4510 }
4511
4512 static void *thread_calc_stdin (void *p)
4513 {
4514 hc_device_param_t *device_param = (hc_device_param_t *) p;
4515
4516 if (device_param->skipped) return NULL;
4517
4518 char *buf = (char *) mymalloc (HCBUFSIZ);
4519
4520 const uint attack_kern = data.attack_kern;
4521
4522 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4523 {
4524 hc_thread_mutex_lock (mux_dispatcher);
4525
4526 if (feof (stdin) != 0)
4527 {
4528 hc_thread_mutex_unlock (mux_dispatcher);
4529
4530 break;
4531 }
4532
4533 uint words_cur = 0;
4534
4535 while (words_cur < get_power (device_param->kernel_power))
4536 {
4537 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4538
4539 if (line_buf == NULL) break;
4540
4541 uint line_len = in_superchop (line_buf);
4542
4543 line_len = convert_from_hex (line_buf, line_len);
4544
4545 // post-process rule engine
4546
4547 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4548 {
4549 char rule_buf_out[BLOCK_SIZE] = { 0 };
4550
4551 int rule_len_out = -1;
4552
4553 if (line_len < BLOCK_SIZE)
4554 {
4555 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4556 }
4557
4558 if (rule_len_out < 0) continue;
4559
4560 line_buf = rule_buf_out;
4561 line_len = rule_len_out;
4562 }
4563
4564 if (line_len > PW_MAX)
4565 {
4566 continue;
4567 }
4568
4569 if (attack_kern == ATTACK_KERN_STRAIGHT)
4570 {
4571 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4572 {
4573 hc_thread_mutex_lock (mux_counter);
4574
4575 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4576 {
4577 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4578 }
4579
4580 hc_thread_mutex_unlock (mux_counter);
4581
4582 continue;
4583 }
4584 }
4585 else if (attack_kern == ATTACK_KERN_COMBI)
4586 {
4587 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4588 // since we still need to combine the plains
4589
4590 if (line_len > data.pw_max)
4591 {
4592 hc_thread_mutex_lock (mux_counter);
4593
4594 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4595 {
4596 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4597 }
4598
4599 hc_thread_mutex_unlock (mux_counter);
4600
4601 continue;
4602 }
4603 }
4604
4605 pw_add (device_param, (u8 *) line_buf, line_len);
4606
4607 words_cur++;
4608
4609 if (data.devices_status == STATUS_CRACKED) break;
4610 if (data.devices_status == STATUS_ABORTED) break;
4611 if (data.devices_status == STATUS_QUIT) break;
4612 if (data.devices_status == STATUS_BYPASS) break;
4613 }
4614
4615 hc_thread_mutex_unlock (mux_dispatcher);
4616
4617 if (data.devices_status == STATUS_CRACKED) break;
4618 if (data.devices_status == STATUS_ABORTED) break;
4619 if (data.devices_status == STATUS_QUIT) break;
4620 if (data.devices_status == STATUS_BYPASS) break;
4621
4622 // flush
4623
4624 const uint pws_cnt = device_param->pws_cnt;
4625
4626 if (pws_cnt)
4627 {
4628 run_copy (device_param, pws_cnt);
4629
4630 run_cracker (device_param, pws_cnt);
4631
4632 device_param->pws_cnt = 0;
4633
4634 /*
4635 still required?
4636 if (attack_kern == ATTACK_KERN_STRAIGHT)
4637 {
4638 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4639 }
4640 else if (attack_kern == ATTACK_KERN_COMBI)
4641 {
4642 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4643 }
4644 */
4645 }
4646 }
4647
4648 device_param->kernel_accel = 0;
4649 device_param->kernel_loops = 0;
4650
4651 myfree (buf);
4652
4653 return NULL;
4654 }
4655
4656 static void *thread_calc (void *p)
4657 {
4658 hc_device_param_t *device_param = (hc_device_param_t *) p;
4659
4660 if (device_param->skipped) return NULL;
4661
4662 const uint attack_mode = data.attack_mode;
4663 const uint attack_kern = data.attack_kern;
4664
4665 if (attack_mode == ATTACK_MODE_BF)
4666 {
4667 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4668 {
4669 const uint work = get_work (device_param, -1);
4670
4671 if (work == 0) break;
4672
4673 const u64 words_off = device_param->words_off;
4674 const u64 words_fin = words_off + work;
4675
4676 const uint pws_cnt = work;
4677
4678 device_param->pws_cnt = pws_cnt;
4679
4680 if (pws_cnt)
4681 {
4682 run_copy (device_param, pws_cnt);
4683
4684 run_cracker (device_param, pws_cnt);
4685
4686 device_param->pws_cnt = 0;
4687
4688 /*
4689 still required?
4690 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4691 */
4692 }
4693
4694 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4695
4696 if (data.devices_status == STATUS_CRACKED) break;
4697 if (data.devices_status == STATUS_ABORTED) break;
4698 if (data.devices_status == STATUS_QUIT) break;
4699 if (data.devices_status == STATUS_BYPASS) break;
4700
4701 if (data.benchmark == 1) break;
4702
4703 device_param->words_done = words_fin;
4704 }
4705 }
4706 else
4707 {
4708 const uint segment_size = data.segment_size;
4709
4710 char *dictfile = data.dictfile;
4711
4712 if (attack_mode == ATTACK_MODE_COMBI)
4713 {
4714 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4715 {
4716 dictfile = data.dictfile2;
4717 }
4718 }
4719
4720 FILE *fd = fopen (dictfile, "rb");
4721
4722 if (fd == NULL)
4723 {
4724 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4725
4726 return NULL;
4727 }
4728
4729 if (attack_mode == ATTACK_MODE_COMBI)
4730 {
4731 const uint combs_mode = data.combs_mode;
4732
4733 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4734 {
4735 const char *dictfilec = data.dictfile2;
4736
4737 FILE *combs_fp = fopen (dictfilec, "rb");
4738
4739 if (combs_fp == NULL)
4740 {
4741 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4742
4743 fclose (fd);
4744
4745 return NULL;
4746 }
4747
4748 device_param->combs_fp = combs_fp;
4749 }
4750 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4751 {
4752 const char *dictfilec = data.dictfile;
4753
4754 FILE *combs_fp = fopen (dictfilec, "rb");
4755
4756 if (combs_fp == NULL)
4757 {
4758 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4759
4760 fclose (fd);
4761
4762 return NULL;
4763 }
4764
4765 device_param->combs_fp = combs_fp;
4766 }
4767 }
4768
4769 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4770
4771 wl_data->buf = (char *) mymalloc (segment_size);
4772 wl_data->avail = segment_size;
4773 wl_data->incr = segment_size;
4774 wl_data->cnt = 0;
4775 wl_data->pos = 0;
4776
4777 u64 words_cur = 0;
4778
4779 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4780 {
4781 u64 words_off = 0;
4782 u64 words_fin = 0;
4783
4784 u64 max = -1;
4785
4786 while (max)
4787 {
4788 const uint work = get_work (device_param, max);
4789
4790 if (work == 0) break;
4791
4792 max = 0;
4793
4794 words_off = device_param->words_off;
4795 words_fin = words_off + work;
4796
4797 char *line_buf;
4798 uint line_len;
4799
4800 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4801
4802 for ( ; words_cur < words_fin; words_cur++)
4803 {
4804 get_next_word (wl_data, fd, &line_buf, &line_len);
4805
4806 line_len = convert_from_hex (line_buf, line_len);
4807
4808 // post-process rule engine
4809
4810 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4811 {
4812 char rule_buf_out[BLOCK_SIZE] = { 0 };
4813
4814 int rule_len_out = -1;
4815
4816 if (line_len < BLOCK_SIZE)
4817 {
4818 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4819 }
4820
4821 if (rule_len_out < 0) continue;
4822
4823 line_buf = rule_buf_out;
4824 line_len = rule_len_out;
4825 }
4826
4827 if (attack_kern == ATTACK_KERN_STRAIGHT)
4828 {
4829 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4830 {
4831 max++;
4832
4833 hc_thread_mutex_lock (mux_counter);
4834
4835 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4836 {
4837 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4838 }
4839
4840 hc_thread_mutex_unlock (mux_counter);
4841
4842 continue;
4843 }
4844 }
4845 else if (attack_kern == ATTACK_KERN_COMBI)
4846 {
4847 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4848 // since we still need to combine the plains
4849
4850 if (line_len > data.pw_max)
4851 {
4852 max++;
4853
4854 hc_thread_mutex_lock (mux_counter);
4855
4856 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4857 {
4858 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4859 }
4860
4861 hc_thread_mutex_unlock (mux_counter);
4862
4863 continue;
4864 }
4865 }
4866
4867 pw_add (device_param, (u8 *) line_buf, line_len);
4868
4869 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4870
4871 if (data.devices_status == STATUS_CRACKED) break;
4872 if (data.devices_status == STATUS_ABORTED) break;
4873 if (data.devices_status == STATUS_QUIT) break;
4874 if (data.devices_status == STATUS_BYPASS) break;
4875 }
4876
4877 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4878
4879 if (data.devices_status == STATUS_CRACKED) break;
4880 if (data.devices_status == STATUS_ABORTED) break;
4881 if (data.devices_status == STATUS_QUIT) break;
4882 if (data.devices_status == STATUS_BYPASS) break;
4883 }
4884
4885 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4886
4887 if (data.devices_status == STATUS_CRACKED) break;
4888 if (data.devices_status == STATUS_ABORTED) break;
4889 if (data.devices_status == STATUS_QUIT) break;
4890 if (data.devices_status == STATUS_BYPASS) break;
4891
4892 //
4893 // flush
4894 //
4895
4896 const uint pws_cnt = device_param->pws_cnt;
4897
4898 if (pws_cnt)
4899 {
4900 run_copy (device_param, pws_cnt);
4901
4902 run_cracker (device_param, pws_cnt);
4903
4904 device_param->pws_cnt = 0;
4905
4906 /*
4907 still required?
4908 if (attack_kern == ATTACK_KERN_STRAIGHT)
4909 {
4910 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4911 }
4912 else if (attack_kern == ATTACK_KERN_COMBI)
4913 {
4914 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4915 }
4916 */
4917 }
4918
4919 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4920
4921 if (data.devices_status == STATUS_CRACKED) break;
4922 if (data.devices_status == STATUS_ABORTED) break;
4923 if (data.devices_status == STATUS_QUIT) break;
4924 if (data.devices_status == STATUS_BYPASS) break;
4925
4926 if (words_fin == 0) break;
4927
4928 device_param->words_done = words_fin;
4929 }
4930
4931 if (attack_mode == ATTACK_MODE_COMBI)
4932 {
4933 fclose (device_param->combs_fp);
4934 }
4935
4936 free (wl_data->buf);
4937 free (wl_data);
4938
4939 fclose (fd);
4940 }
4941
4942 device_param->kernel_accel = 0;
4943 device_param->kernel_loops = 0;
4944
4945 return NULL;
4946 }
4947
4948 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4949 {
4950 if (!device_param)
4951 {
4952 log_error ("ERROR: %s : Invalid argument", __func__);
4953
4954 exit (-1);
4955 }
4956
4957 salt_t *salt_buf = &data.salts_buf[salt_pos];
4958
4959 device_param->kernel_params_buf32[24] = salt_pos;
4960 device_param->kernel_params_buf32[27] = 1;
4961 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4962 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4963 device_param->kernel_params_buf32[30] = 0;
4964 device_param->kernel_params_buf32[31] = 1;
4965
4966 char *dictfile_old = data.dictfile;
4967
4968 const char *weak_hash_check = "weak-hash-check";
4969
4970 data.dictfile = (char *) weak_hash_check;
4971
4972 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4973
4974 data.kernel_rules_buf[0].cmds[0] = 0;
4975
4976 /**
4977 * run the kernel
4978 */
4979
4980 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4981 {
4982 run_kernel (KERN_RUN_1, device_param, 1, false);
4983 }
4984 else
4985 {
4986 run_kernel (KERN_RUN_1, device_param, 1, false);
4987
4988 uint loop_step = 16;
4989
4990 const uint iter = salt_buf->salt_iter;
4991
4992 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4993 {
4994 uint loop_left = iter - loop_pos;
4995
4996 loop_left = MIN (loop_left, loop_step);
4997
4998 device_param->kernel_params_buf32[25] = loop_pos;
4999 device_param->kernel_params_buf32[26] = loop_left;
5000
5001 run_kernel (KERN_RUN_2, device_param, 1, false);
5002 }
5003
5004 run_kernel (KERN_RUN_3, device_param, 1, false);
5005 }
5006
5007 /**
5008 * result
5009 */
5010
5011 check_cracked (device_param, salt_pos);
5012
5013 /**
5014 * cleanup
5015 */
5016
5017 device_param->kernel_params_buf32[24] = 0;
5018 device_param->kernel_params_buf32[25] = 0;
5019 device_param->kernel_params_buf32[26] = 0;
5020 device_param->kernel_params_buf32[27] = 0;
5021 device_param->kernel_params_buf32[28] = 0;
5022 device_param->kernel_params_buf32[29] = 0;
5023 device_param->kernel_params_buf32[30] = 0;
5024 device_param->kernel_params_buf32[31] = 0;
5025
5026 data.dictfile = dictfile_old;
5027
5028 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5029 }
5030
5031 // hlfmt hashcat
5032
5033 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5034 {
5035 if (data.username == 0)
5036 {
5037 *hashbuf_pos = line_buf;
5038 *hashbuf_len = line_len;
5039 }
5040 else
5041 {
5042 char *pos = line_buf;
5043 int len = line_len;
5044
5045 for (int i = 0; i < line_len; i++, pos++, len--)
5046 {
5047 if (line_buf[i] == data.separator)
5048 {
5049 pos++;
5050
5051 len--;
5052
5053 break;
5054 }
5055 }
5056
5057 *hashbuf_pos = pos;
5058 *hashbuf_len = len;
5059 }
5060 }
5061
5062 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5063 {
5064 char *pos = NULL;
5065 int len = 0;
5066
5067 int sep_cnt = 0;
5068
5069 for (int i = 0; i < line_len; i++)
5070 {
5071 if (line_buf[i] == data.separator)
5072 {
5073 sep_cnt++;
5074
5075 continue;
5076 }
5077
5078 if (sep_cnt == 0)
5079 {
5080 if (pos == NULL) pos = line_buf + i;
5081
5082 len++;
5083 }
5084 }
5085
5086 *userbuf_pos = pos;
5087 *userbuf_len = len;
5088 }
5089
5090 // hlfmt pwdump
5091
5092 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5093 {
5094 int sep_cnt = 0;
5095
5096 int sep2_len = 0;
5097 int sep3_len = 0;
5098
5099 for (int i = 0; i < line_len; i++)
5100 {
5101 if (line_buf[i] == ':')
5102 {
5103 sep_cnt++;
5104
5105 continue;
5106 }
5107
5108 if (sep_cnt == 2) sep2_len++;
5109 if (sep_cnt == 3) sep3_len++;
5110 }
5111
5112 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5113
5114 return 0;
5115 }
5116
5117 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5118 {
5119 char *pos = NULL;
5120 int len = 0;
5121
5122 int sep_cnt = 0;
5123
5124 for (int i = 0; i < line_len; i++)
5125 {
5126 if (line_buf[i] == ':')
5127 {
5128 sep_cnt++;
5129
5130 continue;
5131 }
5132
5133 if (data.hash_mode == 1000)
5134 {
5135 if (sep_cnt == 3)
5136 {
5137 if (pos == NULL) pos = line_buf + i;
5138
5139 len++;
5140 }
5141 }
5142 else if (data.hash_mode == 3000)
5143 {
5144 if (sep_cnt == 2)
5145 {
5146 if (pos == NULL) pos = line_buf + i;
5147
5148 len++;
5149 }
5150 }
5151 }
5152
5153 *hashbuf_pos = pos;
5154 *hashbuf_len = len;
5155 }
5156
5157 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5158 {
5159 char *pos = NULL;
5160 int len = 0;
5161
5162 int sep_cnt = 0;
5163
5164 for (int i = 0; i < line_len; i++)
5165 {
5166 if (line_buf[i] == ':')
5167 {
5168 sep_cnt++;
5169
5170 continue;
5171 }
5172
5173 if (sep_cnt == 0)
5174 {
5175 if (pos == NULL) pos = line_buf + i;
5176
5177 len++;
5178 }
5179 }
5180
5181 *userbuf_pos = pos;
5182 *userbuf_len = len;
5183 }
5184
5185 // hlfmt passwd
5186
5187 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5188 {
5189 int sep_cnt = 0;
5190
5191 char sep5_first = 0;
5192 char sep6_first = 0;
5193
5194 for (int i = 0; i < line_len; i++)
5195 {
5196 if (line_buf[i] == ':')
5197 {
5198 sep_cnt++;
5199
5200 continue;
5201 }
5202
5203 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5204 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5205 }
5206
5207 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5208
5209 return 0;
5210 }
5211
5212 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5213 {
5214 char *pos = NULL;
5215 int len = 0;
5216
5217 int sep_cnt = 0;
5218
5219 for (int i = 0; i < line_len; i++)
5220 {
5221 if (line_buf[i] == ':')
5222 {
5223 sep_cnt++;
5224
5225 continue;
5226 }
5227
5228 if (sep_cnt == 1)
5229 {
5230 if (pos == NULL) pos = line_buf + i;
5231
5232 len++;
5233 }
5234 }
5235
5236 *hashbuf_pos = pos;
5237 *hashbuf_len = len;
5238 }
5239
5240 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5241 {
5242 char *pos = NULL;
5243 int len = 0;
5244
5245 int sep_cnt = 0;
5246
5247 for (int i = 0; i < line_len; i++)
5248 {
5249 if (line_buf[i] == ':')
5250 {
5251 sep_cnt++;
5252
5253 continue;
5254 }
5255
5256 if (sep_cnt == 0)
5257 {
5258 if (pos == NULL) pos = line_buf + i;
5259
5260 len++;
5261 }
5262 }
5263
5264 *userbuf_pos = pos;
5265 *userbuf_len = len;
5266 }
5267
5268 // hlfmt shadow
5269
5270 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5271 {
5272 int sep_cnt = 0;
5273
5274 for (int i = 0; i < line_len; i++)
5275 {
5276 if (line_buf[i] == ':') sep_cnt++;
5277 }
5278
5279 if (sep_cnt == 8) return 1;
5280
5281 return 0;
5282 }
5283
5284 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5285 {
5286 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5287 }
5288
5289 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5290 {
5291 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5292 }
5293
5294 // hlfmt main
5295
5296 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5297 {
5298 switch (hashfile_format)
5299 {
5300 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5301 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5302 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5303 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5304 }
5305 }
5306
5307 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5308 {
5309 switch (hashfile_format)
5310 {
5311 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5312 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5313 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5314 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5315 }
5316 }
5317
5318 char *strhlfmt (const uint hashfile_format)
5319 {
5320 switch (hashfile_format)
5321 {
5322 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5323 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5324 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5325 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5326 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5327 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5328 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5329 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5330 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5331 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5332 }
5333
5334 return ((char *) "Unknown");
5335 }
5336
5337 static uint hlfmt_detect (FILE *fp, uint max_check)
5338 {
5339 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5340
5341 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5342 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5343
5344 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5345
5346 uint num_check = 0;
5347
5348 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5349
5350 while (!feof (fp))
5351 {
5352 int line_len = fgetl (fp, line_buf);
5353
5354 if (line_len == 0) continue;
5355
5356 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5357 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5358 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5359
5360 if (num_check == max_check) break;
5361
5362 num_check++;
5363 }
5364
5365 myfree (line_buf);
5366
5367 uint hashlist_format = HLFMT_HASHCAT;
5368
5369 for (int i = 1; i < HLFMTS_CNT; i++)
5370 {
5371 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5372
5373 hashlist_format = i;
5374 }
5375
5376 free (formats_cnt);
5377
5378 return hashlist_format;
5379 }
5380
5381 /**
5382 * some further helper function
5383 */
5384
5385 // wrapper around mymalloc for ADL
5386
5387 #if defined(HAVE_HWMON)
5388 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5389 {
5390 return mymalloc (iSize);
5391 }
5392 #endif
5393
5394 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)
5395 {
5396 u64 collisions = 0;
5397
5398 const uint dgst_pos0 = data.dgst_pos0;
5399 const uint dgst_pos1 = data.dgst_pos1;
5400 const uint dgst_pos2 = data.dgst_pos2;
5401 const uint dgst_pos3 = data.dgst_pos3;
5402
5403 memset (bitmap_a, 0, bitmap_size);
5404 memset (bitmap_b, 0, bitmap_size);
5405 memset (bitmap_c, 0, bitmap_size);
5406 memset (bitmap_d, 0, bitmap_size);
5407
5408 for (uint i = 0; i < digests_cnt; i++)
5409 {
5410 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5411
5412 uint *digest_ptr = (uint *) digests_buf_ptr;
5413
5414 digests_buf_ptr += dgst_size;
5415
5416 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5417 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5418 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5419 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5420
5421 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5422 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5423 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5424 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5425
5426 if (bitmap_a[idx0] & val0) collisions++;
5427 if (bitmap_b[idx1] & val1) collisions++;
5428 if (bitmap_c[idx2] & val2) collisions++;
5429 if (bitmap_d[idx3] & val3) collisions++;
5430
5431 bitmap_a[idx0] |= val0;
5432 bitmap_b[idx1] |= val1;
5433 bitmap_c[idx2] |= val2;
5434 bitmap_d[idx3] |= val3;
5435
5436 if (collisions >= collisions_max) return 0x7fffffff;
5437 }
5438
5439 return collisions;
5440 }
5441
5442 /**
5443 * main
5444 */
5445
5446 #ifdef _WIN
5447 void SetConsoleWindowSize (const int x)
5448 {
5449 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5450
5451 if (h == INVALID_HANDLE_VALUE) return;
5452
5453 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5454
5455 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5456
5457 SMALL_RECT *sr = &bufferInfo.srWindow;
5458
5459 sr->Right = MAX (sr->Right, x - 1);
5460
5461 COORD co;
5462
5463 co.X = sr->Right + 1;
5464 co.Y = 9999;
5465
5466 if (!SetConsoleScreenBufferSize (h, co)) return;
5467
5468 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5469 }
5470 #endif
5471
5472 int main (int argc, char **argv)
5473 {
5474 #ifdef _WIN
5475 SetConsoleWindowSize (132);
5476 #endif
5477
5478 /**
5479 * To help users a bit
5480 */
5481
5482 char *compute = getenv ("COMPUTE");
5483
5484 if (compute)
5485 {
5486 static char display[100];
5487
5488 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5489
5490 putenv (display);
5491 }
5492 else
5493 {
5494 if (getenv ("DISPLAY") == NULL)
5495 putenv ((char *) "DISPLAY=:0");
5496 }
5497
5498 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5499 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5500
5501 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5502 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5503
5504 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5505 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5506
5507 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5508 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5509
5510 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5511 putenv ((char *) "POCL_KERNEL_CACHE=0");
5512
5513 umask (077);
5514
5515 /**
5516 * Real init
5517 */
5518
5519 memset (&data, 0, sizeof (hc_global_data_t));
5520
5521 time_t proc_start;
5522
5523 time (&proc_start);
5524
5525 data.proc_start = proc_start;
5526
5527 int myargc = argc;
5528 char **myargv = argv;
5529
5530 hc_thread_mutex_init (mux_dispatcher);
5531 hc_thread_mutex_init (mux_counter);
5532 hc_thread_mutex_init (mux_display);
5533 hc_thread_mutex_init (mux_adl);
5534
5535 /**
5536 * commandline parameters
5537 */
5538
5539 uint usage = USAGE;
5540 uint version = VERSION;
5541 uint quiet = QUIET;
5542 uint benchmark = BENCHMARK;
5543 uint show = SHOW;
5544 uint left = LEFT;
5545 uint username = USERNAME;
5546 uint remove = REMOVE;
5547 uint remove_timer = REMOVE_TIMER;
5548 u64 skip = SKIP;
5549 u64 limit = LIMIT;
5550 uint keyspace = KEYSPACE;
5551 uint potfile_disable = POTFILE_DISABLE;
5552 char *potfile_path = NULL;
5553 uint debug_mode = DEBUG_MODE;
5554 char *debug_file = NULL;
5555 char *induction_dir = NULL;
5556 char *outfile_check_dir = NULL;
5557 uint force = FORCE;
5558 uint runtime = RUNTIME;
5559 uint hash_mode = HASH_MODE;
5560 uint attack_mode = ATTACK_MODE;
5561 uint markov_disable = MARKOV_DISABLE;
5562 uint markov_classic = MARKOV_CLASSIC;
5563 uint markov_threshold = MARKOV_THRESHOLD;
5564 char *markov_hcstat = NULL;
5565 char *outfile = NULL;
5566 uint outfile_format = OUTFILE_FORMAT;
5567 uint outfile_autohex = OUTFILE_AUTOHEX;
5568 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5569 uint restore = RESTORE;
5570 uint restore_timer = RESTORE_TIMER;
5571 uint restore_disable = RESTORE_DISABLE;
5572 uint status = STATUS;
5573 uint status_timer = STATUS_TIMER;
5574 uint machine_readable = MACHINE_READABLE;
5575 uint loopback = LOOPBACK;
5576 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5577 char *session = NULL;
5578 uint hex_charset = HEX_CHARSET;
5579 uint hex_salt = HEX_SALT;
5580 uint hex_wordlist = HEX_WORDLIST;
5581 uint rp_gen = RP_GEN;
5582 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5583 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5584 uint rp_gen_seed = RP_GEN_SEED;
5585 char *rule_buf_l = (char *) RULE_BUF_L;
5586 char *rule_buf_r = (char *) RULE_BUF_R;
5587 uint increment = INCREMENT;
5588 uint increment_min = INCREMENT_MIN;
5589 uint increment_max = INCREMENT_MAX;
5590 char *cpu_affinity = NULL;
5591 OCL_PTR *ocl = NULL;
5592 char *opencl_devices = NULL;
5593 char *opencl_platforms = NULL;
5594 char *opencl_device_types = NULL;
5595 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5596 char *truecrypt_keyfiles = NULL;
5597 char *veracrypt_keyfiles = NULL;
5598 uint veracrypt_pim = 0;
5599 uint workload_profile = WORKLOAD_PROFILE;
5600 uint kernel_accel = KERNEL_ACCEL;
5601 uint kernel_loops = KERNEL_LOOPS;
5602 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5603 #ifdef HAVE_HWMON
5604 uint gpu_temp_abort = GPU_TEMP_ABORT;
5605 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5606 uint powertune_enable = POWERTUNE_ENABLE;
5607 #endif
5608 uint logfile_disable = LOGFILE_DISABLE;
5609 uint segment_size = SEGMENT_SIZE;
5610 uint scrypt_tmto = SCRYPT_TMTO;
5611 char separator = SEPARATOR;
5612 uint bitmap_min = BITMAP_MIN;
5613 uint bitmap_max = BITMAP_MAX;
5614 char *custom_charset_1 = NULL;
5615 char *custom_charset_2 = NULL;
5616 char *custom_charset_3 = NULL;
5617 char *custom_charset_4 = NULL;
5618
5619 #define IDX_HELP 'h'
5620 #define IDX_VERSION 'V'
5621 #define IDX_VERSION_LOWER 'v'
5622 #define IDX_QUIET 0xff02
5623 #define IDX_SHOW 0xff03
5624 #define IDX_LEFT 0xff04
5625 #define IDX_REMOVE 0xff05
5626 #define IDX_REMOVE_TIMER 0xff37
5627 #define IDX_SKIP 's'
5628 #define IDX_LIMIT 'l'
5629 #define IDX_KEYSPACE 0xff35
5630 #define IDX_POTFILE_DISABLE 0xff06
5631 #define IDX_POTFILE_PATH 0xffe0
5632 #define IDX_DEBUG_MODE 0xff43
5633 #define IDX_DEBUG_FILE 0xff44
5634 #define IDX_INDUCTION_DIR 0xff46
5635 #define IDX_OUTFILE_CHECK_DIR 0xff47
5636 #define IDX_USERNAME 0xff07
5637 #define IDX_FORCE 0xff08
5638 #define IDX_RUNTIME 0xff09
5639 #define IDX_BENCHMARK 'b'
5640 #define IDX_HASH_MODE 'm'
5641 #define IDX_ATTACK_MODE 'a'
5642 #define IDX_RP_FILE 'r'
5643 #define IDX_RP_GEN 'g'
5644 #define IDX_RP_GEN_FUNC_MIN 0xff10
5645 #define IDX_RP_GEN_FUNC_MAX 0xff11
5646 #define IDX_RP_GEN_SEED 0xff34
5647 #define IDX_RULE_BUF_L 'j'
5648 #define IDX_RULE_BUF_R 'k'
5649 #define IDX_INCREMENT 'i'
5650 #define IDX_INCREMENT_MIN 0xff12
5651 #define IDX_INCREMENT_MAX 0xff13
5652 #define IDX_OUTFILE 'o'
5653 #define IDX_OUTFILE_FORMAT 0xff14
5654 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5655 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5656 #define IDX_RESTORE 0xff15
5657 #define IDX_RESTORE_DISABLE 0xff27
5658 #define IDX_STATUS 0xff17
5659 #define IDX_STATUS_TIMER 0xff18
5660 #define IDX_MACHINE_READABLE 0xff50
5661 #define IDX_LOOPBACK 0xff38
5662 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5663 #define IDX_SESSION 0xff19
5664 #define IDX_HEX_CHARSET 0xff20
5665 #define IDX_HEX_SALT 0xff21
5666 #define IDX_HEX_WORDLIST 0xff40
5667 #define IDX_MARKOV_DISABLE 0xff22
5668 #define IDX_MARKOV_CLASSIC 0xff23
5669 #define IDX_MARKOV_THRESHOLD 't'
5670 #define IDX_MARKOV_HCSTAT 0xff24
5671 #define IDX_CPU_AFFINITY 0xff25
5672 #define IDX_OPENCL_DEVICES 'd'
5673 #define IDX_OPENCL_PLATFORMS 0xff72
5674 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5675 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5676 #define IDX_WORKLOAD_PROFILE 'w'
5677 #define IDX_KERNEL_ACCEL 'n'
5678 #define IDX_KERNEL_LOOPS 'u'
5679 #define IDX_GPU_TEMP_DISABLE 0xff29
5680 #define IDX_GPU_TEMP_ABORT 0xff30
5681 #define IDX_GPU_TEMP_RETAIN 0xff31
5682 #define IDX_POWERTUNE_ENABLE 0xff41
5683 #define IDX_LOGFILE_DISABLE 0xff51
5684 #define IDX_TRUECRYPT_KEYFILES 0xff52
5685 #define IDX_VERACRYPT_KEYFILES 0xff53
5686 #define IDX_VERACRYPT_PIM 0xff54
5687 #define IDX_SCRYPT_TMTO 0xff61
5688 #define IDX_SEGMENT_SIZE 'c'
5689 #define IDX_SEPARATOR 'p'
5690 #define IDX_BITMAP_MIN 0xff70
5691 #define IDX_BITMAP_MAX 0xff71
5692 #define IDX_CUSTOM_CHARSET_1 '1'
5693 #define IDX_CUSTOM_CHARSET_2 '2'
5694 #define IDX_CUSTOM_CHARSET_3 '3'
5695 #define IDX_CUSTOM_CHARSET_4 '4'
5696
5697 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5698
5699 struct option long_options[] =
5700 {
5701 {"help", no_argument, 0, IDX_HELP},
5702 {"version", no_argument, 0, IDX_VERSION},
5703 {"quiet", no_argument, 0, IDX_QUIET},
5704 {"show", no_argument, 0, IDX_SHOW},
5705 {"left", no_argument, 0, IDX_LEFT},
5706 {"username", no_argument, 0, IDX_USERNAME},
5707 {"remove", no_argument, 0, IDX_REMOVE},
5708 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5709 {"skip", required_argument, 0, IDX_SKIP},
5710 {"limit", required_argument, 0, IDX_LIMIT},
5711 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5712 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5713 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5714 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5715 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5716 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5717 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5718 {"force", no_argument, 0, IDX_FORCE},
5719 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5720 {"restore", no_argument, 0, IDX_RESTORE},
5721 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5722 {"status", no_argument, 0, IDX_STATUS},
5723 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5724 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5725 {"loopback", no_argument, 0, IDX_LOOPBACK},
5726 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5727 {"session", required_argument, 0, IDX_SESSION},
5728 {"runtime", required_argument, 0, IDX_RUNTIME},
5729 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5730 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5731 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5732 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5733 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5734 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5735 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5736 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5737 {"rules-file", required_argument, 0, IDX_RP_FILE},
5738 {"outfile", required_argument, 0, IDX_OUTFILE},
5739 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5740 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5741 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5742 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5743 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5744 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5745 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5746 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5747 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5748 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5749 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5750 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5751 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5752 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5753 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5754 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5755 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5756 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5757 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5758 #ifdef HAVE_HWMON
5759 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5760 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5761 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5762 #endif // HAVE_HWMON
5763 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5764 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5765 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5766 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5767 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5768 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5769 {"seperator", required_argument, 0, IDX_SEPARATOR},
5770 {"separator", required_argument, 0, IDX_SEPARATOR},
5771 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5772 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5773 {"increment", no_argument, 0, IDX_INCREMENT},
5774 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5775 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5776 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5777 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5778 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5779 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5780 {0, 0, 0, 0}
5781 };
5782
5783 uint rp_files_cnt = 0;
5784
5785 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5786
5787 int option_index = 0;
5788 int c = -1;
5789
5790 optind = 1;
5791 optopt = 0;
5792
5793 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5794 {
5795 switch (c)
5796 {
5797 case IDX_HELP: usage = 1; break;
5798 case IDX_VERSION:
5799 case IDX_VERSION_LOWER: version = 1; break;
5800 case IDX_RESTORE: restore = 1; break;
5801 case IDX_SESSION: session = optarg; break;
5802 case IDX_SHOW: show = 1; break;
5803 case IDX_LEFT: left = 1; break;
5804 case '?': return (-1);
5805 }
5806 }
5807
5808 if (optopt != 0)
5809 {
5810 log_error ("ERROR: Invalid argument specified");
5811
5812 return (-1);
5813 }
5814
5815 /**
5816 * exit functions
5817 */
5818
5819 if (version)
5820 {
5821 log_info ("%s", VERSION_TAG);
5822
5823 return (0);
5824 }
5825
5826 if (usage)
5827 {
5828 usage_big_print (PROGNAME);
5829
5830 return (0);
5831 }
5832
5833 /**
5834 * session needs to be set, always!
5835 */
5836
5837 if (session == NULL) session = (char *) PROGNAME;
5838
5839 /**
5840 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5841 */
5842
5843 char *exec_path = get_exec_path ();
5844
5845 #ifdef LINUX
5846
5847 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5848 char *resolved_exec_path = realpath (exec_path, NULL);
5849
5850 char *install_dir = get_install_dir (resolved_exec_path);
5851 char *profile_dir = NULL;
5852 char *session_dir = NULL;
5853 char *shared_dir = NULL;
5854
5855 if (strcmp (install_dir, resolved_install_folder) == 0)
5856 {
5857 struct passwd *pw = getpwuid (getuid ());
5858
5859 const char *homedir = pw->pw_dir;
5860
5861 profile_dir = get_profile_dir (homedir);
5862 session_dir = get_session_dir (profile_dir);
5863 shared_dir = strdup (SHARED_FOLDER);
5864
5865 mkdir (profile_dir, 0700);
5866 mkdir (session_dir, 0700);
5867 }
5868 else
5869 {
5870 profile_dir = install_dir;
5871 session_dir = install_dir;
5872 shared_dir = install_dir;
5873 }
5874
5875 myfree (resolved_install_folder);
5876 myfree (resolved_exec_path);
5877
5878 #else
5879
5880 char *install_dir = get_install_dir (exec_path);
5881 char *profile_dir = install_dir;
5882 char *session_dir = install_dir;
5883 char *shared_dir = install_dir;
5884
5885 #endif
5886
5887 data.install_dir = install_dir;
5888 data.profile_dir = profile_dir;
5889 data.session_dir = session_dir;
5890 data.shared_dir = shared_dir;
5891
5892 myfree (exec_path);
5893
5894 /**
5895 * kernel cache, we need to make sure folder exist
5896 */
5897
5898 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5899
5900 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5901
5902 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5903
5904 mkdir (kernels_folder, 0700);
5905
5906 myfree (kernels_folder);
5907
5908 /**
5909 * session
5910 */
5911
5912 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5913
5914 data.session = session;
5915
5916 char *eff_restore_file = (char *) mymalloc (session_size);
5917 char *new_restore_file = (char *) mymalloc (session_size);
5918
5919 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5920 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5921
5922 data.eff_restore_file = eff_restore_file;
5923 data.new_restore_file = new_restore_file;
5924
5925 if (((show == 1) || (left == 1)) && (restore == 1))
5926 {
5927 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5928 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5929
5930 return (-1);
5931 }
5932
5933 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5934 if ((show == 1) || (left == 1))
5935 {
5936 restore_disable = 1;
5937
5938 restore = 0;
5939 }
5940
5941 data.restore_disable = restore_disable;
5942
5943 restore_data_t *rd = init_restore (argc, argv);
5944
5945 data.rd = rd;
5946
5947 /**
5948 * restore file
5949 */
5950
5951 if (restore == 1)
5952 {
5953 read_restore (eff_restore_file, rd);
5954
5955 if (rd->version_bin < RESTORE_MIN)
5956 {
5957 log_error ("ERROR: Incompatible restore-file version");
5958
5959 return (-1);
5960 }
5961
5962 myargc = rd->argc;
5963 myargv = rd->argv;
5964
5965 #ifdef _POSIX
5966 rd->pid = getpid ();
5967 #elif _WIN
5968 rd->pid = GetCurrentProcessId ();
5969 #endif
5970 }
5971
5972 uint hash_mode_chgd = 0;
5973 uint runtime_chgd = 0;
5974 uint kernel_loops_chgd = 0;
5975 uint kernel_accel_chgd = 0;
5976 uint attack_mode_chgd = 0;
5977 uint outfile_format_chgd = 0;
5978 uint rp_gen_seed_chgd = 0;
5979 uint remove_timer_chgd = 0;
5980 uint increment_min_chgd = 0;
5981 uint increment_max_chgd = 0;
5982 uint workload_profile_chgd = 0;
5983 uint opencl_vector_width_chgd = 0;
5984
5985 optind = 1;
5986 optopt = 0;
5987 option_index = 0;
5988
5989 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5990 {
5991 switch (c)
5992 {
5993 //case IDX_HELP: usage = 1; break;
5994 //case IDX_VERSION: version = 1; break;
5995 //case IDX_RESTORE: restore = 1; break;
5996 case IDX_QUIET: quiet = 1; break;
5997 //case IDX_SHOW: show = 1; break;
5998 case IDX_SHOW: break;
5999 //case IDX_LEFT: left = 1; break;
6000 case IDX_LEFT: break;
6001 case IDX_USERNAME: username = 1; break;
6002 case IDX_REMOVE: remove = 1; break;
6003 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6004 remove_timer_chgd = 1; break;
6005 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6006 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6007 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6008 case IDX_DEBUG_FILE: debug_file = optarg; break;
6009 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6010 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6011 case IDX_FORCE: force = 1; break;
6012 case IDX_SKIP: skip = atoll (optarg); break;
6013 case IDX_LIMIT: limit = atoll (optarg); break;
6014 case IDX_KEYSPACE: keyspace = 1; break;
6015 case IDX_BENCHMARK: benchmark = 1; break;
6016 case IDX_RESTORE: break;
6017 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6018 case IDX_STATUS: status = 1; break;
6019 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6020 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6021 case IDX_LOOPBACK: loopback = 1; break;
6022 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6023 //case IDX_SESSION: session = optarg; break;
6024 case IDX_SESSION: break;
6025 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6026 hash_mode_chgd = 1; break;
6027 case IDX_RUNTIME: runtime = atoi (optarg);
6028 runtime_chgd = 1; break;
6029 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6030 attack_mode_chgd = 1; break;
6031 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6032 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6033 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6034 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6035 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6036 rp_gen_seed_chgd = 1; break;
6037 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6038 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6039 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6040 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6041 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6042 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6043 case IDX_OUTFILE: outfile = optarg; break;
6044 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6045 outfile_format_chgd = 1; break;
6046 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6047 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6048 case IDX_HEX_CHARSET: hex_charset = 1; break;
6049 case IDX_HEX_SALT: hex_salt = 1; break;
6050 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6051 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6052 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6053 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6054 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6055 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6056 opencl_vector_width_chgd = 1; break;
6057 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6058 workload_profile_chgd = 1; break;
6059 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6060 kernel_accel_chgd = 1; break;
6061 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6062 kernel_loops_chgd = 1; break;
6063 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6064 #ifdef HAVE_HWMON
6065 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6066 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6067 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6068 #endif // HAVE_HWMON
6069 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6070 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6071 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6072 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6073 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6074 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6075 case IDX_SEPARATOR: separator = optarg[0]; break;
6076 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6077 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6078 case IDX_INCREMENT: increment = 1; break;
6079 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6080 increment_min_chgd = 1; break;
6081 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6082 increment_max_chgd = 1; break;
6083 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6084 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6085 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6086 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6087
6088 default:
6089 log_error ("ERROR: Invalid argument specified");
6090 return (-1);
6091 }
6092 }
6093
6094 if (optopt != 0)
6095 {
6096 log_error ("ERROR: Invalid argument specified");
6097
6098 return (-1);
6099 }
6100
6101 /**
6102 * Inform user things getting started,
6103 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6104 * - we do not need to check algorithm_pos
6105 */
6106
6107 if (quiet == 0)
6108 {
6109 if (benchmark == 1)
6110 {
6111 if (machine_readable == 0)
6112 {
6113 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6114 log_info ("");
6115 }
6116 else
6117 {
6118 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6119 }
6120 }
6121 else if (restore == 1)
6122 {
6123 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6124 log_info ("");
6125 }
6126 else
6127 {
6128 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6129 log_info ("");
6130 }
6131 }
6132
6133 /**
6134 * sanity check
6135 */
6136
6137 if (attack_mode > 7)
6138 {
6139 log_error ("ERROR: Invalid attack-mode specified");
6140
6141 return (-1);
6142 }
6143
6144 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6145 {
6146 log_error ("ERROR: Invalid runtime specified");
6147
6148 return (-1);
6149 }
6150
6151 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6152 {
6153 log_error ("ERROR: Invalid hash-type specified");
6154
6155 return (-1);
6156 }
6157
6158 // renamed hash modes
6159
6160 if (hash_mode_chgd)
6161 {
6162 int n = -1;
6163
6164 switch (hash_mode)
6165 {
6166 case 123: n = 124;
6167 break;
6168 }
6169
6170 if (n >= 0)
6171 {
6172 log_error ("Old -m specified, use -m %d instead", n);
6173
6174 return (-1);
6175 }
6176 }
6177
6178 if (username == 1)
6179 {
6180 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6181 {
6182 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6183
6184 return (-1);
6185 }
6186 }
6187
6188 if (outfile_format > 16)
6189 {
6190 log_error ("ERROR: Invalid outfile-format specified");
6191
6192 return (-1);
6193 }
6194
6195 if (left == 1)
6196 {
6197 if (outfile_format_chgd == 1)
6198 {
6199 if (outfile_format > 1)
6200 {
6201 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6202
6203 return (-1);
6204 }
6205 }
6206 else
6207 {
6208 outfile_format = OUTFILE_FMT_HASH;
6209 }
6210 }
6211
6212 if (show == 1)
6213 {
6214 if (outfile_format_chgd == 1)
6215 {
6216 if ((outfile_format > 7) && (outfile_format < 16))
6217 {
6218 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6219
6220 return (-1);
6221 }
6222 }
6223 }
6224
6225 if (increment_min < INCREMENT_MIN)
6226 {
6227 log_error ("ERROR: Invalid increment-min specified");
6228
6229 return (-1);
6230 }
6231
6232 if (increment_max > INCREMENT_MAX)
6233 {
6234 log_error ("ERROR: Invalid increment-max specified");
6235
6236 return (-1);
6237 }
6238
6239 if (increment_min > increment_max)
6240 {
6241 log_error ("ERROR: Invalid increment-min specified");
6242
6243 return (-1);
6244 }
6245
6246 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6247 {
6248 log_error ("ERROR: increment is not allowed in attack-mode 0");
6249
6250 return (-1);
6251 }
6252
6253 if ((increment == 0) && (increment_min_chgd == 1))
6254 {
6255 log_error ("ERROR: increment-min is only supported together with increment switch");
6256
6257 return (-1);
6258 }
6259
6260 if ((increment == 0) && (increment_max_chgd == 1))
6261 {
6262 log_error ("ERROR: increment-max is only supported together with increment switch");
6263
6264 return (-1);
6265 }
6266
6267 if (rp_files_cnt && rp_gen)
6268 {
6269 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6270
6271 return (-1);
6272 }
6273
6274 if (rp_files_cnt || rp_gen)
6275 {
6276 if (attack_mode != ATTACK_MODE_STRAIGHT)
6277 {
6278 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6279
6280 return (-1);
6281 }
6282 }
6283
6284 if (rp_gen_func_min > rp_gen_func_max)
6285 {
6286 log_error ("ERROR: Invalid rp-gen-func-min specified");
6287
6288 return (-1);
6289 }
6290
6291 if (kernel_accel_chgd == 1)
6292 {
6293 if (force == 0)
6294 {
6295 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6296 log_info ("Please consider using the option -w instead");
6297 log_info ("You can use --force to override this but do not post error reports if you do so");
6298 log_info ("");
6299
6300 return (-1);
6301 }
6302
6303 if (kernel_accel < 1)
6304 {
6305 log_error ("ERROR: Invalid kernel-accel specified");
6306
6307 return (-1);
6308 }
6309
6310 if (kernel_accel > 1024)
6311 {
6312 log_error ("ERROR: Invalid kernel-accel specified");
6313
6314 return (-1);
6315 }
6316 }
6317
6318 if (kernel_loops_chgd == 1)
6319 {
6320 if (force == 0)
6321 {
6322 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6323 log_info ("Please consider using the option -w instead");
6324 log_info ("You can use --force to override this but do not post error reports if you do so");
6325 log_info ("");
6326
6327 return (-1);
6328 }
6329
6330 if (kernel_loops < 1)
6331 {
6332 log_error ("ERROR: Invalid kernel-loops specified");
6333
6334 return (-1);
6335 }
6336
6337 if (kernel_loops > 1024)
6338 {
6339 log_error ("ERROR: Invalid kernel-loops specified");
6340
6341 return (-1);
6342 }
6343 }
6344
6345 if ((workload_profile < 1) || (workload_profile > 4))
6346 {
6347 log_error ("ERROR: workload-profile %i not available", workload_profile);
6348
6349 return (-1);
6350 }
6351
6352 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6353 {
6354 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6355
6356 return (-1);
6357 }
6358
6359 if (show == 1 || left == 1)
6360 {
6361 attack_mode = ATTACK_MODE_NONE;
6362
6363 if (remove == 1)
6364 {
6365 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6366
6367 return (-1);
6368 }
6369
6370 if (potfile_disable == 1)
6371 {
6372 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6373
6374 return (-1);
6375 }
6376 }
6377
6378 uint attack_kern = ATTACK_KERN_NONE;
6379
6380 switch (attack_mode)
6381 {
6382 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6383 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6384 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6385 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6386 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6387 }
6388
6389 if (benchmark == 0)
6390 {
6391 if (keyspace == 1)
6392 {
6393 int num_additional_params = 1;
6394
6395 if (attack_kern == ATTACK_KERN_COMBI)
6396 {
6397 num_additional_params = 2;
6398 }
6399
6400 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6401
6402 if (keyspace_wordlist_specified == 0) optind--;
6403 }
6404
6405 if (attack_kern == ATTACK_KERN_NONE)
6406 {
6407 if ((optind + 1) != myargc)
6408 {
6409 usage_mini_print (myargv[0]);
6410
6411 return (-1);
6412 }
6413 }
6414 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6415 {
6416 if ((optind + 1) > myargc)
6417 {
6418 usage_mini_print (myargv[0]);
6419
6420 return (-1);
6421 }
6422 }
6423 else if (attack_kern == ATTACK_KERN_COMBI)
6424 {
6425 if ((optind + 3) != myargc)
6426 {
6427 usage_mini_print (myargv[0]);
6428
6429 return (-1);
6430 }
6431 }
6432 else if (attack_kern == ATTACK_KERN_BF)
6433 {
6434 if ((optind + 1) > myargc)
6435 {
6436 usage_mini_print (myargv[0]);
6437
6438 return (-1);
6439 }
6440 }
6441 else
6442 {
6443 usage_mini_print (myargv[0]);
6444
6445 return (-1);
6446 }
6447 }
6448 else
6449 {
6450 if (myargv[optind] != 0)
6451 {
6452 log_error ("ERROR: Invalid argument for benchmark mode specified");
6453
6454 return (-1);
6455 }
6456
6457 if (attack_mode_chgd == 1)
6458 {
6459 if (attack_mode != ATTACK_MODE_BF)
6460 {
6461 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6462
6463 return (-1);
6464 }
6465 }
6466 }
6467
6468 if (skip != 0 && limit != 0)
6469 {
6470 limit += skip;
6471 }
6472
6473 if (keyspace == 1)
6474 {
6475 if (show == 1)
6476 {
6477 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6478
6479 return (-1);
6480 }
6481 else if (left == 1)
6482 {
6483 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6484
6485 return (-1);
6486 }
6487
6488 potfile_disable = 1;
6489
6490 restore_disable = 1;
6491
6492 restore = 0;
6493
6494 weak_hash_threshold = 0;
6495
6496 quiet = 1;
6497 }
6498
6499 if (remove_timer_chgd == 1)
6500 {
6501 if (remove == 0)
6502 {
6503 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6504
6505 return (-1);
6506 }
6507
6508 if (remove_timer < 1)
6509 {
6510 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6511
6512 return (-1);
6513 }
6514 }
6515
6516 if (loopback == 1)
6517 {
6518 if (attack_mode == ATTACK_MODE_STRAIGHT)
6519 {
6520 if ((rp_files_cnt == 0) && (rp_gen == 0))
6521 {
6522 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6523
6524 return (-1);
6525 }
6526 }
6527 else
6528 {
6529 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6530
6531 return (-1);
6532 }
6533 }
6534
6535 if (debug_mode > 0)
6536 {
6537 if (attack_mode != ATTACK_MODE_STRAIGHT)
6538 {
6539 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6540
6541 return (-1);
6542 }
6543
6544 if ((rp_files_cnt == 0) && (rp_gen == 0))
6545 {
6546 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6547
6548 return (-1);
6549 }
6550 }
6551
6552 if (debug_mode > 4)
6553 {
6554 log_error ("ERROR: Invalid debug-mode specified");
6555
6556 return (-1);
6557 }
6558
6559 if (debug_file != NULL)
6560 {
6561 if (debug_mode < 1)
6562 {
6563 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6564
6565 return (-1);
6566 }
6567 }
6568
6569 if (induction_dir != NULL)
6570 {
6571 if (attack_mode == ATTACK_MODE_BF)
6572 {
6573 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6574
6575 return (-1);
6576 }
6577 }
6578
6579 if (attack_mode != ATTACK_MODE_STRAIGHT)
6580 {
6581 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6582 {
6583 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6584
6585 return (-1);
6586 }
6587
6588 weak_hash_threshold = 0;
6589 }
6590
6591 /**
6592 * induction directory
6593 */
6594
6595 char *induction_directory = NULL;
6596
6597 if (attack_mode != ATTACK_MODE_BF)
6598 {
6599 if (induction_dir == NULL)
6600 {
6601 induction_directory = (char *) mymalloc (session_size);
6602
6603 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6604
6605 // create induction folder if it does not already exist
6606
6607 if (keyspace == 0)
6608 {
6609 if (rmdir (induction_directory) == -1)
6610 {
6611 if (errno == ENOENT)
6612 {
6613 // good, we can ignore
6614 }
6615 else if (errno == ENOTEMPTY)
6616 {
6617 char *induction_directory_mv = (char *) mymalloc (session_size);
6618
6619 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6620
6621 if (rename (induction_directory, induction_directory_mv) != 0)
6622 {
6623 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6624
6625 return (-1);
6626 }
6627 }
6628 else
6629 {
6630 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6631
6632 return (-1);
6633 }
6634 }
6635
6636 if (mkdir (induction_directory, 0700) == -1)
6637 {
6638 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6639
6640 return (-1);
6641 }
6642 }
6643 }
6644 else
6645 {
6646 induction_directory = induction_dir;
6647 }
6648 }
6649
6650 data.induction_directory = induction_directory;
6651
6652 /**
6653 * loopback
6654 */
6655
6656 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6657
6658 char *loopback_file = (char *) mymalloc (loopback_size);
6659
6660 /**
6661 * tuning db
6662 */
6663
6664 char tuning_db_file[256] = { 0 };
6665
6666 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6667
6668 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6669
6670 /**
6671 * outfile-check directory
6672 */
6673
6674 char *outfile_check_directory = NULL;
6675
6676 if (outfile_check_dir == NULL)
6677 {
6678 outfile_check_directory = (char *) mymalloc (session_size);
6679
6680 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6681 }
6682 else
6683 {
6684 outfile_check_directory = outfile_check_dir;
6685 }
6686
6687 data.outfile_check_directory = outfile_check_directory;
6688
6689 if (keyspace == 0)
6690 {
6691 struct stat outfile_check_stat;
6692
6693 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6694 {
6695 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6696
6697 if (is_dir == 0)
6698 {
6699 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6700
6701 return (-1);
6702 }
6703 }
6704 else if (outfile_check_dir == NULL)
6705 {
6706 if (mkdir (outfile_check_directory, 0700) == -1)
6707 {
6708 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6709
6710 return (-1);
6711 }
6712 }
6713 }
6714
6715 /**
6716 * special other stuff
6717 */
6718
6719 if (hash_mode == 9710)
6720 {
6721 outfile_format = 5;
6722 outfile_format_chgd = 1;
6723 }
6724
6725 if (hash_mode == 9810)
6726 {
6727 outfile_format = 5;
6728 outfile_format_chgd = 1;
6729 }
6730
6731 if (hash_mode == 10410)
6732 {
6733 outfile_format = 5;
6734 outfile_format_chgd = 1;
6735 }
6736
6737 /**
6738 * store stuff
6739 */
6740
6741 data.hash_mode = hash_mode;
6742 data.restore = restore;
6743 data.restore_timer = restore_timer;
6744 data.restore_disable = restore_disable;
6745 data.status = status;
6746 data.status_timer = status_timer;
6747 data.machine_readable = machine_readable;
6748 data.loopback = loopback;
6749 data.runtime = runtime;
6750 data.remove = remove;
6751 data.remove_timer = remove_timer;
6752 data.debug_mode = debug_mode;
6753 data.debug_file = debug_file;
6754 data.username = username;
6755 data.quiet = quiet;
6756 data.outfile = outfile;
6757 data.outfile_format = outfile_format;
6758 data.outfile_autohex = outfile_autohex;
6759 data.hex_charset = hex_charset;
6760 data.hex_salt = hex_salt;
6761 data.hex_wordlist = hex_wordlist;
6762 data.separator = separator;
6763 data.rp_files = rp_files;
6764 data.rp_files_cnt = rp_files_cnt;
6765 data.rp_gen = rp_gen;
6766 data.rp_gen_seed = rp_gen_seed;
6767 data.force = force;
6768 data.benchmark = benchmark;
6769 data.skip = skip;
6770 data.limit = limit;
6771 #ifdef HAVE_HWMON
6772 data.powertune_enable = powertune_enable;
6773 #endif
6774 data.logfile_disable = logfile_disable;
6775 data.truecrypt_keyfiles = truecrypt_keyfiles;
6776 data.veracrypt_keyfiles = veracrypt_keyfiles;
6777 data.veracrypt_pim = veracrypt_pim;
6778 data.scrypt_tmto = scrypt_tmto;
6779 data.workload_profile = workload_profile;
6780
6781 /**
6782 * cpu affinity
6783 */
6784
6785 if (cpu_affinity)
6786 {
6787 set_cpu_affinity (cpu_affinity);
6788 }
6789
6790 if (rp_gen_seed_chgd == 0)
6791 {
6792 srand (proc_start);
6793 }
6794 else
6795 {
6796 srand (rp_gen_seed);
6797 }
6798
6799 /**
6800 * logfile init
6801 */
6802
6803 if (logfile_disable == 0)
6804 {
6805 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6806
6807 char *logfile = (char *) mymalloc (logfile_size);
6808
6809 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6810
6811 data.logfile = logfile;
6812
6813 char *topid = logfile_generate_topid ();
6814
6815 data.topid = topid;
6816 }
6817
6818 // logfile_append() checks for logfile_disable internally to make it easier from here
6819
6820 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6821 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6822 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6823 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6824 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6825 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6826 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6827 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6828 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6829 #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));
6830
6831 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6832 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6833 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6834 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6835 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6836 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6837 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6838 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6839
6840 logfile_top_msg ("START");
6841
6842 logfile_top_uint (attack_mode);
6843 logfile_top_uint (attack_kern);
6844 logfile_top_uint (benchmark);
6845 logfile_top_uint (bitmap_min);
6846 logfile_top_uint (bitmap_max);
6847 logfile_top_uint (debug_mode);
6848 logfile_top_uint (force);
6849 logfile_top_uint (kernel_accel);
6850 logfile_top_uint (kernel_loops);
6851 logfile_top_uint (gpu_temp_disable);
6852 #ifdef HAVE_HWMON
6853 logfile_top_uint (gpu_temp_abort);
6854 logfile_top_uint (gpu_temp_retain);
6855 #endif
6856 logfile_top_uint (hash_mode);
6857 logfile_top_uint (hex_charset);
6858 logfile_top_uint (hex_salt);
6859 logfile_top_uint (hex_wordlist);
6860 logfile_top_uint (increment);
6861 logfile_top_uint (increment_max);
6862 logfile_top_uint (increment_min);
6863 logfile_top_uint (keyspace);
6864 logfile_top_uint (left);
6865 logfile_top_uint (logfile_disable);
6866 logfile_top_uint (loopback);
6867 logfile_top_uint (markov_classic);
6868 logfile_top_uint (markov_disable);
6869 logfile_top_uint (markov_threshold);
6870 logfile_top_uint (outfile_autohex);
6871 logfile_top_uint (outfile_check_timer);
6872 logfile_top_uint (outfile_format);
6873 logfile_top_uint (potfile_disable);
6874 logfile_top_string (potfile_path);
6875 #if defined(HAVE_HWMON)
6876 logfile_top_uint (powertune_enable);
6877 #endif
6878 logfile_top_uint (scrypt_tmto);
6879 logfile_top_uint (quiet);
6880 logfile_top_uint (remove);
6881 logfile_top_uint (remove_timer);
6882 logfile_top_uint (restore);
6883 logfile_top_uint (restore_disable);
6884 logfile_top_uint (restore_timer);
6885 logfile_top_uint (rp_gen);
6886 logfile_top_uint (rp_gen_func_max);
6887 logfile_top_uint (rp_gen_func_min);
6888 logfile_top_uint (rp_gen_seed);
6889 logfile_top_uint (runtime);
6890 logfile_top_uint (segment_size);
6891 logfile_top_uint (show);
6892 logfile_top_uint (status);
6893 logfile_top_uint (machine_readable);
6894 logfile_top_uint (status_timer);
6895 logfile_top_uint (usage);
6896 logfile_top_uint (username);
6897 logfile_top_uint (version);
6898 logfile_top_uint (weak_hash_threshold);
6899 logfile_top_uint (workload_profile);
6900 logfile_top_uint64 (limit);
6901 logfile_top_uint64 (skip);
6902 logfile_top_char (separator);
6903 logfile_top_string (cpu_affinity);
6904 logfile_top_string (custom_charset_1);
6905 logfile_top_string (custom_charset_2);
6906 logfile_top_string (custom_charset_3);
6907 logfile_top_string (custom_charset_4);
6908 logfile_top_string (debug_file);
6909 logfile_top_string (opencl_devices);
6910 logfile_top_string (opencl_platforms);
6911 logfile_top_string (opencl_device_types);
6912 logfile_top_uint (opencl_vector_width);
6913 logfile_top_string (induction_dir);
6914 logfile_top_string (markov_hcstat);
6915 logfile_top_string (outfile);
6916 logfile_top_string (outfile_check_dir);
6917 logfile_top_string (rule_buf_l);
6918 logfile_top_string (rule_buf_r);
6919 logfile_top_string (session);
6920 logfile_top_string (truecrypt_keyfiles);
6921 logfile_top_string (veracrypt_keyfiles);
6922 logfile_top_uint (veracrypt_pim);
6923
6924 /**
6925 * Init OpenCL library loader
6926 */
6927
6928 if (keyspace == 0)
6929 {
6930 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6931
6932 ocl_init (ocl);
6933
6934 data.ocl = ocl;
6935 }
6936
6937 /**
6938 * OpenCL platform selection
6939 */
6940
6941 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6942
6943 /**
6944 * OpenCL device selection
6945 */
6946
6947 u32 devices_filter = setup_devices_filter (opencl_devices);
6948
6949 /**
6950 * OpenCL device type selection
6951 */
6952
6953 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6954
6955 /**
6956 * benchmark
6957 */
6958
6959 if (benchmark == 1)
6960 {
6961 /**
6962 * disable useless stuff for benchmark
6963 */
6964
6965 status_timer = 0;
6966 restore_timer = 0;
6967 restore_disable = 1;
6968 potfile_disable = 1;
6969 weak_hash_threshold = 0;
6970 gpu_temp_disable = 1;
6971
6972 #ifdef HAVE_HWMON
6973 powertune_enable = 1;
6974 #endif
6975
6976 data.status_timer = status_timer;
6977 data.restore_timer = restore_timer;
6978 data.restore_disable = restore_disable;
6979
6980 /**
6981 * force attack mode to be bruteforce
6982 */
6983
6984 attack_mode = ATTACK_MODE_BF;
6985 attack_kern = ATTACK_KERN_BF;
6986
6987 if (workload_profile_chgd == 0)
6988 {
6989 workload_profile = 3;
6990
6991 data.workload_profile = workload_profile;
6992 }
6993 }
6994
6995 /**
6996 * config
6997 */
6998
6999 uint hash_type = 0;
7000 uint salt_type = 0;
7001 uint attack_exec = 0;
7002 uint opts_type = 0;
7003 uint kern_type = 0;
7004 uint dgst_size = 0;
7005 uint esalt_size = 0;
7006 uint opti_type = 0;
7007 uint dgst_pos0 = -1;
7008 uint dgst_pos1 = -1;
7009 uint dgst_pos2 = -1;
7010 uint dgst_pos3 = -1;
7011
7012 int (*parse_func) (char *, uint, hash_t *);
7013 int (*sort_by_digest) (const void *, const void *);
7014
7015 uint algorithm_pos = 0;
7016 uint algorithm_max = 1;
7017
7018 uint *algorithms = default_benchmark_algorithms;
7019
7020 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7021
7022 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7023 {
7024 /*
7025 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7026 * the following algos are skipped entirely
7027 */
7028
7029 if (algorithm_pos > 0)
7030 {
7031 local_free (rd);
7032
7033 rd = init_restore (argc, argv);
7034
7035 data.rd = rd;
7036 }
7037
7038 /**
7039 * update hash_mode in case of multihash benchmark
7040 */
7041
7042 if (benchmark == 1)
7043 {
7044 if (hash_mode_chgd == 0)
7045 {
7046 hash_mode = algorithms[algorithm_pos];
7047
7048 data.hash_mode = hash_mode;
7049 }
7050
7051 quiet = 1;
7052
7053 data.quiet = quiet;
7054 }
7055
7056 switch (hash_mode)
7057 {
7058 case 0: hash_type = HASH_TYPE_MD5;
7059 salt_type = SALT_TYPE_NONE;
7060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7061 opts_type = OPTS_TYPE_PT_GENERATE_LE
7062 | OPTS_TYPE_PT_ADD80
7063 | OPTS_TYPE_PT_ADDBITS14;
7064 kern_type = KERN_TYPE_MD5;
7065 dgst_size = DGST_SIZE_4_4;
7066 parse_func = md5_parse_hash;
7067 sort_by_digest = sort_by_digest_4_4;
7068 opti_type = OPTI_TYPE_ZERO_BYTE
7069 | OPTI_TYPE_PRECOMPUTE_INIT
7070 | OPTI_TYPE_PRECOMPUTE_MERKLE
7071 | OPTI_TYPE_MEET_IN_MIDDLE
7072 | OPTI_TYPE_EARLY_SKIP
7073 | OPTI_TYPE_NOT_ITERATED
7074 | OPTI_TYPE_NOT_SALTED
7075 | OPTI_TYPE_RAW_HASH;
7076 dgst_pos0 = 0;
7077 dgst_pos1 = 3;
7078 dgst_pos2 = 2;
7079 dgst_pos3 = 1;
7080 break;
7081
7082 case 10: hash_type = HASH_TYPE_MD5;
7083 salt_type = SALT_TYPE_INTERN;
7084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7085 opts_type = OPTS_TYPE_PT_GENERATE_LE
7086 | OPTS_TYPE_ST_ADD80
7087 | OPTS_TYPE_ST_ADDBITS14;
7088 kern_type = KERN_TYPE_MD5_PWSLT;
7089 dgst_size = DGST_SIZE_4_4;
7090 parse_func = md5s_parse_hash;
7091 sort_by_digest = sort_by_digest_4_4;
7092 opti_type = OPTI_TYPE_ZERO_BYTE
7093 | OPTI_TYPE_PRECOMPUTE_INIT
7094 | OPTI_TYPE_PRECOMPUTE_MERKLE
7095 | OPTI_TYPE_MEET_IN_MIDDLE
7096 | OPTI_TYPE_EARLY_SKIP
7097 | OPTI_TYPE_NOT_ITERATED
7098 | OPTI_TYPE_APPENDED_SALT
7099 | OPTI_TYPE_RAW_HASH;
7100 dgst_pos0 = 0;
7101 dgst_pos1 = 3;
7102 dgst_pos2 = 2;
7103 dgst_pos3 = 1;
7104 break;
7105
7106 case 11: hash_type = HASH_TYPE_MD5;
7107 salt_type = SALT_TYPE_INTERN;
7108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7109 opts_type = OPTS_TYPE_PT_GENERATE_LE
7110 | OPTS_TYPE_ST_ADD80
7111 | OPTS_TYPE_ST_ADDBITS14;
7112 kern_type = KERN_TYPE_MD5_PWSLT;
7113 dgst_size = DGST_SIZE_4_4;
7114 parse_func = joomla_parse_hash;
7115 sort_by_digest = sort_by_digest_4_4;
7116 opti_type = OPTI_TYPE_ZERO_BYTE
7117 | OPTI_TYPE_PRECOMPUTE_INIT
7118 | OPTI_TYPE_PRECOMPUTE_MERKLE
7119 | OPTI_TYPE_MEET_IN_MIDDLE
7120 | OPTI_TYPE_EARLY_SKIP
7121 | OPTI_TYPE_NOT_ITERATED
7122 | OPTI_TYPE_APPENDED_SALT
7123 | OPTI_TYPE_RAW_HASH;
7124 dgst_pos0 = 0;
7125 dgst_pos1 = 3;
7126 dgst_pos2 = 2;
7127 dgst_pos3 = 1;
7128 break;
7129
7130 case 12: hash_type = HASH_TYPE_MD5;
7131 salt_type = SALT_TYPE_INTERN;
7132 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7133 opts_type = OPTS_TYPE_PT_GENERATE_LE
7134 | OPTS_TYPE_ST_ADD80
7135 | OPTS_TYPE_ST_ADDBITS14;
7136 kern_type = KERN_TYPE_MD5_PWSLT;
7137 dgst_size = DGST_SIZE_4_4;
7138 parse_func = postgresql_parse_hash;
7139 sort_by_digest = sort_by_digest_4_4;
7140 opti_type = OPTI_TYPE_ZERO_BYTE
7141 | OPTI_TYPE_PRECOMPUTE_INIT
7142 | OPTI_TYPE_PRECOMPUTE_MERKLE
7143 | OPTI_TYPE_MEET_IN_MIDDLE
7144 | OPTI_TYPE_EARLY_SKIP
7145 | OPTI_TYPE_NOT_ITERATED
7146 | OPTI_TYPE_APPENDED_SALT
7147 | OPTI_TYPE_RAW_HASH;
7148 dgst_pos0 = 0;
7149 dgst_pos1 = 3;
7150 dgst_pos2 = 2;
7151 dgst_pos3 = 1;
7152 break;
7153
7154 case 20: hash_type = HASH_TYPE_MD5;
7155 salt_type = SALT_TYPE_INTERN;
7156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7157 opts_type = OPTS_TYPE_PT_GENERATE_LE
7158 | OPTS_TYPE_PT_ADD80
7159 | OPTS_TYPE_PT_ADDBITS14;
7160 kern_type = KERN_TYPE_MD5_SLTPW;
7161 dgst_size = DGST_SIZE_4_4;
7162 parse_func = md5s_parse_hash;
7163 sort_by_digest = sort_by_digest_4_4;
7164 opti_type = OPTI_TYPE_ZERO_BYTE
7165 | OPTI_TYPE_PRECOMPUTE_INIT
7166 | OPTI_TYPE_PRECOMPUTE_MERKLE
7167 | OPTI_TYPE_EARLY_SKIP
7168 | OPTI_TYPE_NOT_ITERATED
7169 | OPTI_TYPE_PREPENDED_SALT
7170 | OPTI_TYPE_RAW_HASH;
7171 dgst_pos0 = 0;
7172 dgst_pos1 = 3;
7173 dgst_pos2 = 2;
7174 dgst_pos3 = 1;
7175 break;
7176
7177 case 21: hash_type = HASH_TYPE_MD5;
7178 salt_type = SALT_TYPE_INTERN;
7179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7180 opts_type = OPTS_TYPE_PT_GENERATE_LE
7181 | OPTS_TYPE_PT_ADD80
7182 | OPTS_TYPE_PT_ADDBITS14;
7183 kern_type = KERN_TYPE_MD5_SLTPW;
7184 dgst_size = DGST_SIZE_4_4;
7185 parse_func = osc_parse_hash;
7186 sort_by_digest = sort_by_digest_4_4;
7187 opti_type = OPTI_TYPE_ZERO_BYTE
7188 | OPTI_TYPE_PRECOMPUTE_INIT
7189 | OPTI_TYPE_PRECOMPUTE_MERKLE
7190 | OPTI_TYPE_EARLY_SKIP
7191 | OPTI_TYPE_NOT_ITERATED
7192 | OPTI_TYPE_PREPENDED_SALT
7193 | OPTI_TYPE_RAW_HASH;
7194 dgst_pos0 = 0;
7195 dgst_pos1 = 3;
7196 dgst_pos2 = 2;
7197 dgst_pos3 = 1;
7198 break;
7199
7200 case 22: hash_type = HASH_TYPE_MD5;
7201 salt_type = SALT_TYPE_EMBEDDED;
7202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7203 opts_type = OPTS_TYPE_PT_GENERATE_LE
7204 | OPTS_TYPE_PT_ADD80
7205 | OPTS_TYPE_PT_ADDBITS14;
7206 kern_type = KERN_TYPE_MD5_SLTPW;
7207 dgst_size = DGST_SIZE_4_4;
7208 parse_func = netscreen_parse_hash;
7209 sort_by_digest = sort_by_digest_4_4;
7210 opti_type = OPTI_TYPE_ZERO_BYTE
7211 | OPTI_TYPE_PRECOMPUTE_INIT
7212 | OPTI_TYPE_PRECOMPUTE_MERKLE
7213 | OPTI_TYPE_EARLY_SKIP
7214 | OPTI_TYPE_NOT_ITERATED
7215 | OPTI_TYPE_PREPENDED_SALT
7216 | OPTI_TYPE_RAW_HASH;
7217 dgst_pos0 = 0;
7218 dgst_pos1 = 3;
7219 dgst_pos2 = 2;
7220 dgst_pos3 = 1;
7221 break;
7222
7223 case 23: hash_type = HASH_TYPE_MD5;
7224 salt_type = SALT_TYPE_EMBEDDED;
7225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7226 opts_type = OPTS_TYPE_PT_GENERATE_LE
7227 | OPTS_TYPE_PT_ADD80
7228 | OPTS_TYPE_PT_ADDBITS14;
7229 kern_type = KERN_TYPE_MD5_SLTPW;
7230 dgst_size = DGST_SIZE_4_4;
7231 parse_func = skype_parse_hash;
7232 sort_by_digest = sort_by_digest_4_4;
7233 opti_type = OPTI_TYPE_ZERO_BYTE
7234 | OPTI_TYPE_PRECOMPUTE_INIT
7235 | OPTI_TYPE_PRECOMPUTE_MERKLE
7236 | OPTI_TYPE_EARLY_SKIP
7237 | OPTI_TYPE_NOT_ITERATED
7238 | OPTI_TYPE_PREPENDED_SALT
7239 | OPTI_TYPE_RAW_HASH;
7240 dgst_pos0 = 0;
7241 dgst_pos1 = 3;
7242 dgst_pos2 = 2;
7243 dgst_pos3 = 1;
7244 break;
7245
7246 case 30: hash_type = HASH_TYPE_MD5;
7247 salt_type = SALT_TYPE_INTERN;
7248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7249 opts_type = OPTS_TYPE_PT_GENERATE_LE
7250 | OPTS_TYPE_PT_UNICODE
7251 | OPTS_TYPE_ST_ADD80
7252 | OPTS_TYPE_ST_ADDBITS14;
7253 kern_type = KERN_TYPE_MD5_PWUSLT;
7254 dgst_size = DGST_SIZE_4_4;
7255 parse_func = md5s_parse_hash;
7256 sort_by_digest = sort_by_digest_4_4;
7257 opti_type = OPTI_TYPE_ZERO_BYTE
7258 | OPTI_TYPE_PRECOMPUTE_INIT
7259 | OPTI_TYPE_PRECOMPUTE_MERKLE
7260 | OPTI_TYPE_MEET_IN_MIDDLE
7261 | OPTI_TYPE_EARLY_SKIP
7262 | OPTI_TYPE_NOT_ITERATED
7263 | OPTI_TYPE_APPENDED_SALT
7264 | OPTI_TYPE_RAW_HASH;
7265 dgst_pos0 = 0;
7266 dgst_pos1 = 3;
7267 dgst_pos2 = 2;
7268 dgst_pos3 = 1;
7269 break;
7270
7271 case 40: hash_type = HASH_TYPE_MD5;
7272 salt_type = SALT_TYPE_INTERN;
7273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7274 opts_type = OPTS_TYPE_PT_GENERATE_LE
7275 | OPTS_TYPE_PT_ADD80
7276 | OPTS_TYPE_PT_ADDBITS14
7277 | OPTS_TYPE_PT_UNICODE;
7278 kern_type = KERN_TYPE_MD5_SLTPWU;
7279 dgst_size = DGST_SIZE_4_4;
7280 parse_func = md5s_parse_hash;
7281 sort_by_digest = sort_by_digest_4_4;
7282 opti_type = OPTI_TYPE_ZERO_BYTE
7283 | OPTI_TYPE_PRECOMPUTE_INIT
7284 | OPTI_TYPE_PRECOMPUTE_MERKLE
7285 | OPTI_TYPE_EARLY_SKIP
7286 | OPTI_TYPE_NOT_ITERATED
7287 | OPTI_TYPE_PREPENDED_SALT
7288 | OPTI_TYPE_RAW_HASH;
7289 dgst_pos0 = 0;
7290 dgst_pos1 = 3;
7291 dgst_pos2 = 2;
7292 dgst_pos3 = 1;
7293 break;
7294
7295 case 50: hash_type = HASH_TYPE_MD5;
7296 salt_type = SALT_TYPE_INTERN;
7297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7298 opts_type = OPTS_TYPE_PT_GENERATE_LE
7299 | OPTS_TYPE_ST_ADD80
7300 | OPTS_TYPE_ST_ADDBITS14;
7301 kern_type = KERN_TYPE_HMACMD5_PW;
7302 dgst_size = DGST_SIZE_4_4;
7303 parse_func = hmacmd5_parse_hash;
7304 sort_by_digest = sort_by_digest_4_4;
7305 opti_type = OPTI_TYPE_ZERO_BYTE
7306 | OPTI_TYPE_NOT_ITERATED;
7307 dgst_pos0 = 0;
7308 dgst_pos1 = 3;
7309 dgst_pos2 = 2;
7310 dgst_pos3 = 1;
7311 break;
7312
7313 case 60: hash_type = HASH_TYPE_MD5;
7314 salt_type = SALT_TYPE_INTERN;
7315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7316 opts_type = OPTS_TYPE_PT_GENERATE_LE
7317 | OPTS_TYPE_PT_ADD80
7318 | OPTS_TYPE_PT_ADDBITS14;
7319 kern_type = KERN_TYPE_HMACMD5_SLT;
7320 dgst_size = DGST_SIZE_4_4;
7321 parse_func = hmacmd5_parse_hash;
7322 sort_by_digest = sort_by_digest_4_4;
7323 opti_type = OPTI_TYPE_ZERO_BYTE
7324 | OPTI_TYPE_NOT_ITERATED;
7325 dgst_pos0 = 0;
7326 dgst_pos1 = 3;
7327 dgst_pos2 = 2;
7328 dgst_pos3 = 1;
7329 break;
7330
7331 case 100: hash_type = HASH_TYPE_SHA1;
7332 salt_type = SALT_TYPE_NONE;
7333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7334 opts_type = OPTS_TYPE_PT_GENERATE_BE
7335 | OPTS_TYPE_PT_ADD80
7336 | OPTS_TYPE_PT_ADDBITS15;
7337 kern_type = KERN_TYPE_SHA1;
7338 dgst_size = DGST_SIZE_4_5;
7339 parse_func = sha1_parse_hash;
7340 sort_by_digest = sort_by_digest_4_5;
7341 opti_type = OPTI_TYPE_ZERO_BYTE
7342 | OPTI_TYPE_PRECOMPUTE_INIT
7343 | OPTI_TYPE_PRECOMPUTE_MERKLE
7344 | OPTI_TYPE_EARLY_SKIP
7345 | OPTI_TYPE_NOT_ITERATED
7346 | OPTI_TYPE_NOT_SALTED
7347 | OPTI_TYPE_RAW_HASH;
7348 dgst_pos0 = 3;
7349 dgst_pos1 = 4;
7350 dgst_pos2 = 2;
7351 dgst_pos3 = 1;
7352 break;
7353
7354 case 101: hash_type = HASH_TYPE_SHA1;
7355 salt_type = SALT_TYPE_NONE;
7356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7357 opts_type = OPTS_TYPE_PT_GENERATE_BE
7358 | OPTS_TYPE_PT_ADD80
7359 | OPTS_TYPE_PT_ADDBITS15;
7360 kern_type = KERN_TYPE_SHA1;
7361 dgst_size = DGST_SIZE_4_5;
7362 parse_func = sha1b64_parse_hash;
7363 sort_by_digest = sort_by_digest_4_5;
7364 opti_type = OPTI_TYPE_ZERO_BYTE
7365 | OPTI_TYPE_PRECOMPUTE_INIT
7366 | OPTI_TYPE_PRECOMPUTE_MERKLE
7367 | OPTI_TYPE_EARLY_SKIP
7368 | OPTI_TYPE_NOT_ITERATED
7369 | OPTI_TYPE_NOT_SALTED
7370 | OPTI_TYPE_RAW_HASH;
7371 dgst_pos0 = 3;
7372 dgst_pos1 = 4;
7373 dgst_pos2 = 2;
7374 dgst_pos3 = 1;
7375 break;
7376
7377 case 110: hash_type = HASH_TYPE_SHA1;
7378 salt_type = SALT_TYPE_INTERN;
7379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7380 opts_type = OPTS_TYPE_PT_GENERATE_BE
7381 | OPTS_TYPE_ST_ADD80
7382 | OPTS_TYPE_ST_ADDBITS15;
7383 kern_type = KERN_TYPE_SHA1_PWSLT;
7384 dgst_size = DGST_SIZE_4_5;
7385 parse_func = sha1s_parse_hash;
7386 sort_by_digest = sort_by_digest_4_5;
7387 opti_type = OPTI_TYPE_ZERO_BYTE
7388 | OPTI_TYPE_PRECOMPUTE_INIT
7389 | OPTI_TYPE_PRECOMPUTE_MERKLE
7390 | OPTI_TYPE_EARLY_SKIP
7391 | OPTI_TYPE_NOT_ITERATED
7392 | OPTI_TYPE_APPENDED_SALT
7393 | OPTI_TYPE_RAW_HASH;
7394 dgst_pos0 = 3;
7395 dgst_pos1 = 4;
7396 dgst_pos2 = 2;
7397 dgst_pos3 = 1;
7398 break;
7399
7400 case 111: hash_type = HASH_TYPE_SHA1;
7401 salt_type = SALT_TYPE_EMBEDDED;
7402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7403 opts_type = OPTS_TYPE_PT_GENERATE_BE
7404 | OPTS_TYPE_ST_ADD80
7405 | OPTS_TYPE_ST_ADDBITS15;
7406 kern_type = KERN_TYPE_SHA1_PWSLT;
7407 dgst_size = DGST_SIZE_4_5;
7408 parse_func = sha1b64s_parse_hash;
7409 sort_by_digest = sort_by_digest_4_5;
7410 opti_type = OPTI_TYPE_ZERO_BYTE
7411 | OPTI_TYPE_PRECOMPUTE_INIT
7412 | OPTI_TYPE_PRECOMPUTE_MERKLE
7413 | OPTI_TYPE_EARLY_SKIP
7414 | OPTI_TYPE_NOT_ITERATED
7415 | OPTI_TYPE_APPENDED_SALT
7416 | OPTI_TYPE_RAW_HASH;
7417 dgst_pos0 = 3;
7418 dgst_pos1 = 4;
7419 dgst_pos2 = 2;
7420 dgst_pos3 = 1;
7421 break;
7422
7423 case 112: hash_type = HASH_TYPE_SHA1;
7424 salt_type = SALT_TYPE_INTERN;
7425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7426 opts_type = OPTS_TYPE_PT_GENERATE_BE
7427 | OPTS_TYPE_ST_ADD80
7428 | OPTS_TYPE_ST_ADDBITS15
7429 | OPTS_TYPE_ST_HEX;
7430 kern_type = KERN_TYPE_SHA1_PWSLT;
7431 dgst_size = DGST_SIZE_4_5;
7432 parse_func = oracles_parse_hash;
7433 sort_by_digest = sort_by_digest_4_5;
7434 opti_type = OPTI_TYPE_ZERO_BYTE
7435 | OPTI_TYPE_PRECOMPUTE_INIT
7436 | OPTI_TYPE_PRECOMPUTE_MERKLE
7437 | OPTI_TYPE_EARLY_SKIP
7438 | OPTI_TYPE_NOT_ITERATED
7439 | OPTI_TYPE_APPENDED_SALT
7440 | OPTI_TYPE_RAW_HASH;
7441 dgst_pos0 = 3;
7442 dgst_pos1 = 4;
7443 dgst_pos2 = 2;
7444 dgst_pos3 = 1;
7445 break;
7446
7447 case 120: hash_type = HASH_TYPE_SHA1;
7448 salt_type = SALT_TYPE_INTERN;
7449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7450 opts_type = OPTS_TYPE_PT_GENERATE_BE
7451 | OPTS_TYPE_PT_ADD80
7452 | OPTS_TYPE_PT_ADDBITS15;
7453 kern_type = KERN_TYPE_SHA1_SLTPW;
7454 dgst_size = DGST_SIZE_4_5;
7455 parse_func = sha1s_parse_hash;
7456 sort_by_digest = sort_by_digest_4_5;
7457 opti_type = OPTI_TYPE_ZERO_BYTE
7458 | OPTI_TYPE_PRECOMPUTE_INIT
7459 | OPTI_TYPE_PRECOMPUTE_MERKLE
7460 | OPTI_TYPE_EARLY_SKIP
7461 | OPTI_TYPE_NOT_ITERATED
7462 | OPTI_TYPE_PREPENDED_SALT
7463 | OPTI_TYPE_RAW_HASH;
7464 dgst_pos0 = 3;
7465 dgst_pos1 = 4;
7466 dgst_pos2 = 2;
7467 dgst_pos3 = 1;
7468 break;
7469
7470 case 121: hash_type = HASH_TYPE_SHA1;
7471 salt_type = SALT_TYPE_INTERN;
7472 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7473 opts_type = OPTS_TYPE_PT_GENERATE_BE
7474 | OPTS_TYPE_PT_ADD80
7475 | OPTS_TYPE_PT_ADDBITS15
7476 | OPTS_TYPE_ST_LOWER;
7477 kern_type = KERN_TYPE_SHA1_SLTPW;
7478 dgst_size = DGST_SIZE_4_5;
7479 parse_func = smf_parse_hash;
7480 sort_by_digest = sort_by_digest_4_5;
7481 opti_type = OPTI_TYPE_ZERO_BYTE
7482 | OPTI_TYPE_PRECOMPUTE_INIT
7483 | OPTI_TYPE_PRECOMPUTE_MERKLE
7484 | OPTI_TYPE_EARLY_SKIP
7485 | OPTI_TYPE_NOT_ITERATED
7486 | OPTI_TYPE_PREPENDED_SALT
7487 | OPTI_TYPE_RAW_HASH;
7488 dgst_pos0 = 3;
7489 dgst_pos1 = 4;
7490 dgst_pos2 = 2;
7491 dgst_pos3 = 1;
7492 break;
7493
7494 case 122: hash_type = HASH_TYPE_SHA1;
7495 salt_type = SALT_TYPE_EMBEDDED;
7496 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7497 opts_type = OPTS_TYPE_PT_GENERATE_BE
7498 | OPTS_TYPE_PT_ADD80
7499 | OPTS_TYPE_PT_ADDBITS15
7500 | OPTS_TYPE_ST_HEX;
7501 kern_type = KERN_TYPE_SHA1_SLTPW;
7502 dgst_size = DGST_SIZE_4_5;
7503 parse_func = osx1_parse_hash;
7504 sort_by_digest = sort_by_digest_4_5;
7505 opti_type = OPTI_TYPE_ZERO_BYTE
7506 | OPTI_TYPE_PRECOMPUTE_INIT
7507 | OPTI_TYPE_PRECOMPUTE_MERKLE
7508 | OPTI_TYPE_EARLY_SKIP
7509 | OPTI_TYPE_NOT_ITERATED
7510 | OPTI_TYPE_PREPENDED_SALT
7511 | OPTI_TYPE_RAW_HASH;
7512 dgst_pos0 = 3;
7513 dgst_pos1 = 4;
7514 dgst_pos2 = 2;
7515 dgst_pos3 = 1;
7516 break;
7517
7518 case 124: hash_type = HASH_TYPE_SHA1;
7519 salt_type = SALT_TYPE_EMBEDDED;
7520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7521 opts_type = OPTS_TYPE_PT_GENERATE_BE
7522 | OPTS_TYPE_PT_ADD80
7523 | OPTS_TYPE_PT_ADDBITS15;
7524 kern_type = KERN_TYPE_SHA1_SLTPW;
7525 dgst_size = DGST_SIZE_4_5;
7526 parse_func = djangosha1_parse_hash;
7527 sort_by_digest = sort_by_digest_4_5;
7528 opti_type = OPTI_TYPE_ZERO_BYTE
7529 | OPTI_TYPE_PRECOMPUTE_INIT
7530 | OPTI_TYPE_PRECOMPUTE_MERKLE
7531 | OPTI_TYPE_EARLY_SKIP
7532 | OPTI_TYPE_NOT_ITERATED
7533 | OPTI_TYPE_PREPENDED_SALT
7534 | OPTI_TYPE_RAW_HASH;
7535 dgst_pos0 = 3;
7536 dgst_pos1 = 4;
7537 dgst_pos2 = 2;
7538 dgst_pos3 = 1;
7539 break;
7540
7541 case 125: hash_type = HASH_TYPE_SHA1;
7542 salt_type = SALT_TYPE_EMBEDDED;
7543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7544 opts_type = OPTS_TYPE_PT_GENERATE_BE
7545 | OPTS_TYPE_PT_ADD80
7546 | OPTS_TYPE_PT_ADDBITS15
7547 | OPTS_TYPE_ST_HEX;
7548 kern_type = KERN_TYPE_SHA1_SLTPW;
7549 dgst_size = DGST_SIZE_4_5;
7550 parse_func = arubaos_parse_hash;
7551 sort_by_digest = sort_by_digest_4_5;
7552 opti_type = OPTI_TYPE_ZERO_BYTE
7553 | OPTI_TYPE_PRECOMPUTE_INIT
7554 | OPTI_TYPE_PRECOMPUTE_MERKLE
7555 | OPTI_TYPE_EARLY_SKIP
7556 | OPTI_TYPE_NOT_ITERATED
7557 | OPTI_TYPE_PREPENDED_SALT
7558 | OPTI_TYPE_RAW_HASH;
7559 dgst_pos0 = 3;
7560 dgst_pos1 = 4;
7561 dgst_pos2 = 2;
7562 dgst_pos3 = 1;
7563 break;
7564
7565 case 130: hash_type = HASH_TYPE_SHA1;
7566 salt_type = SALT_TYPE_INTERN;
7567 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7568 opts_type = OPTS_TYPE_PT_GENERATE_BE
7569 | OPTS_TYPE_PT_UNICODE
7570 | OPTS_TYPE_ST_ADD80
7571 | OPTS_TYPE_ST_ADDBITS15;
7572 kern_type = KERN_TYPE_SHA1_PWUSLT;
7573 dgst_size = DGST_SIZE_4_5;
7574 parse_func = sha1s_parse_hash;
7575 sort_by_digest = sort_by_digest_4_5;
7576 opti_type = OPTI_TYPE_ZERO_BYTE
7577 | OPTI_TYPE_PRECOMPUTE_INIT
7578 | OPTI_TYPE_PRECOMPUTE_MERKLE
7579 | OPTI_TYPE_EARLY_SKIP
7580 | OPTI_TYPE_NOT_ITERATED
7581 | OPTI_TYPE_APPENDED_SALT
7582 | OPTI_TYPE_RAW_HASH;
7583 dgst_pos0 = 3;
7584 dgst_pos1 = 4;
7585 dgst_pos2 = 2;
7586 dgst_pos3 = 1;
7587 break;
7588
7589 case 131: hash_type = HASH_TYPE_SHA1;
7590 salt_type = SALT_TYPE_EMBEDDED;
7591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7592 opts_type = OPTS_TYPE_PT_GENERATE_BE
7593 | OPTS_TYPE_PT_UNICODE
7594 | OPTS_TYPE_PT_UPPER
7595 | OPTS_TYPE_ST_ADD80
7596 | OPTS_TYPE_ST_ADDBITS15
7597 | OPTS_TYPE_ST_HEX;
7598 kern_type = KERN_TYPE_SHA1_PWUSLT;
7599 dgst_size = DGST_SIZE_4_5;
7600 parse_func = mssql2000_parse_hash;
7601 sort_by_digest = sort_by_digest_4_5;
7602 opti_type = OPTI_TYPE_ZERO_BYTE
7603 | OPTI_TYPE_PRECOMPUTE_INIT
7604 | OPTI_TYPE_PRECOMPUTE_MERKLE
7605 | OPTI_TYPE_EARLY_SKIP
7606 | OPTI_TYPE_NOT_ITERATED
7607 | OPTI_TYPE_APPENDED_SALT
7608 | OPTI_TYPE_RAW_HASH;
7609 dgst_pos0 = 3;
7610 dgst_pos1 = 4;
7611 dgst_pos2 = 2;
7612 dgst_pos3 = 1;
7613 break;
7614
7615 case 132: hash_type = HASH_TYPE_SHA1;
7616 salt_type = SALT_TYPE_EMBEDDED;
7617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7618 opts_type = OPTS_TYPE_PT_GENERATE_BE
7619 | OPTS_TYPE_PT_UNICODE
7620 | OPTS_TYPE_ST_ADD80
7621 | OPTS_TYPE_ST_ADDBITS15
7622 | OPTS_TYPE_ST_HEX;
7623 kern_type = KERN_TYPE_SHA1_PWUSLT;
7624 dgst_size = DGST_SIZE_4_5;
7625 parse_func = mssql2005_parse_hash;
7626 sort_by_digest = sort_by_digest_4_5;
7627 opti_type = OPTI_TYPE_ZERO_BYTE
7628 | OPTI_TYPE_PRECOMPUTE_INIT
7629 | OPTI_TYPE_PRECOMPUTE_MERKLE
7630 | OPTI_TYPE_EARLY_SKIP
7631 | OPTI_TYPE_NOT_ITERATED
7632 | OPTI_TYPE_APPENDED_SALT
7633 | OPTI_TYPE_RAW_HASH;
7634 dgst_pos0 = 3;
7635 dgst_pos1 = 4;
7636 dgst_pos2 = 2;
7637 dgst_pos3 = 1;
7638 break;
7639
7640 case 133: hash_type = HASH_TYPE_SHA1;
7641 salt_type = SALT_TYPE_EMBEDDED;
7642 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7643 opts_type = OPTS_TYPE_PT_GENERATE_BE
7644 | OPTS_TYPE_PT_UNICODE
7645 | OPTS_TYPE_ST_ADD80
7646 | OPTS_TYPE_ST_ADDBITS15;
7647 kern_type = KERN_TYPE_SHA1_PWUSLT;
7648 dgst_size = DGST_SIZE_4_5;
7649 parse_func = peoplesoft_parse_hash;
7650 sort_by_digest = sort_by_digest_4_5;
7651 opti_type = OPTI_TYPE_ZERO_BYTE
7652 | OPTI_TYPE_PRECOMPUTE_INIT
7653 | OPTI_TYPE_PRECOMPUTE_MERKLE
7654 | OPTI_TYPE_EARLY_SKIP
7655 | OPTI_TYPE_NOT_ITERATED
7656 | OPTI_TYPE_APPENDED_SALT
7657 | OPTI_TYPE_RAW_HASH;
7658 dgst_pos0 = 3;
7659 dgst_pos1 = 4;
7660 dgst_pos2 = 2;
7661 dgst_pos3 = 1;
7662 break;
7663
7664 case 140: hash_type = HASH_TYPE_SHA1;
7665 salt_type = SALT_TYPE_INTERN;
7666 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7667 opts_type = OPTS_TYPE_PT_GENERATE_BE
7668 | OPTS_TYPE_PT_ADD80
7669 | OPTS_TYPE_PT_ADDBITS15
7670 | OPTS_TYPE_PT_UNICODE;
7671 kern_type = KERN_TYPE_SHA1_SLTPWU;
7672 dgst_size = DGST_SIZE_4_5;
7673 parse_func = sha1s_parse_hash;
7674 sort_by_digest = sort_by_digest_4_5;
7675 opti_type = OPTI_TYPE_ZERO_BYTE
7676 | OPTI_TYPE_PRECOMPUTE_INIT
7677 | OPTI_TYPE_PRECOMPUTE_MERKLE
7678 | OPTI_TYPE_EARLY_SKIP
7679 | OPTI_TYPE_NOT_ITERATED
7680 | OPTI_TYPE_PREPENDED_SALT
7681 | OPTI_TYPE_RAW_HASH;
7682 dgst_pos0 = 3;
7683 dgst_pos1 = 4;
7684 dgst_pos2 = 2;
7685 dgst_pos3 = 1;
7686 break;
7687
7688 case 141: hash_type = HASH_TYPE_SHA1;
7689 salt_type = SALT_TYPE_EMBEDDED;
7690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7691 opts_type = OPTS_TYPE_PT_GENERATE_BE
7692 | OPTS_TYPE_PT_ADD80
7693 | OPTS_TYPE_PT_ADDBITS15
7694 | OPTS_TYPE_PT_UNICODE
7695 | OPTS_TYPE_ST_BASE64;
7696 kern_type = KERN_TYPE_SHA1_SLTPWU;
7697 dgst_size = DGST_SIZE_4_5;
7698 parse_func = episerver_parse_hash;
7699 sort_by_digest = sort_by_digest_4_5;
7700 opti_type = OPTI_TYPE_ZERO_BYTE
7701 | OPTI_TYPE_PRECOMPUTE_INIT
7702 | OPTI_TYPE_PRECOMPUTE_MERKLE
7703 | OPTI_TYPE_EARLY_SKIP
7704 | OPTI_TYPE_NOT_ITERATED
7705 | OPTI_TYPE_PREPENDED_SALT
7706 | OPTI_TYPE_RAW_HASH;
7707 dgst_pos0 = 3;
7708 dgst_pos1 = 4;
7709 dgst_pos2 = 2;
7710 dgst_pos3 = 1;
7711 break;
7712
7713 case 150: hash_type = HASH_TYPE_SHA1;
7714 salt_type = SALT_TYPE_INTERN;
7715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7716 opts_type = OPTS_TYPE_PT_GENERATE_BE
7717 | OPTS_TYPE_ST_ADD80
7718 | OPTS_TYPE_ST_ADDBITS15;
7719 kern_type = KERN_TYPE_HMACSHA1_PW;
7720 dgst_size = DGST_SIZE_4_5;
7721 parse_func = hmacsha1_parse_hash;
7722 sort_by_digest = sort_by_digest_4_5;
7723 opti_type = OPTI_TYPE_ZERO_BYTE
7724 | OPTI_TYPE_NOT_ITERATED;
7725 dgst_pos0 = 3;
7726 dgst_pos1 = 4;
7727 dgst_pos2 = 2;
7728 dgst_pos3 = 1;
7729 break;
7730
7731 case 160: hash_type = HASH_TYPE_SHA1;
7732 salt_type = SALT_TYPE_INTERN;
7733 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7734 opts_type = OPTS_TYPE_PT_GENERATE_BE
7735 | OPTS_TYPE_PT_ADD80
7736 | OPTS_TYPE_PT_ADDBITS15;
7737 kern_type = KERN_TYPE_HMACSHA1_SLT;
7738 dgst_size = DGST_SIZE_4_5;
7739 parse_func = hmacsha1_parse_hash;
7740 sort_by_digest = sort_by_digest_4_5;
7741 opti_type = OPTI_TYPE_ZERO_BYTE
7742 | OPTI_TYPE_NOT_ITERATED;
7743 dgst_pos0 = 3;
7744 dgst_pos1 = 4;
7745 dgst_pos2 = 2;
7746 dgst_pos3 = 1;
7747 break;
7748
7749 case 190: hash_type = HASH_TYPE_SHA1;
7750 salt_type = SALT_TYPE_NONE;
7751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7752 opts_type = OPTS_TYPE_PT_GENERATE_BE
7753 | OPTS_TYPE_PT_ADD80
7754 | OPTS_TYPE_PT_ADDBITS15;
7755 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7756 dgst_size = DGST_SIZE_4_5;
7757 parse_func = sha1linkedin_parse_hash;
7758 sort_by_digest = sort_by_digest_4_5;
7759 opti_type = OPTI_TYPE_ZERO_BYTE
7760 | OPTI_TYPE_PRECOMPUTE_INIT
7761 | OPTI_TYPE_EARLY_SKIP
7762 | OPTI_TYPE_NOT_ITERATED
7763 | OPTI_TYPE_NOT_SALTED;
7764 dgst_pos0 = 0;
7765 dgst_pos1 = 4;
7766 dgst_pos2 = 3;
7767 dgst_pos3 = 2;
7768 break;
7769
7770 case 200: hash_type = HASH_TYPE_MYSQL;
7771 salt_type = SALT_TYPE_NONE;
7772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7773 opts_type = 0;
7774 kern_type = KERN_TYPE_MYSQL;
7775 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7776 parse_func = mysql323_parse_hash;
7777 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7778 opti_type = OPTI_TYPE_ZERO_BYTE;
7779 dgst_pos0 = 0;
7780 dgst_pos1 = 1;
7781 dgst_pos2 = 2;
7782 dgst_pos3 = 3;
7783 break;
7784
7785 case 300: hash_type = HASH_TYPE_SHA1;
7786 salt_type = SALT_TYPE_NONE;
7787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7788 opts_type = OPTS_TYPE_PT_GENERATE_BE
7789 | OPTS_TYPE_PT_ADD80
7790 | OPTS_TYPE_PT_ADDBITS15;
7791 kern_type = KERN_TYPE_MYSQL41;
7792 dgst_size = DGST_SIZE_4_5;
7793 parse_func = sha1_parse_hash;
7794 sort_by_digest = sort_by_digest_4_5;
7795 opti_type = OPTI_TYPE_ZERO_BYTE
7796 | OPTI_TYPE_PRECOMPUTE_INIT
7797 | OPTI_TYPE_PRECOMPUTE_MERKLE
7798 | OPTI_TYPE_EARLY_SKIP
7799 | OPTI_TYPE_NOT_ITERATED
7800 | OPTI_TYPE_NOT_SALTED;
7801 dgst_pos0 = 3;
7802 dgst_pos1 = 4;
7803 dgst_pos2 = 2;
7804 dgst_pos3 = 1;
7805 break;
7806
7807 case 400: hash_type = HASH_TYPE_MD5;
7808 salt_type = SALT_TYPE_EMBEDDED;
7809 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7810 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7811 kern_type = KERN_TYPE_PHPASS;
7812 dgst_size = DGST_SIZE_4_4;
7813 parse_func = phpass_parse_hash;
7814 sort_by_digest = sort_by_digest_4_4;
7815 opti_type = OPTI_TYPE_ZERO_BYTE
7816 | OPTI_TYPE_SLOW_HASH_SIMD;
7817 dgst_pos0 = 0;
7818 dgst_pos1 = 1;
7819 dgst_pos2 = 2;
7820 dgst_pos3 = 3;
7821 break;
7822
7823 case 500: hash_type = HASH_TYPE_MD5;
7824 salt_type = SALT_TYPE_EMBEDDED;
7825 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7826 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7827 kern_type = KERN_TYPE_MD5CRYPT;
7828 dgst_size = DGST_SIZE_4_4;
7829 parse_func = md5crypt_parse_hash;
7830 sort_by_digest = sort_by_digest_4_4;
7831 opti_type = OPTI_TYPE_ZERO_BYTE;
7832 dgst_pos0 = 0;
7833 dgst_pos1 = 1;
7834 dgst_pos2 = 2;
7835 dgst_pos3 = 3;
7836 break;
7837
7838 case 501: hash_type = HASH_TYPE_MD5;
7839 salt_type = SALT_TYPE_EMBEDDED;
7840 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7841 opts_type = OPTS_TYPE_PT_GENERATE_LE
7842 | OPTS_TYPE_HASH_COPY;
7843 kern_type = KERN_TYPE_MD5CRYPT;
7844 dgst_size = DGST_SIZE_4_4;
7845 parse_func = juniper_parse_hash;
7846 sort_by_digest = sort_by_digest_4_4;
7847 opti_type = OPTI_TYPE_ZERO_BYTE;
7848 dgst_pos0 = 0;
7849 dgst_pos1 = 1;
7850 dgst_pos2 = 2;
7851 dgst_pos3 = 3;
7852 break;
7853
7854 case 900: hash_type = HASH_TYPE_MD4;
7855 salt_type = SALT_TYPE_NONE;
7856 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7857 opts_type = OPTS_TYPE_PT_GENERATE_LE
7858 | OPTS_TYPE_PT_ADD80
7859 | OPTS_TYPE_PT_ADDBITS14;
7860 kern_type = KERN_TYPE_MD4;
7861 dgst_size = DGST_SIZE_4_4;
7862 parse_func = md4_parse_hash;
7863 sort_by_digest = sort_by_digest_4_4;
7864 opti_type = OPTI_TYPE_ZERO_BYTE
7865 | OPTI_TYPE_PRECOMPUTE_INIT
7866 | OPTI_TYPE_PRECOMPUTE_MERKLE
7867 | OPTI_TYPE_MEET_IN_MIDDLE
7868 | OPTI_TYPE_EARLY_SKIP
7869 | OPTI_TYPE_NOT_ITERATED
7870 | OPTI_TYPE_NOT_SALTED
7871 | OPTI_TYPE_RAW_HASH;
7872 dgst_pos0 = 0;
7873 dgst_pos1 = 3;
7874 dgst_pos2 = 2;
7875 dgst_pos3 = 1;
7876 break;
7877
7878 case 1000: hash_type = HASH_TYPE_MD4;
7879 salt_type = SALT_TYPE_NONE;
7880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7881 opts_type = OPTS_TYPE_PT_GENERATE_LE
7882 | OPTS_TYPE_PT_ADD80
7883 | OPTS_TYPE_PT_ADDBITS14
7884 | OPTS_TYPE_PT_UNICODE;
7885 kern_type = KERN_TYPE_MD4_PWU;
7886 dgst_size = DGST_SIZE_4_4;
7887 parse_func = md4_parse_hash;
7888 sort_by_digest = sort_by_digest_4_4;
7889 opti_type = OPTI_TYPE_ZERO_BYTE
7890 | OPTI_TYPE_PRECOMPUTE_INIT
7891 | OPTI_TYPE_PRECOMPUTE_MERKLE
7892 | OPTI_TYPE_MEET_IN_MIDDLE
7893 | OPTI_TYPE_EARLY_SKIP
7894 | OPTI_TYPE_NOT_ITERATED
7895 | OPTI_TYPE_NOT_SALTED
7896 | OPTI_TYPE_RAW_HASH;
7897 dgst_pos0 = 0;
7898 dgst_pos1 = 3;
7899 dgst_pos2 = 2;
7900 dgst_pos3 = 1;
7901 break;
7902
7903 case 1100: hash_type = HASH_TYPE_MD4;
7904 salt_type = SALT_TYPE_INTERN;
7905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7906 opts_type = OPTS_TYPE_PT_GENERATE_LE
7907 | OPTS_TYPE_PT_ADD80
7908 | OPTS_TYPE_PT_ADDBITS14
7909 | OPTS_TYPE_PT_UNICODE
7910 | OPTS_TYPE_ST_ADD80
7911 | OPTS_TYPE_ST_UNICODE
7912 | OPTS_TYPE_ST_LOWER;
7913 kern_type = KERN_TYPE_MD44_PWUSLT;
7914 dgst_size = DGST_SIZE_4_4;
7915 parse_func = dcc_parse_hash;
7916 sort_by_digest = sort_by_digest_4_4;
7917 opti_type = OPTI_TYPE_ZERO_BYTE
7918 | OPTI_TYPE_PRECOMPUTE_INIT
7919 | OPTI_TYPE_PRECOMPUTE_MERKLE
7920 | OPTI_TYPE_EARLY_SKIP
7921 | OPTI_TYPE_NOT_ITERATED;
7922 dgst_pos0 = 0;
7923 dgst_pos1 = 3;
7924 dgst_pos2 = 2;
7925 dgst_pos3 = 1;
7926 break;
7927
7928 case 1400: hash_type = HASH_TYPE_SHA256;
7929 salt_type = SALT_TYPE_NONE;
7930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7931 opts_type = OPTS_TYPE_PT_GENERATE_BE
7932 | OPTS_TYPE_PT_ADD80
7933 | OPTS_TYPE_PT_ADDBITS15;
7934 kern_type = KERN_TYPE_SHA256;
7935 dgst_size = DGST_SIZE_4_8;
7936 parse_func = sha256_parse_hash;
7937 sort_by_digest = sort_by_digest_4_8;
7938 opti_type = OPTI_TYPE_ZERO_BYTE
7939 | OPTI_TYPE_PRECOMPUTE_INIT
7940 | OPTI_TYPE_PRECOMPUTE_MERKLE
7941 | OPTI_TYPE_EARLY_SKIP
7942 | OPTI_TYPE_NOT_ITERATED
7943 | OPTI_TYPE_NOT_SALTED
7944 | OPTI_TYPE_RAW_HASH;
7945 dgst_pos0 = 3;
7946 dgst_pos1 = 7;
7947 dgst_pos2 = 2;
7948 dgst_pos3 = 6;
7949 break;
7950
7951 case 1410: hash_type = HASH_TYPE_SHA256;
7952 salt_type = SALT_TYPE_INTERN;
7953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7954 opts_type = OPTS_TYPE_PT_GENERATE_BE
7955 | OPTS_TYPE_ST_ADD80
7956 | OPTS_TYPE_ST_ADDBITS15;
7957 kern_type = KERN_TYPE_SHA256_PWSLT;
7958 dgst_size = DGST_SIZE_4_8;
7959 parse_func = sha256s_parse_hash;
7960 sort_by_digest = sort_by_digest_4_8;
7961 opti_type = OPTI_TYPE_ZERO_BYTE
7962 | OPTI_TYPE_PRECOMPUTE_INIT
7963 | OPTI_TYPE_PRECOMPUTE_MERKLE
7964 | OPTI_TYPE_EARLY_SKIP
7965 | OPTI_TYPE_NOT_ITERATED
7966 | OPTI_TYPE_APPENDED_SALT
7967 | OPTI_TYPE_RAW_HASH;
7968 dgst_pos0 = 3;
7969 dgst_pos1 = 7;
7970 dgst_pos2 = 2;
7971 dgst_pos3 = 6;
7972 break;
7973
7974 case 1420: hash_type = HASH_TYPE_SHA256;
7975 salt_type = SALT_TYPE_INTERN;
7976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7977 opts_type = OPTS_TYPE_PT_GENERATE_BE
7978 | OPTS_TYPE_PT_ADD80
7979 | OPTS_TYPE_PT_ADDBITS15;
7980 kern_type = KERN_TYPE_SHA256_SLTPW;
7981 dgst_size = DGST_SIZE_4_8;
7982 parse_func = sha256s_parse_hash;
7983 sort_by_digest = sort_by_digest_4_8;
7984 opti_type = OPTI_TYPE_ZERO_BYTE
7985 | OPTI_TYPE_PRECOMPUTE_INIT
7986 | OPTI_TYPE_PRECOMPUTE_MERKLE
7987 | OPTI_TYPE_EARLY_SKIP
7988 | OPTI_TYPE_NOT_ITERATED
7989 | OPTI_TYPE_PREPENDED_SALT
7990 | OPTI_TYPE_RAW_HASH;
7991 dgst_pos0 = 3;
7992 dgst_pos1 = 7;
7993 dgst_pos2 = 2;
7994 dgst_pos3 = 6;
7995 break;
7996
7997 case 1421: hash_type = HASH_TYPE_SHA256;
7998 salt_type = SALT_TYPE_EMBEDDED;
7999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8000 opts_type = OPTS_TYPE_PT_GENERATE_BE
8001 | OPTS_TYPE_PT_ADD80
8002 | OPTS_TYPE_PT_ADDBITS15;
8003 kern_type = KERN_TYPE_SHA256_SLTPW;
8004 dgst_size = DGST_SIZE_4_8;
8005 parse_func = hmailserver_parse_hash;
8006 sort_by_digest = sort_by_digest_4_8;
8007 opti_type = OPTI_TYPE_ZERO_BYTE
8008 | OPTI_TYPE_PRECOMPUTE_INIT
8009 | OPTI_TYPE_PRECOMPUTE_MERKLE
8010 | OPTI_TYPE_EARLY_SKIP
8011 | OPTI_TYPE_NOT_ITERATED
8012 | OPTI_TYPE_PREPENDED_SALT
8013 | OPTI_TYPE_RAW_HASH;
8014 dgst_pos0 = 3;
8015 dgst_pos1 = 7;
8016 dgst_pos2 = 2;
8017 dgst_pos3 = 6;
8018 break;
8019
8020 case 1430: hash_type = HASH_TYPE_SHA256;
8021 salt_type = SALT_TYPE_INTERN;
8022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8023 opts_type = OPTS_TYPE_PT_GENERATE_BE
8024 | OPTS_TYPE_PT_UNICODE
8025 | OPTS_TYPE_ST_ADD80
8026 | OPTS_TYPE_ST_ADDBITS15;
8027 kern_type = KERN_TYPE_SHA256_PWUSLT;
8028 dgst_size = DGST_SIZE_4_8;
8029 parse_func = sha256s_parse_hash;
8030 sort_by_digest = sort_by_digest_4_8;
8031 opti_type = OPTI_TYPE_ZERO_BYTE
8032 | OPTI_TYPE_PRECOMPUTE_INIT
8033 | OPTI_TYPE_PRECOMPUTE_MERKLE
8034 | OPTI_TYPE_EARLY_SKIP
8035 | OPTI_TYPE_NOT_ITERATED
8036 | OPTI_TYPE_APPENDED_SALT
8037 | OPTI_TYPE_RAW_HASH;
8038 dgst_pos0 = 3;
8039 dgst_pos1 = 7;
8040 dgst_pos2 = 2;
8041 dgst_pos3 = 6;
8042 break;
8043
8044 case 1440: hash_type = HASH_TYPE_SHA256;
8045 salt_type = SALT_TYPE_INTERN;
8046 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8047 opts_type = OPTS_TYPE_PT_GENERATE_BE
8048 | OPTS_TYPE_PT_ADD80
8049 | OPTS_TYPE_PT_ADDBITS15
8050 | OPTS_TYPE_PT_UNICODE;
8051 kern_type = KERN_TYPE_SHA256_SLTPWU;
8052 dgst_size = DGST_SIZE_4_8;
8053 parse_func = sha256s_parse_hash;
8054 sort_by_digest = sort_by_digest_4_8;
8055 opti_type = OPTI_TYPE_ZERO_BYTE
8056 | OPTI_TYPE_PRECOMPUTE_INIT
8057 | OPTI_TYPE_PRECOMPUTE_MERKLE
8058 | OPTI_TYPE_EARLY_SKIP
8059 | OPTI_TYPE_NOT_ITERATED
8060 | OPTI_TYPE_PREPENDED_SALT
8061 | OPTI_TYPE_RAW_HASH;
8062 dgst_pos0 = 3;
8063 dgst_pos1 = 7;
8064 dgst_pos2 = 2;
8065 dgst_pos3 = 6;
8066 break;
8067
8068 case 1441: hash_type = HASH_TYPE_SHA256;
8069 salt_type = SALT_TYPE_EMBEDDED;
8070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8071 opts_type = OPTS_TYPE_PT_GENERATE_BE
8072 | OPTS_TYPE_PT_ADD80
8073 | OPTS_TYPE_PT_ADDBITS15
8074 | OPTS_TYPE_PT_UNICODE
8075 | OPTS_TYPE_ST_BASE64;
8076 kern_type = KERN_TYPE_SHA256_SLTPWU;
8077 dgst_size = DGST_SIZE_4_8;
8078 parse_func = episerver4_parse_hash;
8079 sort_by_digest = sort_by_digest_4_8;
8080 opti_type = OPTI_TYPE_ZERO_BYTE
8081 | OPTI_TYPE_PRECOMPUTE_INIT
8082 | OPTI_TYPE_PRECOMPUTE_MERKLE
8083 | OPTI_TYPE_EARLY_SKIP
8084 | OPTI_TYPE_NOT_ITERATED
8085 | OPTI_TYPE_PREPENDED_SALT
8086 | OPTI_TYPE_RAW_HASH;
8087 dgst_pos0 = 3;
8088 dgst_pos1 = 7;
8089 dgst_pos2 = 2;
8090 dgst_pos3 = 6;
8091 break;
8092
8093 case 1450: hash_type = HASH_TYPE_SHA256;
8094 salt_type = SALT_TYPE_INTERN;
8095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8096 opts_type = OPTS_TYPE_PT_GENERATE_BE
8097 | OPTS_TYPE_ST_ADD80;
8098 kern_type = KERN_TYPE_HMACSHA256_PW;
8099 dgst_size = DGST_SIZE_4_8;
8100 parse_func = hmacsha256_parse_hash;
8101 sort_by_digest = sort_by_digest_4_8;
8102 opti_type = OPTI_TYPE_ZERO_BYTE
8103 | OPTI_TYPE_NOT_ITERATED;
8104 dgst_pos0 = 3;
8105 dgst_pos1 = 7;
8106 dgst_pos2 = 2;
8107 dgst_pos3 = 6;
8108 break;
8109
8110 case 1460: hash_type = HASH_TYPE_SHA256;
8111 salt_type = SALT_TYPE_INTERN;
8112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8113 opts_type = OPTS_TYPE_PT_GENERATE_BE
8114 | OPTS_TYPE_PT_ADD80
8115 | OPTS_TYPE_PT_ADDBITS15;
8116 kern_type = KERN_TYPE_HMACSHA256_SLT;
8117 dgst_size = DGST_SIZE_4_8;
8118 parse_func = hmacsha256_parse_hash;
8119 sort_by_digest = sort_by_digest_4_8;
8120 opti_type = OPTI_TYPE_ZERO_BYTE
8121 | OPTI_TYPE_NOT_ITERATED;
8122 dgst_pos0 = 3;
8123 dgst_pos1 = 7;
8124 dgst_pos2 = 2;
8125 dgst_pos3 = 6;
8126 break;
8127
8128 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8129 salt_type = SALT_TYPE_EMBEDDED;
8130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8131 opts_type = OPTS_TYPE_PT_GENERATE_LE
8132 | OPTS_TYPE_PT_BITSLICE;
8133 kern_type = KERN_TYPE_DESCRYPT;
8134 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8135 parse_func = descrypt_parse_hash;
8136 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8137 opti_type = OPTI_TYPE_ZERO_BYTE
8138 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8139 dgst_pos0 = 0;
8140 dgst_pos1 = 1;
8141 dgst_pos2 = 2;
8142 dgst_pos3 = 3;
8143 break;
8144
8145 case 1600: hash_type = HASH_TYPE_MD5;
8146 salt_type = SALT_TYPE_EMBEDDED;
8147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8148 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8149 kern_type = KERN_TYPE_APR1CRYPT;
8150 dgst_size = DGST_SIZE_4_4;
8151 parse_func = md5apr1_parse_hash;
8152 sort_by_digest = sort_by_digest_4_4;
8153 opti_type = OPTI_TYPE_ZERO_BYTE;
8154 dgst_pos0 = 0;
8155 dgst_pos1 = 1;
8156 dgst_pos2 = 2;
8157 dgst_pos3 = 3;
8158 break;
8159
8160 case 1700: hash_type = HASH_TYPE_SHA512;
8161 salt_type = SALT_TYPE_NONE;
8162 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8163 opts_type = OPTS_TYPE_PT_GENERATE_BE
8164 | OPTS_TYPE_PT_ADD80
8165 | OPTS_TYPE_PT_ADDBITS15;
8166 kern_type = KERN_TYPE_SHA512;
8167 dgst_size = DGST_SIZE_8_8;
8168 parse_func = sha512_parse_hash;
8169 sort_by_digest = sort_by_digest_8_8;
8170 opti_type = OPTI_TYPE_ZERO_BYTE
8171 | OPTI_TYPE_PRECOMPUTE_INIT
8172 | OPTI_TYPE_PRECOMPUTE_MERKLE
8173 | OPTI_TYPE_EARLY_SKIP
8174 | OPTI_TYPE_NOT_ITERATED
8175 | OPTI_TYPE_NOT_SALTED
8176 | OPTI_TYPE_USES_BITS_64
8177 | OPTI_TYPE_RAW_HASH;
8178 dgst_pos0 = 14;
8179 dgst_pos1 = 15;
8180 dgst_pos2 = 6;
8181 dgst_pos3 = 7;
8182 break;
8183
8184 case 1710: hash_type = HASH_TYPE_SHA512;
8185 salt_type = SALT_TYPE_INTERN;
8186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8187 opts_type = OPTS_TYPE_PT_GENERATE_BE
8188 | OPTS_TYPE_ST_ADD80
8189 | OPTS_TYPE_ST_ADDBITS15;
8190 kern_type = KERN_TYPE_SHA512_PWSLT;
8191 dgst_size = DGST_SIZE_8_8;
8192 parse_func = sha512s_parse_hash;
8193 sort_by_digest = sort_by_digest_8_8;
8194 opti_type = OPTI_TYPE_ZERO_BYTE
8195 | OPTI_TYPE_PRECOMPUTE_INIT
8196 | OPTI_TYPE_PRECOMPUTE_MERKLE
8197 | OPTI_TYPE_EARLY_SKIP
8198 | OPTI_TYPE_NOT_ITERATED
8199 | OPTI_TYPE_APPENDED_SALT
8200 | OPTI_TYPE_USES_BITS_64
8201 | OPTI_TYPE_RAW_HASH;
8202 dgst_pos0 = 14;
8203 dgst_pos1 = 15;
8204 dgst_pos2 = 6;
8205 dgst_pos3 = 7;
8206 break;
8207
8208 case 1711: hash_type = HASH_TYPE_SHA512;
8209 salt_type = SALT_TYPE_EMBEDDED;
8210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8211 opts_type = OPTS_TYPE_PT_GENERATE_BE
8212 | OPTS_TYPE_ST_ADD80
8213 | OPTS_TYPE_ST_ADDBITS15;
8214 kern_type = KERN_TYPE_SHA512_PWSLT;
8215 dgst_size = DGST_SIZE_8_8;
8216 parse_func = sha512b64s_parse_hash;
8217 sort_by_digest = sort_by_digest_8_8;
8218 opti_type = OPTI_TYPE_ZERO_BYTE
8219 | OPTI_TYPE_PRECOMPUTE_INIT
8220 | OPTI_TYPE_PRECOMPUTE_MERKLE
8221 | OPTI_TYPE_EARLY_SKIP
8222 | OPTI_TYPE_NOT_ITERATED
8223 | OPTI_TYPE_APPENDED_SALT
8224 | OPTI_TYPE_USES_BITS_64
8225 | OPTI_TYPE_RAW_HASH;
8226 dgst_pos0 = 14;
8227 dgst_pos1 = 15;
8228 dgst_pos2 = 6;
8229 dgst_pos3 = 7;
8230 break;
8231
8232 case 1720: hash_type = HASH_TYPE_SHA512;
8233 salt_type = SALT_TYPE_INTERN;
8234 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8235 opts_type = OPTS_TYPE_PT_GENERATE_BE
8236 | OPTS_TYPE_PT_ADD80
8237 | OPTS_TYPE_PT_ADDBITS15;
8238 kern_type = KERN_TYPE_SHA512_SLTPW;
8239 dgst_size = DGST_SIZE_8_8;
8240 parse_func = sha512s_parse_hash;
8241 sort_by_digest = sort_by_digest_8_8;
8242 opti_type = OPTI_TYPE_ZERO_BYTE
8243 | OPTI_TYPE_PRECOMPUTE_INIT
8244 | OPTI_TYPE_PRECOMPUTE_MERKLE
8245 | OPTI_TYPE_EARLY_SKIP
8246 | OPTI_TYPE_NOT_ITERATED
8247 | OPTI_TYPE_PREPENDED_SALT
8248 | OPTI_TYPE_USES_BITS_64
8249 | OPTI_TYPE_RAW_HASH;
8250 dgst_pos0 = 14;
8251 dgst_pos1 = 15;
8252 dgst_pos2 = 6;
8253 dgst_pos3 = 7;
8254 break;
8255
8256 case 1722: hash_type = HASH_TYPE_SHA512;
8257 salt_type = SALT_TYPE_EMBEDDED;
8258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8259 opts_type = OPTS_TYPE_PT_GENERATE_BE
8260 | OPTS_TYPE_PT_ADD80
8261 | OPTS_TYPE_PT_ADDBITS15
8262 | OPTS_TYPE_ST_HEX;
8263 kern_type = KERN_TYPE_SHA512_SLTPW;
8264 dgst_size = DGST_SIZE_8_8;
8265 parse_func = osx512_parse_hash;
8266 sort_by_digest = sort_by_digest_8_8;
8267 opti_type = OPTI_TYPE_ZERO_BYTE
8268 | OPTI_TYPE_PRECOMPUTE_INIT
8269 | OPTI_TYPE_PRECOMPUTE_MERKLE
8270 | OPTI_TYPE_EARLY_SKIP
8271 | OPTI_TYPE_NOT_ITERATED
8272 | OPTI_TYPE_PREPENDED_SALT
8273 | OPTI_TYPE_USES_BITS_64
8274 | OPTI_TYPE_RAW_HASH;
8275 dgst_pos0 = 14;
8276 dgst_pos1 = 15;
8277 dgst_pos2 = 6;
8278 dgst_pos3 = 7;
8279 break;
8280
8281 case 1730: hash_type = HASH_TYPE_SHA512;
8282 salt_type = SALT_TYPE_INTERN;
8283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8284 opts_type = OPTS_TYPE_PT_GENERATE_BE
8285 | OPTS_TYPE_PT_UNICODE
8286 | OPTS_TYPE_ST_ADD80
8287 | OPTS_TYPE_ST_ADDBITS15;
8288 kern_type = KERN_TYPE_SHA512_PWSLTU;
8289 dgst_size = DGST_SIZE_8_8;
8290 parse_func = sha512s_parse_hash;
8291 sort_by_digest = sort_by_digest_8_8;
8292 opti_type = OPTI_TYPE_ZERO_BYTE
8293 | OPTI_TYPE_PRECOMPUTE_INIT
8294 | OPTI_TYPE_PRECOMPUTE_MERKLE
8295 | OPTI_TYPE_EARLY_SKIP
8296 | OPTI_TYPE_NOT_ITERATED
8297 | OPTI_TYPE_APPENDED_SALT
8298 | OPTI_TYPE_USES_BITS_64
8299 | OPTI_TYPE_RAW_HASH;
8300 dgst_pos0 = 14;
8301 dgst_pos1 = 15;
8302 dgst_pos2 = 6;
8303 dgst_pos3 = 7;
8304 break;
8305
8306 case 1731: hash_type = HASH_TYPE_SHA512;
8307 salt_type = SALT_TYPE_EMBEDDED;
8308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8309 opts_type = OPTS_TYPE_PT_GENERATE_BE
8310 | OPTS_TYPE_PT_UNICODE
8311 | OPTS_TYPE_ST_ADD80
8312 | OPTS_TYPE_ST_ADDBITS15
8313 | OPTS_TYPE_ST_HEX;
8314 kern_type = KERN_TYPE_SHA512_PWSLTU;
8315 dgst_size = DGST_SIZE_8_8;
8316 parse_func = mssql2012_parse_hash;
8317 sort_by_digest = sort_by_digest_8_8;
8318 opti_type = OPTI_TYPE_ZERO_BYTE
8319 | OPTI_TYPE_PRECOMPUTE_INIT
8320 | OPTI_TYPE_PRECOMPUTE_MERKLE
8321 | OPTI_TYPE_EARLY_SKIP
8322 | OPTI_TYPE_NOT_ITERATED
8323 | OPTI_TYPE_APPENDED_SALT
8324 | OPTI_TYPE_USES_BITS_64
8325 | OPTI_TYPE_RAW_HASH;
8326 dgst_pos0 = 14;
8327 dgst_pos1 = 15;
8328 dgst_pos2 = 6;
8329 dgst_pos3 = 7;
8330 break;
8331
8332 case 1740: hash_type = HASH_TYPE_SHA512;
8333 salt_type = SALT_TYPE_INTERN;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_BE
8336 | OPTS_TYPE_PT_ADD80
8337 | OPTS_TYPE_PT_ADDBITS15
8338 | OPTS_TYPE_PT_UNICODE;
8339 kern_type = KERN_TYPE_SHA512_SLTPWU;
8340 dgst_size = DGST_SIZE_8_8;
8341 parse_func = sha512s_parse_hash;
8342 sort_by_digest = sort_by_digest_8_8;
8343 opti_type = OPTI_TYPE_ZERO_BYTE
8344 | OPTI_TYPE_PRECOMPUTE_INIT
8345 | OPTI_TYPE_PRECOMPUTE_MERKLE
8346 | OPTI_TYPE_EARLY_SKIP
8347 | OPTI_TYPE_NOT_ITERATED
8348 | OPTI_TYPE_PREPENDED_SALT
8349 | OPTI_TYPE_USES_BITS_64
8350 | OPTI_TYPE_RAW_HASH;
8351 dgst_pos0 = 14;
8352 dgst_pos1 = 15;
8353 dgst_pos2 = 6;
8354 dgst_pos3 = 7;
8355 break;
8356
8357 case 1750: hash_type = HASH_TYPE_SHA512;
8358 salt_type = SALT_TYPE_INTERN;
8359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8360 opts_type = OPTS_TYPE_PT_GENERATE_BE
8361 | OPTS_TYPE_ST_ADD80;
8362 kern_type = KERN_TYPE_HMACSHA512_PW;
8363 dgst_size = DGST_SIZE_8_8;
8364 parse_func = hmacsha512_parse_hash;
8365 sort_by_digest = sort_by_digest_8_8;
8366 opti_type = OPTI_TYPE_ZERO_BYTE
8367 | OPTI_TYPE_USES_BITS_64
8368 | OPTI_TYPE_NOT_ITERATED;
8369 dgst_pos0 = 14;
8370 dgst_pos1 = 15;
8371 dgst_pos2 = 6;
8372 dgst_pos3 = 7;
8373 break;
8374
8375 case 1760: hash_type = HASH_TYPE_SHA512;
8376 salt_type = SALT_TYPE_INTERN;
8377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8378 opts_type = OPTS_TYPE_PT_GENERATE_BE
8379 | OPTS_TYPE_PT_ADD80
8380 | OPTS_TYPE_PT_ADDBITS15;
8381 kern_type = KERN_TYPE_HMACSHA512_SLT;
8382 dgst_size = DGST_SIZE_8_8;
8383 parse_func = hmacsha512_parse_hash;
8384 sort_by_digest = sort_by_digest_8_8;
8385 opti_type = OPTI_TYPE_ZERO_BYTE
8386 | OPTI_TYPE_USES_BITS_64
8387 | OPTI_TYPE_NOT_ITERATED;
8388 dgst_pos0 = 14;
8389 dgst_pos1 = 15;
8390 dgst_pos2 = 6;
8391 dgst_pos3 = 7;
8392 break;
8393
8394 case 1800: hash_type = HASH_TYPE_SHA512;
8395 salt_type = SALT_TYPE_EMBEDDED;
8396 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8397 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8398 kern_type = KERN_TYPE_SHA512CRYPT;
8399 dgst_size = DGST_SIZE_8_8;
8400 parse_func = sha512crypt_parse_hash;
8401 sort_by_digest = sort_by_digest_8_8;
8402 opti_type = OPTI_TYPE_ZERO_BYTE
8403 | OPTI_TYPE_USES_BITS_64;
8404 dgst_pos0 = 0;
8405 dgst_pos1 = 1;
8406 dgst_pos2 = 2;
8407 dgst_pos3 = 3;
8408 break;
8409
8410 case 2100: hash_type = HASH_TYPE_DCC2;
8411 salt_type = SALT_TYPE_EMBEDDED;
8412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8413 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8414 | OPTS_TYPE_ST_LOWER
8415 | OPTS_TYPE_ST_UNICODE;
8416 kern_type = KERN_TYPE_DCC2;
8417 dgst_size = DGST_SIZE_4_4;
8418 parse_func = dcc2_parse_hash;
8419 sort_by_digest = sort_by_digest_4_4;
8420 opti_type = OPTI_TYPE_ZERO_BYTE
8421 | OPTI_TYPE_SLOW_HASH_SIMD;
8422 dgst_pos0 = 0;
8423 dgst_pos1 = 1;
8424 dgst_pos2 = 2;
8425 dgst_pos3 = 3;
8426 break;
8427
8428 case 2400: hash_type = HASH_TYPE_MD5;
8429 salt_type = SALT_TYPE_NONE;
8430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8431 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8432 kern_type = KERN_TYPE_MD5PIX;
8433 dgst_size = DGST_SIZE_4_4;
8434 parse_func = md5pix_parse_hash;
8435 sort_by_digest = sort_by_digest_4_4;
8436 opti_type = OPTI_TYPE_ZERO_BYTE
8437 | OPTI_TYPE_PRECOMPUTE_INIT
8438 | OPTI_TYPE_PRECOMPUTE_MERKLE
8439 | OPTI_TYPE_EARLY_SKIP
8440 | OPTI_TYPE_NOT_ITERATED
8441 | OPTI_TYPE_NOT_SALTED;
8442 dgst_pos0 = 0;
8443 dgst_pos1 = 3;
8444 dgst_pos2 = 2;
8445 dgst_pos3 = 1;
8446 break;
8447
8448 case 2410: hash_type = HASH_TYPE_MD5;
8449 salt_type = SALT_TYPE_INTERN;
8450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8451 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8452 kern_type = KERN_TYPE_MD5ASA;
8453 dgst_size = DGST_SIZE_4_4;
8454 parse_func = md5asa_parse_hash;
8455 sort_by_digest = sort_by_digest_4_4;
8456 opti_type = OPTI_TYPE_ZERO_BYTE
8457 | OPTI_TYPE_PRECOMPUTE_INIT
8458 | OPTI_TYPE_PRECOMPUTE_MERKLE
8459 | OPTI_TYPE_EARLY_SKIP
8460 | OPTI_TYPE_NOT_ITERATED;
8461 dgst_pos0 = 0;
8462 dgst_pos1 = 3;
8463 dgst_pos2 = 2;
8464 dgst_pos3 = 1;
8465 break;
8466
8467 case 2500: hash_type = HASH_TYPE_WPA;
8468 salt_type = SALT_TYPE_EMBEDDED;
8469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8470 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8471 kern_type = KERN_TYPE_WPA;
8472 dgst_size = DGST_SIZE_4_4;
8473 parse_func = wpa_parse_hash;
8474 sort_by_digest = sort_by_digest_4_4;
8475 opti_type = OPTI_TYPE_ZERO_BYTE
8476 | OPTI_TYPE_SLOW_HASH_SIMD;
8477 dgst_pos0 = 0;
8478 dgst_pos1 = 1;
8479 dgst_pos2 = 2;
8480 dgst_pos3 = 3;
8481 break;
8482
8483 case 2600: hash_type = HASH_TYPE_MD5;
8484 salt_type = SALT_TYPE_VIRTUAL;
8485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8486 opts_type = OPTS_TYPE_PT_GENERATE_LE
8487 | OPTS_TYPE_PT_ADD80
8488 | OPTS_TYPE_PT_ADDBITS14
8489 | OPTS_TYPE_ST_ADD80;
8490 kern_type = KERN_TYPE_MD55_PWSLT1;
8491 dgst_size = DGST_SIZE_4_4;
8492 parse_func = md5md5_parse_hash;
8493 sort_by_digest = sort_by_digest_4_4;
8494 opti_type = OPTI_TYPE_ZERO_BYTE
8495 | OPTI_TYPE_PRECOMPUTE_INIT
8496 | OPTI_TYPE_PRECOMPUTE_MERKLE
8497 | OPTI_TYPE_EARLY_SKIP;
8498 dgst_pos0 = 0;
8499 dgst_pos1 = 3;
8500 dgst_pos2 = 2;
8501 dgst_pos3 = 1;
8502 break;
8503
8504 case 2611: hash_type = HASH_TYPE_MD5;
8505 salt_type = SALT_TYPE_INTERN;
8506 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8507 opts_type = OPTS_TYPE_PT_GENERATE_LE
8508 | OPTS_TYPE_PT_ADD80
8509 | OPTS_TYPE_PT_ADDBITS14
8510 | OPTS_TYPE_ST_ADD80;
8511 kern_type = KERN_TYPE_MD55_PWSLT1;
8512 dgst_size = DGST_SIZE_4_4;
8513 parse_func = vb3_parse_hash;
8514 sort_by_digest = sort_by_digest_4_4;
8515 opti_type = OPTI_TYPE_ZERO_BYTE
8516 | OPTI_TYPE_PRECOMPUTE_INIT
8517 | OPTI_TYPE_PRECOMPUTE_MERKLE
8518 | OPTI_TYPE_EARLY_SKIP;
8519 dgst_pos0 = 0;
8520 dgst_pos1 = 3;
8521 dgst_pos2 = 2;
8522 dgst_pos3 = 1;
8523 break;
8524
8525 case 2612: hash_type = HASH_TYPE_MD5;
8526 salt_type = SALT_TYPE_EMBEDDED;
8527 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8528 opts_type = OPTS_TYPE_PT_GENERATE_LE
8529 | OPTS_TYPE_PT_ADD80
8530 | OPTS_TYPE_PT_ADDBITS14
8531 | OPTS_TYPE_ST_ADD80
8532 | OPTS_TYPE_ST_HEX;
8533 kern_type = KERN_TYPE_MD55_PWSLT1;
8534 dgst_size = DGST_SIZE_4_4;
8535 parse_func = phps_parse_hash;
8536 sort_by_digest = sort_by_digest_4_4;
8537 opti_type = OPTI_TYPE_ZERO_BYTE
8538 | OPTI_TYPE_PRECOMPUTE_INIT
8539 | OPTI_TYPE_PRECOMPUTE_MERKLE
8540 | OPTI_TYPE_EARLY_SKIP;
8541 dgst_pos0 = 0;
8542 dgst_pos1 = 3;
8543 dgst_pos2 = 2;
8544 dgst_pos3 = 1;
8545 break;
8546
8547 case 2711: hash_type = HASH_TYPE_MD5;
8548 salt_type = SALT_TYPE_INTERN;
8549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8550 opts_type = OPTS_TYPE_PT_GENERATE_LE
8551 | OPTS_TYPE_PT_ADD80
8552 | OPTS_TYPE_PT_ADDBITS14
8553 | OPTS_TYPE_ST_ADD80;
8554 kern_type = KERN_TYPE_MD55_PWSLT2;
8555 dgst_size = DGST_SIZE_4_4;
8556 parse_func = vb30_parse_hash;
8557 sort_by_digest = sort_by_digest_4_4;
8558 opti_type = OPTI_TYPE_ZERO_BYTE
8559 | OPTI_TYPE_PRECOMPUTE_INIT
8560 | OPTI_TYPE_EARLY_SKIP;
8561 dgst_pos0 = 0;
8562 dgst_pos1 = 3;
8563 dgst_pos2 = 2;
8564 dgst_pos3 = 1;
8565 break;
8566
8567 case 2811: hash_type = HASH_TYPE_MD5;
8568 salt_type = SALT_TYPE_INTERN;
8569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8570 opts_type = OPTS_TYPE_PT_GENERATE_LE
8571 | OPTS_TYPE_PT_ADD80
8572 | OPTS_TYPE_PT_ADDBITS14;
8573 kern_type = KERN_TYPE_MD55_SLTPW;
8574 dgst_size = DGST_SIZE_4_4;
8575 parse_func = ipb2_parse_hash;
8576 sort_by_digest = sort_by_digest_4_4;
8577 opti_type = OPTI_TYPE_ZERO_BYTE
8578 | OPTI_TYPE_PRECOMPUTE_INIT
8579 | OPTI_TYPE_EARLY_SKIP;
8580 dgst_pos0 = 0;
8581 dgst_pos1 = 3;
8582 dgst_pos2 = 2;
8583 dgst_pos3 = 1;
8584 break;
8585
8586 case 3000: hash_type = HASH_TYPE_LM;
8587 salt_type = SALT_TYPE_NONE;
8588 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8589 opts_type = OPTS_TYPE_PT_GENERATE_LE
8590 | OPTS_TYPE_PT_UPPER
8591 | OPTS_TYPE_PT_BITSLICE;
8592 kern_type = KERN_TYPE_LM;
8593 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8594 parse_func = lm_parse_hash;
8595 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8596 opti_type = OPTI_TYPE_ZERO_BYTE
8597 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8598 dgst_pos0 = 0;
8599 dgst_pos1 = 1;
8600 dgst_pos2 = 2;
8601 dgst_pos3 = 3;
8602 break;
8603
8604 case 3100: hash_type = HASH_TYPE_ORACLEH;
8605 salt_type = SALT_TYPE_INTERN;
8606 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8607 opts_type = OPTS_TYPE_PT_GENERATE_LE
8608 | OPTS_TYPE_PT_UPPER
8609 | OPTS_TYPE_ST_UPPER;
8610 kern_type = KERN_TYPE_ORACLEH;
8611 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8612 parse_func = oracleh_parse_hash;
8613 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8614 opti_type = OPTI_TYPE_ZERO_BYTE;
8615 dgst_pos0 = 0;
8616 dgst_pos1 = 1;
8617 dgst_pos2 = 2;
8618 dgst_pos3 = 3;
8619 break;
8620
8621 case 3200: hash_type = HASH_TYPE_BCRYPT;
8622 salt_type = SALT_TYPE_EMBEDDED;
8623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8624 opts_type = OPTS_TYPE_PT_GENERATE_LE
8625 | OPTS_TYPE_ST_GENERATE_LE;
8626 kern_type = KERN_TYPE_BCRYPT;
8627 dgst_size = DGST_SIZE_4_6;
8628 parse_func = bcrypt_parse_hash;
8629 sort_by_digest = sort_by_digest_4_6;
8630 opti_type = OPTI_TYPE_ZERO_BYTE;
8631 dgst_pos0 = 0;
8632 dgst_pos1 = 1;
8633 dgst_pos2 = 2;
8634 dgst_pos3 = 3;
8635 break;
8636
8637 case 3710: hash_type = HASH_TYPE_MD5;
8638 salt_type = SALT_TYPE_INTERN;
8639 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8640 opts_type = OPTS_TYPE_PT_GENERATE_LE
8641 | OPTS_TYPE_PT_ADD80
8642 | OPTS_TYPE_PT_ADDBITS14;
8643 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8644 dgst_size = DGST_SIZE_4_4;
8645 parse_func = md5s_parse_hash;
8646 sort_by_digest = sort_by_digest_4_4;
8647 opti_type = OPTI_TYPE_ZERO_BYTE
8648 | OPTI_TYPE_PRECOMPUTE_INIT
8649 | OPTI_TYPE_PRECOMPUTE_MERKLE
8650 | OPTI_TYPE_EARLY_SKIP;
8651 dgst_pos0 = 0;
8652 dgst_pos1 = 3;
8653 dgst_pos2 = 2;
8654 dgst_pos3 = 1;
8655 break;
8656
8657 case 3711: hash_type = HASH_TYPE_MD5;
8658 salt_type = SALT_TYPE_EMBEDDED;
8659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8660 opts_type = OPTS_TYPE_PT_GENERATE_LE
8661 | OPTS_TYPE_PT_ADD80
8662 | OPTS_TYPE_PT_ADDBITS14;
8663 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8664 dgst_size = DGST_SIZE_4_4;
8665 parse_func = mediawiki_b_parse_hash;
8666 sort_by_digest = sort_by_digest_4_4;
8667 opti_type = OPTI_TYPE_ZERO_BYTE
8668 | OPTI_TYPE_PRECOMPUTE_INIT
8669 | OPTI_TYPE_PRECOMPUTE_MERKLE
8670 | OPTI_TYPE_EARLY_SKIP;
8671 dgst_pos0 = 0;
8672 dgst_pos1 = 3;
8673 dgst_pos2 = 2;
8674 dgst_pos3 = 1;
8675 break;
8676
8677 case 3800: hash_type = HASH_TYPE_MD5;
8678 salt_type = SALT_TYPE_INTERN;
8679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8680 opts_type = OPTS_TYPE_PT_GENERATE_LE
8681 | OPTS_TYPE_ST_ADDBITS14;
8682 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8683 dgst_size = DGST_SIZE_4_4;
8684 parse_func = md5s_parse_hash;
8685 sort_by_digest = sort_by_digest_4_4;
8686 opti_type = OPTI_TYPE_ZERO_BYTE
8687 | OPTI_TYPE_PRECOMPUTE_INIT
8688 | OPTI_TYPE_PRECOMPUTE_MERKLE
8689 | OPTI_TYPE_EARLY_SKIP
8690 | OPTI_TYPE_NOT_ITERATED
8691 | OPTI_TYPE_RAW_HASH;
8692 dgst_pos0 = 0;
8693 dgst_pos1 = 3;
8694 dgst_pos2 = 2;
8695 dgst_pos3 = 1;
8696 break;
8697
8698 case 4300: hash_type = HASH_TYPE_MD5;
8699 salt_type = SALT_TYPE_VIRTUAL;
8700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8701 opts_type = OPTS_TYPE_PT_GENERATE_LE
8702 | OPTS_TYPE_PT_ADD80
8703 | OPTS_TYPE_PT_ADDBITS14
8704 | OPTS_TYPE_ST_ADD80;
8705 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8706 dgst_size = DGST_SIZE_4_4;
8707 parse_func = md5md5_parse_hash;
8708 sort_by_digest = sort_by_digest_4_4;
8709 opti_type = OPTI_TYPE_ZERO_BYTE
8710 | OPTI_TYPE_PRECOMPUTE_INIT
8711 | OPTI_TYPE_PRECOMPUTE_MERKLE
8712 | OPTI_TYPE_EARLY_SKIP;
8713 dgst_pos0 = 0;
8714 dgst_pos1 = 3;
8715 dgst_pos2 = 2;
8716 dgst_pos3 = 1;
8717 break;
8718
8719
8720 case 4400: hash_type = HASH_TYPE_MD5;
8721 salt_type = SALT_TYPE_NONE;
8722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8723 opts_type = OPTS_TYPE_PT_GENERATE_BE
8724 | OPTS_TYPE_PT_ADD80
8725 | OPTS_TYPE_PT_ADDBITS15;
8726 kern_type = KERN_TYPE_MD5_SHA1;
8727 dgst_size = DGST_SIZE_4_4;
8728 parse_func = md5_parse_hash;
8729 sort_by_digest = sort_by_digest_4_4;
8730 opti_type = OPTI_TYPE_ZERO_BYTE
8731 | OPTI_TYPE_PRECOMPUTE_INIT
8732 | OPTI_TYPE_PRECOMPUTE_MERKLE
8733 | OPTI_TYPE_EARLY_SKIP
8734 | OPTI_TYPE_NOT_ITERATED
8735 | OPTI_TYPE_NOT_SALTED
8736 | OPTI_TYPE_RAW_HASH;
8737 dgst_pos0 = 0;
8738 dgst_pos1 = 3;
8739 dgst_pos2 = 2;
8740 dgst_pos3 = 1;
8741 break;
8742
8743 case 4500: hash_type = HASH_TYPE_SHA1;
8744 salt_type = SALT_TYPE_NONE;
8745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8746 opts_type = OPTS_TYPE_PT_GENERATE_BE
8747 | OPTS_TYPE_PT_ADD80
8748 | OPTS_TYPE_PT_ADDBITS15;
8749 kern_type = KERN_TYPE_SHA11;
8750 dgst_size = DGST_SIZE_4_5;
8751 parse_func = sha1_parse_hash;
8752 sort_by_digest = sort_by_digest_4_5;
8753 opti_type = OPTI_TYPE_ZERO_BYTE
8754 | OPTI_TYPE_PRECOMPUTE_INIT
8755 | OPTI_TYPE_PRECOMPUTE_MERKLE
8756 | OPTI_TYPE_EARLY_SKIP
8757 | OPTI_TYPE_NOT_SALTED;
8758 dgst_pos0 = 3;
8759 dgst_pos1 = 4;
8760 dgst_pos2 = 2;
8761 dgst_pos3 = 1;
8762 break;
8763
8764 case 4700: hash_type = HASH_TYPE_SHA1;
8765 salt_type = SALT_TYPE_NONE;
8766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8767 opts_type = OPTS_TYPE_PT_GENERATE_LE
8768 | OPTS_TYPE_PT_ADD80
8769 | OPTS_TYPE_PT_ADDBITS14;
8770 kern_type = KERN_TYPE_SHA1_MD5;
8771 dgst_size = DGST_SIZE_4_5;
8772 parse_func = sha1_parse_hash;
8773 sort_by_digest = sort_by_digest_4_5;
8774 opti_type = OPTI_TYPE_ZERO_BYTE
8775 | OPTI_TYPE_PRECOMPUTE_INIT
8776 | OPTI_TYPE_PRECOMPUTE_MERKLE
8777 | OPTI_TYPE_EARLY_SKIP
8778 | OPTI_TYPE_NOT_ITERATED
8779 | OPTI_TYPE_NOT_SALTED
8780 | OPTI_TYPE_RAW_HASH;
8781 dgst_pos0 = 3;
8782 dgst_pos1 = 4;
8783 dgst_pos2 = 2;
8784 dgst_pos3 = 1;
8785 break;
8786
8787 case 4800: hash_type = HASH_TYPE_MD5;
8788 salt_type = SALT_TYPE_EMBEDDED;
8789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8790 opts_type = OPTS_TYPE_PT_GENERATE_LE
8791 | OPTS_TYPE_PT_ADDBITS14;
8792 kern_type = KERN_TYPE_MD5_CHAP;
8793 dgst_size = DGST_SIZE_4_4;
8794 parse_func = chap_parse_hash;
8795 sort_by_digest = sort_by_digest_4_4;
8796 opti_type = OPTI_TYPE_ZERO_BYTE
8797 | OPTI_TYPE_PRECOMPUTE_INIT
8798 | OPTI_TYPE_PRECOMPUTE_MERKLE
8799 | OPTI_TYPE_MEET_IN_MIDDLE
8800 | OPTI_TYPE_EARLY_SKIP
8801 | OPTI_TYPE_NOT_ITERATED
8802 | OPTI_TYPE_RAW_HASH;
8803 dgst_pos0 = 0;
8804 dgst_pos1 = 3;
8805 dgst_pos2 = 2;
8806 dgst_pos3 = 1;
8807 break;
8808
8809 case 4900: hash_type = HASH_TYPE_SHA1;
8810 salt_type = SALT_TYPE_INTERN;
8811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8812 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8813 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8814 dgst_size = DGST_SIZE_4_5;
8815 parse_func = sha1s_parse_hash;
8816 sort_by_digest = sort_by_digest_4_5;
8817 opti_type = OPTI_TYPE_ZERO_BYTE
8818 | OPTI_TYPE_PRECOMPUTE_INIT
8819 | OPTI_TYPE_PRECOMPUTE_MERKLE
8820 | OPTI_TYPE_EARLY_SKIP;
8821 dgst_pos0 = 3;
8822 dgst_pos1 = 4;
8823 dgst_pos2 = 2;
8824 dgst_pos3 = 1;
8825 break;
8826
8827 case 5000: hash_type = HASH_TYPE_KECCAK;
8828 salt_type = SALT_TYPE_EMBEDDED;
8829 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8830 opts_type = OPTS_TYPE_PT_GENERATE_LE
8831 | OPTS_TYPE_PT_ADD01;
8832 kern_type = KERN_TYPE_KECCAK;
8833 dgst_size = DGST_SIZE_8_25;
8834 parse_func = keccak_parse_hash;
8835 sort_by_digest = sort_by_digest_8_25;
8836 opti_type = OPTI_TYPE_ZERO_BYTE
8837 | OPTI_TYPE_USES_BITS_64
8838 | OPTI_TYPE_RAW_HASH;
8839 dgst_pos0 = 2;
8840 dgst_pos1 = 3;
8841 dgst_pos2 = 4;
8842 dgst_pos3 = 5;
8843 break;
8844
8845 case 5100: hash_type = HASH_TYPE_MD5H;
8846 salt_type = SALT_TYPE_NONE;
8847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8848 opts_type = OPTS_TYPE_PT_GENERATE_LE
8849 | OPTS_TYPE_PT_ADD80
8850 | OPTS_TYPE_PT_ADDBITS14;
8851 kern_type = KERN_TYPE_MD5H;
8852 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8853 parse_func = md5half_parse_hash;
8854 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8855 opti_type = OPTI_TYPE_ZERO_BYTE
8856 | OPTI_TYPE_RAW_HASH;
8857 dgst_pos0 = 0;
8858 dgst_pos1 = 1;
8859 dgst_pos2 = 2;
8860 dgst_pos3 = 3;
8861 break;
8862
8863 case 5200: hash_type = HASH_TYPE_SHA256;
8864 salt_type = SALT_TYPE_EMBEDDED;
8865 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8866 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8867 kern_type = KERN_TYPE_PSAFE3;
8868 dgst_size = DGST_SIZE_4_8;
8869 parse_func = psafe3_parse_hash;
8870 sort_by_digest = sort_by_digest_4_8;
8871 opti_type = OPTI_TYPE_ZERO_BYTE;
8872 dgst_pos0 = 0;
8873 dgst_pos1 = 1;
8874 dgst_pos2 = 2;
8875 dgst_pos3 = 3;
8876 break;
8877
8878 case 5300: hash_type = HASH_TYPE_MD5;
8879 salt_type = SALT_TYPE_EMBEDDED;
8880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8881 opts_type = OPTS_TYPE_PT_GENERATE_LE
8882 | OPTS_TYPE_ST_ADD80;
8883 kern_type = KERN_TYPE_IKEPSK_MD5;
8884 dgst_size = DGST_SIZE_4_4;
8885 parse_func = ikepsk_md5_parse_hash;
8886 sort_by_digest = sort_by_digest_4_4;
8887 opti_type = OPTI_TYPE_ZERO_BYTE;
8888 dgst_pos0 = 0;
8889 dgst_pos1 = 3;
8890 dgst_pos2 = 2;
8891 dgst_pos3 = 1;
8892 break;
8893
8894 case 5400: hash_type = HASH_TYPE_SHA1;
8895 salt_type = SALT_TYPE_EMBEDDED;
8896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8897 opts_type = OPTS_TYPE_PT_GENERATE_BE
8898 | OPTS_TYPE_ST_ADD80;
8899 kern_type = KERN_TYPE_IKEPSK_SHA1;
8900 dgst_size = DGST_SIZE_4_5;
8901 parse_func = ikepsk_sha1_parse_hash;
8902 sort_by_digest = sort_by_digest_4_5;
8903 opti_type = OPTI_TYPE_ZERO_BYTE;
8904 dgst_pos0 = 3;
8905 dgst_pos1 = 4;
8906 dgst_pos2 = 2;
8907 dgst_pos3 = 1;
8908 break;
8909
8910 case 5500: hash_type = HASH_TYPE_NETNTLM;
8911 salt_type = SALT_TYPE_EMBEDDED;
8912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8913 opts_type = OPTS_TYPE_PT_GENERATE_LE
8914 | OPTS_TYPE_PT_ADD80
8915 | OPTS_TYPE_PT_ADDBITS14
8916 | OPTS_TYPE_PT_UNICODE
8917 | OPTS_TYPE_ST_HEX;
8918 kern_type = KERN_TYPE_NETNTLMv1;
8919 dgst_size = DGST_SIZE_4_4;
8920 parse_func = netntlmv1_parse_hash;
8921 sort_by_digest = sort_by_digest_4_4;
8922 opti_type = OPTI_TYPE_ZERO_BYTE
8923 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8924 dgst_pos0 = 0;
8925 dgst_pos1 = 1;
8926 dgst_pos2 = 2;
8927 dgst_pos3 = 3;
8928 break;
8929
8930 case 5600: hash_type = HASH_TYPE_MD5;
8931 salt_type = SALT_TYPE_EMBEDDED;
8932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8933 opts_type = OPTS_TYPE_PT_GENERATE_LE
8934 | OPTS_TYPE_PT_ADD80
8935 | OPTS_TYPE_PT_ADDBITS14
8936 | OPTS_TYPE_PT_UNICODE;
8937 kern_type = KERN_TYPE_NETNTLMv2;
8938 dgst_size = DGST_SIZE_4_4;
8939 parse_func = netntlmv2_parse_hash;
8940 sort_by_digest = sort_by_digest_4_4;
8941 opti_type = OPTI_TYPE_ZERO_BYTE;
8942 dgst_pos0 = 0;
8943 dgst_pos1 = 3;
8944 dgst_pos2 = 2;
8945 dgst_pos3 = 1;
8946 break;
8947
8948 case 5700: hash_type = HASH_TYPE_SHA256;
8949 salt_type = SALT_TYPE_NONE;
8950 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8951 opts_type = OPTS_TYPE_PT_GENERATE_BE
8952 | OPTS_TYPE_PT_ADD80
8953 | OPTS_TYPE_PT_ADDBITS15;
8954 kern_type = KERN_TYPE_SHA256;
8955 dgst_size = DGST_SIZE_4_8;
8956 parse_func = cisco4_parse_hash;
8957 sort_by_digest = sort_by_digest_4_8;
8958 opti_type = OPTI_TYPE_ZERO_BYTE
8959 | OPTI_TYPE_PRECOMPUTE_INIT
8960 | OPTI_TYPE_PRECOMPUTE_MERKLE
8961 | OPTI_TYPE_EARLY_SKIP
8962 | OPTI_TYPE_NOT_ITERATED
8963 | OPTI_TYPE_NOT_SALTED
8964 | OPTI_TYPE_RAW_HASH;
8965 dgst_pos0 = 3;
8966 dgst_pos1 = 7;
8967 dgst_pos2 = 2;
8968 dgst_pos3 = 6;
8969 break;
8970
8971 case 5800: hash_type = HASH_TYPE_SHA1;
8972 salt_type = SALT_TYPE_INTERN;
8973 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8974 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8975 | OPTS_TYPE_ST_ADD80;
8976 kern_type = KERN_TYPE_ANDROIDPIN;
8977 dgst_size = DGST_SIZE_4_5;
8978 parse_func = androidpin_parse_hash;
8979 sort_by_digest = sort_by_digest_4_5;
8980 opti_type = OPTI_TYPE_ZERO_BYTE;
8981 dgst_pos0 = 0;
8982 dgst_pos1 = 1;
8983 dgst_pos2 = 2;
8984 dgst_pos3 = 3;
8985 break;
8986
8987 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8988 salt_type = SALT_TYPE_NONE;
8989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8990 opts_type = OPTS_TYPE_PT_GENERATE_LE
8991 | OPTS_TYPE_PT_ADD80;
8992 kern_type = KERN_TYPE_RIPEMD160;
8993 dgst_size = DGST_SIZE_4_5;
8994 parse_func = ripemd160_parse_hash;
8995 sort_by_digest = sort_by_digest_4_5;
8996 opti_type = OPTI_TYPE_ZERO_BYTE;
8997 dgst_pos0 = 0;
8998 dgst_pos1 = 1;
8999 dgst_pos2 = 2;
9000 dgst_pos3 = 3;
9001 break;
9002
9003 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9004 salt_type = SALT_TYPE_NONE;
9005 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9006 opts_type = OPTS_TYPE_PT_GENERATE_BE
9007 | OPTS_TYPE_PT_ADD80;
9008 kern_type = KERN_TYPE_WHIRLPOOL;
9009 dgst_size = DGST_SIZE_4_16;
9010 parse_func = whirlpool_parse_hash;
9011 sort_by_digest = sort_by_digest_4_16;
9012 opti_type = OPTI_TYPE_ZERO_BYTE;
9013 dgst_pos0 = 0;
9014 dgst_pos1 = 1;
9015 dgst_pos2 = 2;
9016 dgst_pos3 = 3;
9017 break;
9018
9019 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9020 salt_type = SALT_TYPE_EMBEDDED;
9021 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9022 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9023 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9024 dgst_size = DGST_SIZE_4_5;
9025 parse_func = truecrypt_parse_hash_2k;
9026 sort_by_digest = sort_by_digest_4_5;
9027 opti_type = OPTI_TYPE_ZERO_BYTE;
9028 dgst_pos0 = 0;
9029 dgst_pos1 = 1;
9030 dgst_pos2 = 2;
9031 dgst_pos3 = 3;
9032 break;
9033
9034 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9035 salt_type = SALT_TYPE_EMBEDDED;
9036 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9037 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9038 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9039 dgst_size = DGST_SIZE_4_5;
9040 parse_func = truecrypt_parse_hash_2k;
9041 sort_by_digest = sort_by_digest_4_5;
9042 opti_type = OPTI_TYPE_ZERO_BYTE;
9043 dgst_pos0 = 0;
9044 dgst_pos1 = 1;
9045 dgst_pos2 = 2;
9046 dgst_pos3 = 3;
9047 break;
9048
9049 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9050 salt_type = SALT_TYPE_EMBEDDED;
9051 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9052 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9053 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9054 dgst_size = DGST_SIZE_4_5;
9055 parse_func = truecrypt_parse_hash_2k;
9056 sort_by_digest = sort_by_digest_4_5;
9057 opti_type = OPTI_TYPE_ZERO_BYTE;
9058 dgst_pos0 = 0;
9059 dgst_pos1 = 1;
9060 dgst_pos2 = 2;
9061 dgst_pos3 = 3;
9062 break;
9063
9064 case 6221: hash_type = HASH_TYPE_SHA512;
9065 salt_type = SALT_TYPE_EMBEDDED;
9066 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9067 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9068 kern_type = KERN_TYPE_TCSHA512_XTS512;
9069 dgst_size = DGST_SIZE_8_8;
9070 parse_func = truecrypt_parse_hash_1k;
9071 sort_by_digest = sort_by_digest_8_8;
9072 opti_type = OPTI_TYPE_ZERO_BYTE
9073 | OPTI_TYPE_USES_BITS_64;
9074 dgst_pos0 = 0;
9075 dgst_pos1 = 1;
9076 dgst_pos2 = 2;
9077 dgst_pos3 = 3;
9078 break;
9079
9080 case 6222: hash_type = HASH_TYPE_SHA512;
9081 salt_type = SALT_TYPE_EMBEDDED;
9082 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9083 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9084 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9085 dgst_size = DGST_SIZE_8_8;
9086 parse_func = truecrypt_parse_hash_1k;
9087 sort_by_digest = sort_by_digest_8_8;
9088 opti_type = OPTI_TYPE_ZERO_BYTE
9089 | OPTI_TYPE_USES_BITS_64;
9090 dgst_pos0 = 0;
9091 dgst_pos1 = 1;
9092 dgst_pos2 = 2;
9093 dgst_pos3 = 3;
9094 break;
9095
9096 case 6223: hash_type = HASH_TYPE_SHA512;
9097 salt_type = SALT_TYPE_EMBEDDED;
9098 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9099 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9100 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9101 dgst_size = DGST_SIZE_8_8;
9102 parse_func = truecrypt_parse_hash_1k;
9103 sort_by_digest = sort_by_digest_8_8;
9104 opti_type = OPTI_TYPE_ZERO_BYTE
9105 | OPTI_TYPE_USES_BITS_64;
9106 dgst_pos0 = 0;
9107 dgst_pos1 = 1;
9108 dgst_pos2 = 2;
9109 dgst_pos3 = 3;
9110 break;
9111
9112 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9113 salt_type = SALT_TYPE_EMBEDDED;
9114 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9115 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9116 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9117 dgst_size = DGST_SIZE_4_8;
9118 parse_func = truecrypt_parse_hash_1k;
9119 sort_by_digest = sort_by_digest_4_8;
9120 opti_type = OPTI_TYPE_ZERO_BYTE;
9121 dgst_pos0 = 0;
9122 dgst_pos1 = 1;
9123 dgst_pos2 = 2;
9124 dgst_pos3 = 3;
9125 break;
9126
9127 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9128 salt_type = SALT_TYPE_EMBEDDED;
9129 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9130 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9131 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9132 dgst_size = DGST_SIZE_4_8;
9133 parse_func = truecrypt_parse_hash_1k;
9134 sort_by_digest = sort_by_digest_4_8;
9135 opti_type = OPTI_TYPE_ZERO_BYTE;
9136 dgst_pos0 = 0;
9137 dgst_pos1 = 1;
9138 dgst_pos2 = 2;
9139 dgst_pos3 = 3;
9140 break;
9141
9142 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9143 salt_type = SALT_TYPE_EMBEDDED;
9144 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9145 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9146 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9147 dgst_size = DGST_SIZE_4_8;
9148 parse_func = truecrypt_parse_hash_1k;
9149 sort_by_digest = sort_by_digest_4_8;
9150 opti_type = OPTI_TYPE_ZERO_BYTE;
9151 dgst_pos0 = 0;
9152 dgst_pos1 = 1;
9153 dgst_pos2 = 2;
9154 dgst_pos3 = 3;
9155 break;
9156
9157 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9158 salt_type = SALT_TYPE_EMBEDDED;
9159 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9160 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9161 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9162 dgst_size = DGST_SIZE_4_5;
9163 parse_func = truecrypt_parse_hash_1k;
9164 sort_by_digest = sort_by_digest_4_5;
9165 opti_type = OPTI_TYPE_ZERO_BYTE;
9166 dgst_pos0 = 0;
9167 dgst_pos1 = 1;
9168 dgst_pos2 = 2;
9169 dgst_pos3 = 3;
9170 break;
9171
9172 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9173 salt_type = SALT_TYPE_EMBEDDED;
9174 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9175 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9176 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9177 dgst_size = DGST_SIZE_4_5;
9178 parse_func = truecrypt_parse_hash_1k;
9179 sort_by_digest = sort_by_digest_4_5;
9180 opti_type = OPTI_TYPE_ZERO_BYTE;
9181 dgst_pos0 = 0;
9182 dgst_pos1 = 1;
9183 dgst_pos2 = 2;
9184 dgst_pos3 = 3;
9185 break;
9186
9187 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9188 salt_type = SALT_TYPE_EMBEDDED;
9189 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9190 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9191 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9192 dgst_size = DGST_SIZE_4_5;
9193 parse_func = truecrypt_parse_hash_1k;
9194 sort_by_digest = sort_by_digest_4_5;
9195 opti_type = OPTI_TYPE_ZERO_BYTE;
9196 dgst_pos0 = 0;
9197 dgst_pos1 = 1;
9198 dgst_pos2 = 2;
9199 dgst_pos3 = 3;
9200 break;
9201
9202 case 6300: hash_type = HASH_TYPE_MD5;
9203 salt_type = SALT_TYPE_EMBEDDED;
9204 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9205 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9206 kern_type = KERN_TYPE_MD5AIX;
9207 dgst_size = DGST_SIZE_4_4;
9208 parse_func = md5aix_parse_hash;
9209 sort_by_digest = sort_by_digest_4_4;
9210 opti_type = OPTI_TYPE_ZERO_BYTE;
9211 dgst_pos0 = 0;
9212 dgst_pos1 = 1;
9213 dgst_pos2 = 2;
9214 dgst_pos3 = 3;
9215 break;
9216
9217 case 6400: hash_type = HASH_TYPE_SHA256;
9218 salt_type = SALT_TYPE_EMBEDDED;
9219 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9220 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9221 kern_type = KERN_TYPE_SHA256AIX;
9222 dgst_size = DGST_SIZE_4_8;
9223 parse_func = sha256aix_parse_hash;
9224 sort_by_digest = sort_by_digest_4_8;
9225 opti_type = OPTI_TYPE_ZERO_BYTE;
9226 dgst_pos0 = 0;
9227 dgst_pos1 = 1;
9228 dgst_pos2 = 2;
9229 dgst_pos3 = 3;
9230 break;
9231
9232 case 6500: hash_type = HASH_TYPE_SHA512;
9233 salt_type = SALT_TYPE_EMBEDDED;
9234 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9235 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9236 kern_type = KERN_TYPE_SHA512AIX;
9237 dgst_size = DGST_SIZE_8_8;
9238 parse_func = sha512aix_parse_hash;
9239 sort_by_digest = sort_by_digest_8_8;
9240 opti_type = OPTI_TYPE_ZERO_BYTE
9241 | OPTI_TYPE_USES_BITS_64;
9242 dgst_pos0 = 0;
9243 dgst_pos1 = 1;
9244 dgst_pos2 = 2;
9245 dgst_pos3 = 3;
9246 break;
9247
9248 case 6600: hash_type = HASH_TYPE_AES;
9249 salt_type = SALT_TYPE_EMBEDDED;
9250 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9251 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9252 kern_type = KERN_TYPE_AGILEKEY;
9253 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9254 parse_func = agilekey_parse_hash;
9255 sort_by_digest = sort_by_digest_4_5;
9256 opti_type = OPTI_TYPE_ZERO_BYTE;
9257 dgst_pos0 = 0;
9258 dgst_pos1 = 1;
9259 dgst_pos2 = 2;
9260 dgst_pos3 = 3;
9261 break;
9262
9263 case 6700: hash_type = HASH_TYPE_SHA1;
9264 salt_type = SALT_TYPE_EMBEDDED;
9265 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9266 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9267 kern_type = KERN_TYPE_SHA1AIX;
9268 dgst_size = DGST_SIZE_4_5;
9269 parse_func = sha1aix_parse_hash;
9270 sort_by_digest = sort_by_digest_4_5;
9271 opti_type = OPTI_TYPE_ZERO_BYTE;
9272 dgst_pos0 = 0;
9273 dgst_pos1 = 1;
9274 dgst_pos2 = 2;
9275 dgst_pos3 = 3;
9276 break;
9277
9278 case 6800: hash_type = HASH_TYPE_AES;
9279 salt_type = SALT_TYPE_EMBEDDED;
9280 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9281 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9282 kern_type = KERN_TYPE_LASTPASS;
9283 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9284 parse_func = lastpass_parse_hash;
9285 sort_by_digest = sort_by_digest_4_8;
9286 opti_type = OPTI_TYPE_ZERO_BYTE;
9287 dgst_pos0 = 0;
9288 dgst_pos1 = 1;
9289 dgst_pos2 = 2;
9290 dgst_pos3 = 3;
9291 break;
9292
9293 case 6900: hash_type = HASH_TYPE_GOST;
9294 salt_type = SALT_TYPE_NONE;
9295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9296 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9297 kern_type = KERN_TYPE_GOST;
9298 dgst_size = DGST_SIZE_4_8;
9299 parse_func = gost_parse_hash;
9300 sort_by_digest = sort_by_digest_4_8;
9301 opti_type = OPTI_TYPE_ZERO_BYTE;
9302 dgst_pos0 = 0;
9303 dgst_pos1 = 1;
9304 dgst_pos2 = 2;
9305 dgst_pos3 = 3;
9306 break;
9307
9308 case 7100: hash_type = HASH_TYPE_SHA512;
9309 salt_type = SALT_TYPE_EMBEDDED;
9310 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9311 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9312 kern_type = KERN_TYPE_PBKDF2_SHA512;
9313 dgst_size = DGST_SIZE_8_16;
9314 parse_func = sha512osx_parse_hash;
9315 sort_by_digest = sort_by_digest_8_16;
9316 opti_type = OPTI_TYPE_ZERO_BYTE
9317 | OPTI_TYPE_USES_BITS_64
9318 | OPTI_TYPE_SLOW_HASH_SIMD;
9319 dgst_pos0 = 0;
9320 dgst_pos1 = 1;
9321 dgst_pos2 = 2;
9322 dgst_pos3 = 3;
9323 break;
9324
9325 case 7200: hash_type = HASH_TYPE_SHA512;
9326 salt_type = SALT_TYPE_EMBEDDED;
9327 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9328 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9329 kern_type = KERN_TYPE_PBKDF2_SHA512;
9330 dgst_size = DGST_SIZE_8_16;
9331 parse_func = sha512grub_parse_hash;
9332 sort_by_digest = sort_by_digest_8_16;
9333 opti_type = OPTI_TYPE_ZERO_BYTE
9334 | OPTI_TYPE_USES_BITS_64
9335 | OPTI_TYPE_SLOW_HASH_SIMD;
9336 dgst_pos0 = 0;
9337 dgst_pos1 = 1;
9338 dgst_pos2 = 2;
9339 dgst_pos3 = 3;
9340 break;
9341
9342 case 7300: hash_type = HASH_TYPE_SHA1;
9343 salt_type = SALT_TYPE_EMBEDDED;
9344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9345 opts_type = OPTS_TYPE_PT_GENERATE_BE
9346 | OPTS_TYPE_ST_ADD80
9347 | OPTS_TYPE_ST_ADDBITS15;
9348 kern_type = KERN_TYPE_RAKP;
9349 dgst_size = DGST_SIZE_4_5;
9350 parse_func = rakp_parse_hash;
9351 sort_by_digest = sort_by_digest_4_5;
9352 opti_type = OPTI_TYPE_ZERO_BYTE
9353 | OPTI_TYPE_NOT_ITERATED;
9354 dgst_pos0 = 3;
9355 dgst_pos1 = 4;
9356 dgst_pos2 = 2;
9357 dgst_pos3 = 1;
9358 break;
9359
9360 case 7400: hash_type = HASH_TYPE_SHA256;
9361 salt_type = SALT_TYPE_EMBEDDED;
9362 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9363 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9364 kern_type = KERN_TYPE_SHA256CRYPT;
9365 dgst_size = DGST_SIZE_4_8;
9366 parse_func = sha256crypt_parse_hash;
9367 sort_by_digest = sort_by_digest_4_8;
9368 opti_type = OPTI_TYPE_ZERO_BYTE;
9369 dgst_pos0 = 0;
9370 dgst_pos1 = 1;
9371 dgst_pos2 = 2;
9372 dgst_pos3 = 3;
9373 break;
9374
9375 case 7500: hash_type = HASH_TYPE_KRB5PA;
9376 salt_type = SALT_TYPE_EMBEDDED;
9377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9378 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9379 kern_type = KERN_TYPE_KRB5PA;
9380 dgst_size = DGST_SIZE_4_4;
9381 parse_func = krb5pa_parse_hash;
9382 sort_by_digest = sort_by_digest_4_4;
9383 opti_type = OPTI_TYPE_ZERO_BYTE
9384 | OPTI_TYPE_NOT_ITERATED;
9385 dgst_pos0 = 0;
9386 dgst_pos1 = 1;
9387 dgst_pos2 = 2;
9388 dgst_pos3 = 3;
9389 break;
9390
9391 case 7600: hash_type = HASH_TYPE_SHA1;
9392 salt_type = SALT_TYPE_INTERN;
9393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9394 opts_type = OPTS_TYPE_PT_GENERATE_BE
9395 | OPTS_TYPE_PT_ADD80
9396 | OPTS_TYPE_PT_ADDBITS15;
9397 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9398 dgst_size = DGST_SIZE_4_5;
9399 parse_func = redmine_parse_hash;
9400 sort_by_digest = sort_by_digest_4_5;
9401 opti_type = OPTI_TYPE_ZERO_BYTE
9402 | OPTI_TYPE_PRECOMPUTE_INIT
9403 | OPTI_TYPE_EARLY_SKIP
9404 | OPTI_TYPE_NOT_ITERATED
9405 | OPTI_TYPE_PREPENDED_SALT;
9406 dgst_pos0 = 3;
9407 dgst_pos1 = 4;
9408 dgst_pos2 = 2;
9409 dgst_pos3 = 1;
9410 break;
9411
9412 case 7700: hash_type = HASH_TYPE_SAPB;
9413 salt_type = SALT_TYPE_EMBEDDED;
9414 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9415 opts_type = OPTS_TYPE_PT_GENERATE_LE
9416 | OPTS_TYPE_PT_UPPER
9417 | OPTS_TYPE_ST_UPPER;
9418 kern_type = KERN_TYPE_SAPB;
9419 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9420 parse_func = sapb_parse_hash;
9421 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9422 opti_type = OPTI_TYPE_ZERO_BYTE
9423 | OPTI_TYPE_PRECOMPUTE_INIT
9424 | OPTI_TYPE_NOT_ITERATED;
9425 dgst_pos0 = 0;
9426 dgst_pos1 = 1;
9427 dgst_pos2 = 2;
9428 dgst_pos3 = 3;
9429 break;
9430
9431 case 7800: hash_type = HASH_TYPE_SAPG;
9432 salt_type = SALT_TYPE_EMBEDDED;
9433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9434 opts_type = OPTS_TYPE_PT_GENERATE_BE
9435 | OPTS_TYPE_ST_ADD80
9436 | OPTS_TYPE_ST_UPPER;
9437 kern_type = KERN_TYPE_SAPG;
9438 dgst_size = DGST_SIZE_4_5;
9439 parse_func = sapg_parse_hash;
9440 sort_by_digest = sort_by_digest_4_5;
9441 opti_type = OPTI_TYPE_ZERO_BYTE
9442 | OPTI_TYPE_PRECOMPUTE_INIT
9443 | OPTI_TYPE_NOT_ITERATED;
9444 dgst_pos0 = 3;
9445 dgst_pos1 = 4;
9446 dgst_pos2 = 2;
9447 dgst_pos3 = 1;
9448 break;
9449
9450 case 7900: hash_type = HASH_TYPE_SHA512;
9451 salt_type = SALT_TYPE_EMBEDDED;
9452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9453 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9454 kern_type = KERN_TYPE_DRUPAL7;
9455 dgst_size = DGST_SIZE_8_8;
9456 parse_func = drupal7_parse_hash;
9457 sort_by_digest = sort_by_digest_8_8;
9458 opti_type = OPTI_TYPE_ZERO_BYTE
9459 | OPTI_TYPE_USES_BITS_64;
9460 dgst_pos0 = 0;
9461 dgst_pos1 = 1;
9462 dgst_pos2 = 2;
9463 dgst_pos3 = 3;
9464 break;
9465
9466 case 8000: hash_type = HASH_TYPE_SHA256;
9467 salt_type = SALT_TYPE_EMBEDDED;
9468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9469 opts_type = OPTS_TYPE_PT_GENERATE_BE
9470 | OPTS_TYPE_PT_UNICODE
9471 | OPTS_TYPE_ST_ADD80
9472 | OPTS_TYPE_ST_HEX;
9473 kern_type = KERN_TYPE_SYBASEASE;
9474 dgst_size = DGST_SIZE_4_8;
9475 parse_func = sybasease_parse_hash;
9476 sort_by_digest = sort_by_digest_4_8;
9477 opti_type = OPTI_TYPE_ZERO_BYTE
9478 | OPTI_TYPE_PRECOMPUTE_INIT
9479 | OPTI_TYPE_EARLY_SKIP
9480 | OPTI_TYPE_NOT_ITERATED
9481 | OPTI_TYPE_RAW_HASH;
9482 dgst_pos0 = 3;
9483 dgst_pos1 = 7;
9484 dgst_pos2 = 2;
9485 dgst_pos3 = 6;
9486 break;
9487
9488 case 8100: hash_type = HASH_TYPE_SHA1;
9489 salt_type = SALT_TYPE_EMBEDDED;
9490 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9491 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9492 kern_type = KERN_TYPE_NETSCALER;
9493 dgst_size = DGST_SIZE_4_5;
9494 parse_func = netscaler_parse_hash;
9495 sort_by_digest = sort_by_digest_4_5;
9496 opti_type = OPTI_TYPE_ZERO_BYTE
9497 | OPTI_TYPE_PRECOMPUTE_INIT
9498 | OPTI_TYPE_PRECOMPUTE_MERKLE
9499 | OPTI_TYPE_EARLY_SKIP
9500 | OPTI_TYPE_NOT_ITERATED
9501 | OPTI_TYPE_PREPENDED_SALT
9502 | OPTI_TYPE_RAW_HASH;
9503 dgst_pos0 = 3;
9504 dgst_pos1 = 4;
9505 dgst_pos2 = 2;
9506 dgst_pos3 = 1;
9507 break;
9508
9509 case 8200: hash_type = HASH_TYPE_SHA256;
9510 salt_type = SALT_TYPE_EMBEDDED;
9511 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9512 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9513 kern_type = KERN_TYPE_CLOUDKEY;
9514 dgst_size = DGST_SIZE_4_8;
9515 parse_func = cloudkey_parse_hash;
9516 sort_by_digest = sort_by_digest_4_8;
9517 opti_type = OPTI_TYPE_ZERO_BYTE;
9518 dgst_pos0 = 0;
9519 dgst_pos1 = 1;
9520 dgst_pos2 = 2;
9521 dgst_pos3 = 3;
9522 break;
9523
9524 case 8300: hash_type = HASH_TYPE_SHA1;
9525 salt_type = SALT_TYPE_EMBEDDED;
9526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9527 opts_type = OPTS_TYPE_PT_GENERATE_BE
9528 | OPTS_TYPE_ST_HEX
9529 | OPTS_TYPE_ST_ADD80;
9530 kern_type = KERN_TYPE_NSEC3;
9531 dgst_size = DGST_SIZE_4_5;
9532 parse_func = nsec3_parse_hash;
9533 sort_by_digest = sort_by_digest_4_5;
9534 opti_type = OPTI_TYPE_ZERO_BYTE;
9535 dgst_pos0 = 3;
9536 dgst_pos1 = 4;
9537 dgst_pos2 = 2;
9538 dgst_pos3 = 1;
9539 break;
9540
9541 case 8400: hash_type = HASH_TYPE_SHA1;
9542 salt_type = SALT_TYPE_INTERN;
9543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9544 opts_type = OPTS_TYPE_PT_GENERATE_BE
9545 | OPTS_TYPE_PT_ADD80
9546 | OPTS_TYPE_PT_ADDBITS15;
9547 kern_type = KERN_TYPE_WBB3;
9548 dgst_size = DGST_SIZE_4_5;
9549 parse_func = wbb3_parse_hash;
9550 sort_by_digest = sort_by_digest_4_5;
9551 opti_type = OPTI_TYPE_ZERO_BYTE
9552 | OPTI_TYPE_PRECOMPUTE_INIT
9553 | OPTI_TYPE_NOT_ITERATED;
9554 dgst_pos0 = 3;
9555 dgst_pos1 = 4;
9556 dgst_pos2 = 2;
9557 dgst_pos3 = 1;
9558 break;
9559
9560 case 8500: hash_type = HASH_TYPE_DESRACF;
9561 salt_type = SALT_TYPE_EMBEDDED;
9562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9563 opts_type = OPTS_TYPE_PT_GENERATE_LE
9564 | OPTS_TYPE_ST_UPPER;
9565 kern_type = KERN_TYPE_RACF;
9566 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9567 parse_func = racf_parse_hash;
9568 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9569 opti_type = OPTI_TYPE_ZERO_BYTE
9570 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9571 dgst_pos0 = 0;
9572 dgst_pos1 = 1;
9573 dgst_pos2 = 2;
9574 dgst_pos3 = 3;
9575 break;
9576
9577 case 8600: hash_type = HASH_TYPE_LOTUS5;
9578 salt_type = SALT_TYPE_NONE;
9579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9580 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9581 kern_type = KERN_TYPE_LOTUS5;
9582 dgst_size = DGST_SIZE_4_4;
9583 parse_func = lotus5_parse_hash;
9584 sort_by_digest = sort_by_digest_4_4;
9585 opti_type = OPTI_TYPE_EARLY_SKIP
9586 | OPTI_TYPE_NOT_ITERATED
9587 | OPTI_TYPE_NOT_SALTED
9588 | OPTI_TYPE_RAW_HASH;
9589 dgst_pos0 = 0;
9590 dgst_pos1 = 1;
9591 dgst_pos2 = 2;
9592 dgst_pos3 = 3;
9593 break;
9594
9595 case 8700: hash_type = HASH_TYPE_LOTUS6;
9596 salt_type = SALT_TYPE_EMBEDDED;
9597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9598 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9599 kern_type = KERN_TYPE_LOTUS6;
9600 dgst_size = DGST_SIZE_4_4;
9601 parse_func = lotus6_parse_hash;
9602 sort_by_digest = sort_by_digest_4_4;
9603 opti_type = OPTI_TYPE_EARLY_SKIP
9604 | OPTI_TYPE_NOT_ITERATED
9605 | OPTI_TYPE_RAW_HASH;
9606 dgst_pos0 = 0;
9607 dgst_pos1 = 1;
9608 dgst_pos2 = 2;
9609 dgst_pos3 = 3;
9610 break;
9611
9612 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9613 salt_type = SALT_TYPE_EMBEDDED;
9614 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9615 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9616 kern_type = KERN_TYPE_ANDROIDFDE;
9617 dgst_size = DGST_SIZE_4_4;
9618 parse_func = androidfde_parse_hash;
9619 sort_by_digest = sort_by_digest_4_4;
9620 opti_type = OPTI_TYPE_ZERO_BYTE;
9621 dgst_pos0 = 0;
9622 dgst_pos1 = 1;
9623 dgst_pos2 = 2;
9624 dgst_pos3 = 3;
9625 break;
9626
9627 case 8900: hash_type = HASH_TYPE_SCRYPT;
9628 salt_type = SALT_TYPE_EMBEDDED;
9629 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9630 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9631 kern_type = KERN_TYPE_SCRYPT;
9632 dgst_size = DGST_SIZE_4_8;
9633 parse_func = scrypt_parse_hash;
9634 sort_by_digest = sort_by_digest_4_8;
9635 opti_type = OPTI_TYPE_ZERO_BYTE;
9636 dgst_pos0 = 0;
9637 dgst_pos1 = 1;
9638 dgst_pos2 = 2;
9639 dgst_pos3 = 3;
9640 break;
9641
9642 case 9000: hash_type = HASH_TYPE_SHA1;
9643 salt_type = SALT_TYPE_EMBEDDED;
9644 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9645 opts_type = OPTS_TYPE_PT_GENERATE_LE
9646 | OPTS_TYPE_ST_GENERATE_LE;
9647 kern_type = KERN_TYPE_PSAFE2;
9648 dgst_size = DGST_SIZE_4_5;
9649 parse_func = psafe2_parse_hash;
9650 sort_by_digest = sort_by_digest_4_5;
9651 opti_type = OPTI_TYPE_ZERO_BYTE;
9652 dgst_pos0 = 0;
9653 dgst_pos1 = 1;
9654 dgst_pos2 = 2;
9655 dgst_pos3 = 3;
9656 break;
9657
9658 case 9100: hash_type = HASH_TYPE_LOTUS8;
9659 salt_type = SALT_TYPE_EMBEDDED;
9660 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9661 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9662 kern_type = KERN_TYPE_LOTUS8;
9663 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9664 parse_func = lotus8_parse_hash;
9665 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9666 opti_type = OPTI_TYPE_ZERO_BYTE;
9667 dgst_pos0 = 0;
9668 dgst_pos1 = 1;
9669 dgst_pos2 = 2;
9670 dgst_pos3 = 3;
9671 break;
9672
9673 case 9200: hash_type = HASH_TYPE_SHA256;
9674 salt_type = SALT_TYPE_EMBEDDED;
9675 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9676 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9677 kern_type = KERN_TYPE_PBKDF2_SHA256;
9678 dgst_size = DGST_SIZE_4_32;
9679 parse_func = cisco8_parse_hash;
9680 sort_by_digest = sort_by_digest_4_32;
9681 opti_type = OPTI_TYPE_ZERO_BYTE
9682 | OPTI_TYPE_SLOW_HASH_SIMD;
9683 dgst_pos0 = 0;
9684 dgst_pos1 = 1;
9685 dgst_pos2 = 2;
9686 dgst_pos3 = 3;
9687 break;
9688
9689 case 9300: hash_type = HASH_TYPE_SCRYPT;
9690 salt_type = SALT_TYPE_EMBEDDED;
9691 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9692 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9693 kern_type = KERN_TYPE_SCRYPT;
9694 dgst_size = DGST_SIZE_4_8;
9695 parse_func = cisco9_parse_hash;
9696 sort_by_digest = sort_by_digest_4_8;
9697 opti_type = OPTI_TYPE_ZERO_BYTE;
9698 dgst_pos0 = 0;
9699 dgst_pos1 = 1;
9700 dgst_pos2 = 2;
9701 dgst_pos3 = 3;
9702 break;
9703
9704 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9705 salt_type = SALT_TYPE_EMBEDDED;
9706 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9707 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9708 kern_type = KERN_TYPE_OFFICE2007;
9709 dgst_size = DGST_SIZE_4_4;
9710 parse_func = office2007_parse_hash;
9711 sort_by_digest = sort_by_digest_4_4;
9712 opti_type = OPTI_TYPE_ZERO_BYTE;
9713 dgst_pos0 = 0;
9714 dgst_pos1 = 1;
9715 dgst_pos2 = 2;
9716 dgst_pos3 = 3;
9717 break;
9718
9719 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9720 salt_type = SALT_TYPE_EMBEDDED;
9721 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9722 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9723 kern_type = KERN_TYPE_OFFICE2010;
9724 dgst_size = DGST_SIZE_4_4;
9725 parse_func = office2010_parse_hash;
9726 sort_by_digest = sort_by_digest_4_4;
9727 opti_type = OPTI_TYPE_ZERO_BYTE;
9728 dgst_pos0 = 0;
9729 dgst_pos1 = 1;
9730 dgst_pos2 = 2;
9731 dgst_pos3 = 3;
9732 break;
9733
9734 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9735 salt_type = SALT_TYPE_EMBEDDED;
9736 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9737 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9738 kern_type = KERN_TYPE_OFFICE2013;
9739 dgst_size = DGST_SIZE_4_4;
9740 parse_func = office2013_parse_hash;
9741 sort_by_digest = sort_by_digest_4_4;
9742 opti_type = OPTI_TYPE_ZERO_BYTE;
9743 dgst_pos0 = 0;
9744 dgst_pos1 = 1;
9745 dgst_pos2 = 2;
9746 dgst_pos3 = 3;
9747 break;
9748
9749 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9750 salt_type = SALT_TYPE_EMBEDDED;
9751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9752 opts_type = OPTS_TYPE_PT_GENERATE_LE
9753 | OPTS_TYPE_PT_ADD80
9754 | OPTS_TYPE_PT_UNICODE;
9755 kern_type = KERN_TYPE_OLDOFFICE01;
9756 dgst_size = DGST_SIZE_4_4;
9757 parse_func = oldoffice01_parse_hash;
9758 sort_by_digest = sort_by_digest_4_4;
9759 opti_type = OPTI_TYPE_ZERO_BYTE
9760 | OPTI_TYPE_PRECOMPUTE_INIT
9761 | OPTI_TYPE_NOT_ITERATED;
9762 dgst_pos0 = 0;
9763 dgst_pos1 = 1;
9764 dgst_pos2 = 2;
9765 dgst_pos3 = 3;
9766 break;
9767
9768 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9769 salt_type = SALT_TYPE_EMBEDDED;
9770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9771 opts_type = OPTS_TYPE_PT_GENERATE_LE
9772 | OPTS_TYPE_PT_ADD80;
9773 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9774 dgst_size = DGST_SIZE_4_4;
9775 parse_func = oldoffice01cm1_parse_hash;
9776 sort_by_digest = sort_by_digest_4_4;
9777 opti_type = OPTI_TYPE_ZERO_BYTE
9778 | OPTI_TYPE_PRECOMPUTE_INIT
9779 | OPTI_TYPE_NOT_ITERATED;
9780 dgst_pos0 = 0;
9781 dgst_pos1 = 1;
9782 dgst_pos2 = 2;
9783 dgst_pos3 = 3;
9784 break;
9785
9786 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9787 salt_type = SALT_TYPE_EMBEDDED;
9788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9789 opts_type = OPTS_TYPE_PT_GENERATE_LE
9790 | OPTS_TYPE_PT_ADD80
9791 | OPTS_TYPE_PT_UNICODE
9792 | OPTS_TYPE_PT_NEVERCRACK;
9793 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9794 dgst_size = DGST_SIZE_4_4;
9795 parse_func = oldoffice01cm2_parse_hash;
9796 sort_by_digest = sort_by_digest_4_4;
9797 opti_type = OPTI_TYPE_ZERO_BYTE
9798 | OPTI_TYPE_PRECOMPUTE_INIT
9799 | OPTI_TYPE_NOT_ITERATED;
9800 dgst_pos0 = 0;
9801 dgst_pos1 = 1;
9802 dgst_pos2 = 2;
9803 dgst_pos3 = 3;
9804 break;
9805
9806 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9807 salt_type = SALT_TYPE_EMBEDDED;
9808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9809 opts_type = OPTS_TYPE_PT_GENERATE_BE
9810 | OPTS_TYPE_PT_ADD80
9811 | OPTS_TYPE_PT_UNICODE;
9812 kern_type = KERN_TYPE_OLDOFFICE34;
9813 dgst_size = DGST_SIZE_4_4;
9814 parse_func = oldoffice34_parse_hash;
9815 sort_by_digest = sort_by_digest_4_4;
9816 opti_type = OPTI_TYPE_ZERO_BYTE
9817 | OPTI_TYPE_PRECOMPUTE_INIT
9818 | OPTI_TYPE_NOT_ITERATED;
9819 dgst_pos0 = 0;
9820 dgst_pos1 = 1;
9821 dgst_pos2 = 2;
9822 dgst_pos3 = 3;
9823 break;
9824
9825 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9826 salt_type = SALT_TYPE_EMBEDDED;
9827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9828 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9829 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9830 dgst_size = DGST_SIZE_4_4;
9831 parse_func = oldoffice34cm1_parse_hash;
9832 sort_by_digest = sort_by_digest_4_4;
9833 opti_type = OPTI_TYPE_ZERO_BYTE
9834 | OPTI_TYPE_PRECOMPUTE_INIT
9835 | OPTI_TYPE_NOT_ITERATED;
9836 dgst_pos0 = 0;
9837 dgst_pos1 = 1;
9838 dgst_pos2 = 2;
9839 dgst_pos3 = 3;
9840 break;
9841
9842 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9843 salt_type = SALT_TYPE_EMBEDDED;
9844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9845 opts_type = OPTS_TYPE_PT_GENERATE_BE
9846 | OPTS_TYPE_PT_ADD80
9847 | OPTS_TYPE_PT_UNICODE
9848 | OPTS_TYPE_PT_NEVERCRACK;
9849 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9850 dgst_size = DGST_SIZE_4_4;
9851 parse_func = oldoffice34cm2_parse_hash;
9852 sort_by_digest = sort_by_digest_4_4;
9853 opti_type = OPTI_TYPE_ZERO_BYTE
9854 | OPTI_TYPE_PRECOMPUTE_INIT
9855 | OPTI_TYPE_NOT_ITERATED;
9856 dgst_pos0 = 0;
9857 dgst_pos1 = 1;
9858 dgst_pos2 = 2;
9859 dgst_pos3 = 3;
9860 break;
9861
9862 case 9900: hash_type = HASH_TYPE_MD5;
9863 salt_type = SALT_TYPE_NONE;
9864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9865 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9866 kern_type = KERN_TYPE_RADMIN2;
9867 dgst_size = DGST_SIZE_4_4;
9868 parse_func = radmin2_parse_hash;
9869 sort_by_digest = sort_by_digest_4_4;
9870 opti_type = OPTI_TYPE_ZERO_BYTE
9871 | OPTI_TYPE_PRECOMPUTE_INIT
9872 | OPTI_TYPE_EARLY_SKIP
9873 | OPTI_TYPE_NOT_ITERATED
9874 | OPTI_TYPE_NOT_SALTED;
9875 dgst_pos0 = 0;
9876 dgst_pos1 = 3;
9877 dgst_pos2 = 2;
9878 dgst_pos3 = 1;
9879 break;
9880
9881 case 10000: hash_type = HASH_TYPE_SHA256;
9882 salt_type = SALT_TYPE_EMBEDDED;
9883 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9884 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9885 kern_type = KERN_TYPE_PBKDF2_SHA256;
9886 dgst_size = DGST_SIZE_4_32;
9887 parse_func = djangopbkdf2_parse_hash;
9888 sort_by_digest = sort_by_digest_4_32;
9889 opti_type = OPTI_TYPE_ZERO_BYTE
9890 | OPTI_TYPE_SLOW_HASH_SIMD;
9891 dgst_pos0 = 0;
9892 dgst_pos1 = 1;
9893 dgst_pos2 = 2;
9894 dgst_pos3 = 3;
9895 break;
9896
9897 case 10100: hash_type = HASH_TYPE_SIPHASH;
9898 salt_type = SALT_TYPE_EMBEDDED;
9899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9900 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9901 kern_type = KERN_TYPE_SIPHASH;
9902 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9903 parse_func = siphash_parse_hash;
9904 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9905 opti_type = OPTI_TYPE_ZERO_BYTE
9906 | OPTI_TYPE_NOT_ITERATED
9907 | OPTI_TYPE_RAW_HASH;
9908 dgst_pos0 = 0;
9909 dgst_pos1 = 1;
9910 dgst_pos2 = 2;
9911 dgst_pos3 = 3;
9912 break;
9913
9914 case 10200: hash_type = HASH_TYPE_MD5;
9915 salt_type = SALT_TYPE_EMBEDDED;
9916 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9917 opts_type = OPTS_TYPE_PT_GENERATE_LE
9918 | OPTS_TYPE_ST_ADD80
9919 | OPTS_TYPE_ST_ADDBITS14;
9920 kern_type = KERN_TYPE_HMACMD5_PW;
9921 dgst_size = DGST_SIZE_4_4;
9922 parse_func = crammd5_parse_hash;
9923 sort_by_digest = sort_by_digest_4_4;
9924 opti_type = OPTI_TYPE_ZERO_BYTE
9925 | OPTI_TYPE_NOT_ITERATED;
9926 dgst_pos0 = 0;
9927 dgst_pos1 = 3;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 1;
9930 break;
9931
9932 case 10300: hash_type = HASH_TYPE_SHA1;
9933 salt_type = SALT_TYPE_EMBEDDED;
9934 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9936 kern_type = KERN_TYPE_SAPH_SHA1;
9937 dgst_size = DGST_SIZE_4_5;
9938 parse_func = saph_sha1_parse_hash;
9939 sort_by_digest = sort_by_digest_4_5;
9940 opti_type = OPTI_TYPE_ZERO_BYTE;
9941 dgst_pos0 = 0;
9942 dgst_pos1 = 1;
9943 dgst_pos2 = 2;
9944 dgst_pos3 = 3;
9945 break;
9946
9947 case 10400: hash_type = HASH_TYPE_PDFU16;
9948 salt_type = SALT_TYPE_EMBEDDED;
9949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9950 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9951 kern_type = KERN_TYPE_PDF11;
9952 dgst_size = DGST_SIZE_4_4;
9953 parse_func = pdf11_parse_hash;
9954 sort_by_digest = sort_by_digest_4_4;
9955 opti_type = OPTI_TYPE_ZERO_BYTE
9956 | OPTI_TYPE_NOT_ITERATED;
9957 dgst_pos0 = 0;
9958 dgst_pos1 = 1;
9959 dgst_pos2 = 2;
9960 dgst_pos3 = 3;
9961 break;
9962
9963 case 10410: hash_type = HASH_TYPE_PDFU16;
9964 salt_type = SALT_TYPE_EMBEDDED;
9965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9966 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9967 kern_type = KERN_TYPE_PDF11CM1;
9968 dgst_size = DGST_SIZE_4_4;
9969 parse_func = pdf11cm1_parse_hash;
9970 sort_by_digest = sort_by_digest_4_4;
9971 opti_type = OPTI_TYPE_ZERO_BYTE
9972 | OPTI_TYPE_NOT_ITERATED;
9973 dgst_pos0 = 0;
9974 dgst_pos1 = 1;
9975 dgst_pos2 = 2;
9976 dgst_pos3 = 3;
9977 break;
9978
9979 case 10420: hash_type = HASH_TYPE_PDFU16;
9980 salt_type = SALT_TYPE_EMBEDDED;
9981 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9982 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9983 kern_type = KERN_TYPE_PDF11CM2;
9984 dgst_size = DGST_SIZE_4_4;
9985 parse_func = pdf11cm2_parse_hash;
9986 sort_by_digest = sort_by_digest_4_4;
9987 opti_type = OPTI_TYPE_ZERO_BYTE
9988 | OPTI_TYPE_NOT_ITERATED;
9989 dgst_pos0 = 0;
9990 dgst_pos1 = 1;
9991 dgst_pos2 = 2;
9992 dgst_pos3 = 3;
9993 break;
9994
9995 case 10500: hash_type = HASH_TYPE_PDFU16;
9996 salt_type = SALT_TYPE_EMBEDDED;
9997 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9998 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9999 kern_type = KERN_TYPE_PDF14;
10000 dgst_size = DGST_SIZE_4_4;
10001 parse_func = pdf14_parse_hash;
10002 sort_by_digest = sort_by_digest_4_4;
10003 opti_type = OPTI_TYPE_ZERO_BYTE
10004 | OPTI_TYPE_NOT_ITERATED;
10005 dgst_pos0 = 0;
10006 dgst_pos1 = 1;
10007 dgst_pos2 = 2;
10008 dgst_pos3 = 3;
10009 break;
10010
10011 case 10600: hash_type = HASH_TYPE_SHA256;
10012 salt_type = SALT_TYPE_EMBEDDED;
10013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10014 opts_type = OPTS_TYPE_PT_GENERATE_BE
10015 | OPTS_TYPE_ST_ADD80
10016 | OPTS_TYPE_ST_ADDBITS15
10017 | OPTS_TYPE_HASH_COPY;
10018 kern_type = KERN_TYPE_SHA256_PWSLT;
10019 dgst_size = DGST_SIZE_4_8;
10020 parse_func = pdf17l3_parse_hash;
10021 sort_by_digest = sort_by_digest_4_8;
10022 opti_type = OPTI_TYPE_ZERO_BYTE
10023 | OPTI_TYPE_PRECOMPUTE_INIT
10024 | OPTI_TYPE_PRECOMPUTE_MERKLE
10025 | OPTI_TYPE_EARLY_SKIP
10026 | OPTI_TYPE_NOT_ITERATED
10027 | OPTI_TYPE_APPENDED_SALT
10028 | OPTI_TYPE_RAW_HASH;
10029 dgst_pos0 = 3;
10030 dgst_pos1 = 7;
10031 dgst_pos2 = 2;
10032 dgst_pos3 = 6;
10033 break;
10034
10035 case 10700: hash_type = HASH_TYPE_PDFU32;
10036 salt_type = SALT_TYPE_EMBEDDED;
10037 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10038 opts_type = OPTS_TYPE_PT_GENERATE_LE
10039 | OPTS_TYPE_HASH_COPY;
10040 kern_type = KERN_TYPE_PDF17L8;
10041 dgst_size = DGST_SIZE_4_8;
10042 parse_func = pdf17l8_parse_hash;
10043 sort_by_digest = sort_by_digest_4_8;
10044 opti_type = OPTI_TYPE_ZERO_BYTE
10045 | OPTI_TYPE_NOT_ITERATED;
10046 dgst_pos0 = 0;
10047 dgst_pos1 = 1;
10048 dgst_pos2 = 2;
10049 dgst_pos3 = 3;
10050 break;
10051
10052 case 10800: hash_type = HASH_TYPE_SHA384;
10053 salt_type = SALT_TYPE_NONE;
10054 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10055 opts_type = OPTS_TYPE_PT_GENERATE_BE
10056 | OPTS_TYPE_PT_ADD80
10057 | OPTS_TYPE_PT_ADDBITS15;
10058 kern_type = KERN_TYPE_SHA384;
10059 dgst_size = DGST_SIZE_8_8;
10060 parse_func = sha384_parse_hash;
10061 sort_by_digest = sort_by_digest_8_8;
10062 opti_type = OPTI_TYPE_ZERO_BYTE
10063 | OPTI_TYPE_PRECOMPUTE_INIT
10064 | OPTI_TYPE_PRECOMPUTE_MERKLE
10065 | OPTI_TYPE_EARLY_SKIP
10066 | OPTI_TYPE_NOT_ITERATED
10067 | OPTI_TYPE_NOT_SALTED
10068 | OPTI_TYPE_USES_BITS_64
10069 | OPTI_TYPE_RAW_HASH;
10070 dgst_pos0 = 6;
10071 dgst_pos1 = 7;
10072 dgst_pos2 = 4;
10073 dgst_pos3 = 5;
10074 break;
10075
10076 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10077 salt_type = SALT_TYPE_EMBEDDED;
10078 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10079 opts_type = OPTS_TYPE_PT_GENERATE_LE
10080 | OPTS_TYPE_ST_BASE64
10081 | OPTS_TYPE_HASH_COPY;
10082 kern_type = KERN_TYPE_PBKDF2_SHA256;
10083 dgst_size = DGST_SIZE_4_32;
10084 parse_func = pbkdf2_sha256_parse_hash;
10085 sort_by_digest = sort_by_digest_4_32;
10086 opti_type = OPTI_TYPE_ZERO_BYTE
10087 | OPTI_TYPE_SLOW_HASH_SIMD;
10088 dgst_pos0 = 0;
10089 dgst_pos1 = 1;
10090 dgst_pos2 = 2;
10091 dgst_pos3 = 3;
10092 break;
10093
10094 case 11000: hash_type = HASH_TYPE_MD5;
10095 salt_type = SALT_TYPE_INTERN;
10096 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10097 opts_type = OPTS_TYPE_PT_GENERATE_LE
10098 | OPTS_TYPE_PT_ADD80;
10099 kern_type = KERN_TYPE_PRESTASHOP;
10100 dgst_size = DGST_SIZE_4_4;
10101 parse_func = prestashop_parse_hash;
10102 sort_by_digest = sort_by_digest_4_4;
10103 opti_type = OPTI_TYPE_ZERO_BYTE
10104 | OPTI_TYPE_PRECOMPUTE_INIT
10105 | OPTI_TYPE_NOT_ITERATED
10106 | OPTI_TYPE_PREPENDED_SALT;
10107 dgst_pos0 = 0;
10108 dgst_pos1 = 3;
10109 dgst_pos2 = 2;
10110 dgst_pos3 = 1;
10111 break;
10112
10113 case 11100: hash_type = HASH_TYPE_MD5;
10114 salt_type = SALT_TYPE_EMBEDDED;
10115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10116 opts_type = OPTS_TYPE_PT_GENERATE_LE
10117 | OPTS_TYPE_ST_ADD80;
10118 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10119 dgst_size = DGST_SIZE_4_4;
10120 parse_func = postgresql_auth_parse_hash;
10121 sort_by_digest = sort_by_digest_4_4;
10122 opti_type = OPTI_TYPE_ZERO_BYTE
10123 | OPTI_TYPE_PRECOMPUTE_INIT
10124 | OPTI_TYPE_PRECOMPUTE_MERKLE
10125 | OPTI_TYPE_EARLY_SKIP;
10126 dgst_pos0 = 0;
10127 dgst_pos1 = 3;
10128 dgst_pos2 = 2;
10129 dgst_pos3 = 1;
10130 break;
10131
10132 case 11200: hash_type = HASH_TYPE_SHA1;
10133 salt_type = SALT_TYPE_EMBEDDED;
10134 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10135 opts_type = OPTS_TYPE_PT_GENERATE_BE
10136 | OPTS_TYPE_PT_ADD80
10137 | OPTS_TYPE_ST_HEX;
10138 kern_type = KERN_TYPE_MYSQL_AUTH;
10139 dgst_size = DGST_SIZE_4_5;
10140 parse_func = mysql_auth_parse_hash;
10141 sort_by_digest = sort_by_digest_4_5;
10142 opti_type = OPTI_TYPE_ZERO_BYTE
10143 | OPTI_TYPE_EARLY_SKIP;
10144 dgst_pos0 = 3;
10145 dgst_pos1 = 4;
10146 dgst_pos2 = 2;
10147 dgst_pos3 = 1;
10148 break;
10149
10150 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10151 salt_type = SALT_TYPE_EMBEDDED;
10152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10153 opts_type = OPTS_TYPE_PT_GENERATE_LE
10154 | OPTS_TYPE_ST_HEX
10155 | OPTS_TYPE_ST_ADD80;
10156 kern_type = KERN_TYPE_BITCOIN_WALLET;
10157 dgst_size = DGST_SIZE_4_4;
10158 parse_func = bitcoin_wallet_parse_hash;
10159 sort_by_digest = sort_by_digest_4_4;
10160 opti_type = OPTI_TYPE_ZERO_BYTE;
10161 dgst_pos0 = 0;
10162 dgst_pos1 = 1;
10163 dgst_pos2 = 2;
10164 dgst_pos3 = 3;
10165 break;
10166
10167 case 11400: hash_type = HASH_TYPE_MD5;
10168 salt_type = SALT_TYPE_EMBEDDED;
10169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10170 opts_type = OPTS_TYPE_PT_GENERATE_LE
10171 | OPTS_TYPE_PT_ADD80
10172 | OPTS_TYPE_HASH_COPY;
10173 kern_type = KERN_TYPE_SIP_AUTH;
10174 dgst_size = DGST_SIZE_4_4;
10175 parse_func = sip_auth_parse_hash;
10176 sort_by_digest = sort_by_digest_4_4;
10177 opti_type = OPTI_TYPE_ZERO_BYTE;
10178 dgst_pos0 = 0;
10179 dgst_pos1 = 3;
10180 dgst_pos2 = 2;
10181 dgst_pos3 = 1;
10182 break;
10183
10184 case 11500: hash_type = HASH_TYPE_CRC32;
10185 salt_type = SALT_TYPE_INTERN;
10186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10187 opts_type = OPTS_TYPE_PT_GENERATE_LE
10188 | OPTS_TYPE_ST_GENERATE_LE
10189 | OPTS_TYPE_ST_HEX;
10190 kern_type = KERN_TYPE_CRC32;
10191 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10192 parse_func = crc32_parse_hash;
10193 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10194 opti_type = OPTI_TYPE_ZERO_BYTE;
10195 dgst_pos0 = 0;
10196 dgst_pos1 = 1;
10197 dgst_pos2 = 2;
10198 dgst_pos3 = 3;
10199 break;
10200
10201 case 11600: hash_type = HASH_TYPE_AES;
10202 salt_type = SALT_TYPE_EMBEDDED;
10203 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10204 opts_type = OPTS_TYPE_PT_GENERATE_LE
10205 | OPTS_TYPE_PT_NEVERCRACK;
10206 kern_type = KERN_TYPE_SEVEN_ZIP;
10207 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10208 parse_func = seven_zip_parse_hash;
10209 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10210 opti_type = OPTI_TYPE_ZERO_BYTE;
10211 dgst_pos0 = 0;
10212 dgst_pos1 = 1;
10213 dgst_pos2 = 2;
10214 dgst_pos3 = 3;
10215 break;
10216
10217 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10218 salt_type = SALT_TYPE_NONE;
10219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10220 opts_type = OPTS_TYPE_PT_GENERATE_LE
10221 | OPTS_TYPE_PT_ADD01;
10222 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10223 dgst_size = DGST_SIZE_4_8;
10224 parse_func = gost2012sbog_256_parse_hash;
10225 sort_by_digest = sort_by_digest_4_8;
10226 opti_type = OPTI_TYPE_ZERO_BYTE;
10227 dgst_pos0 = 0;
10228 dgst_pos1 = 1;
10229 dgst_pos2 = 2;
10230 dgst_pos3 = 3;
10231 break;
10232
10233 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10234 salt_type = SALT_TYPE_NONE;
10235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10236 opts_type = OPTS_TYPE_PT_GENERATE_LE
10237 | OPTS_TYPE_PT_ADD01;
10238 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10239 dgst_size = DGST_SIZE_4_16;
10240 parse_func = gost2012sbog_512_parse_hash;
10241 sort_by_digest = sort_by_digest_4_16;
10242 opti_type = OPTI_TYPE_ZERO_BYTE;
10243 dgst_pos0 = 0;
10244 dgst_pos1 = 1;
10245 dgst_pos2 = 2;
10246 dgst_pos3 = 3;
10247 break;
10248
10249 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10250 salt_type = SALT_TYPE_EMBEDDED;
10251 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10252 opts_type = OPTS_TYPE_PT_GENERATE_LE
10253 | OPTS_TYPE_ST_BASE64
10254 | OPTS_TYPE_HASH_COPY;
10255 kern_type = KERN_TYPE_PBKDF2_MD5;
10256 dgst_size = DGST_SIZE_4_32;
10257 parse_func = pbkdf2_md5_parse_hash;
10258 sort_by_digest = sort_by_digest_4_32;
10259 opti_type = OPTI_TYPE_ZERO_BYTE
10260 | OPTI_TYPE_SLOW_HASH_SIMD;
10261 dgst_pos0 = 0;
10262 dgst_pos1 = 1;
10263 dgst_pos2 = 2;
10264 dgst_pos3 = 3;
10265 break;
10266
10267 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10268 salt_type = SALT_TYPE_EMBEDDED;
10269 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10270 opts_type = OPTS_TYPE_PT_GENERATE_LE
10271 | OPTS_TYPE_ST_BASE64
10272 | OPTS_TYPE_HASH_COPY;
10273 kern_type = KERN_TYPE_PBKDF2_SHA1;
10274 dgst_size = DGST_SIZE_4_32;
10275 parse_func = pbkdf2_sha1_parse_hash;
10276 sort_by_digest = sort_by_digest_4_32;
10277 opti_type = OPTI_TYPE_ZERO_BYTE
10278 | OPTI_TYPE_SLOW_HASH_SIMD;
10279 dgst_pos0 = 0;
10280 dgst_pos1 = 1;
10281 dgst_pos2 = 2;
10282 dgst_pos3 = 3;
10283 break;
10284
10285 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10286 salt_type = SALT_TYPE_EMBEDDED;
10287 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10288 opts_type = OPTS_TYPE_PT_GENERATE_LE
10289 | OPTS_TYPE_ST_BASE64
10290 | OPTS_TYPE_HASH_COPY;
10291 kern_type = KERN_TYPE_PBKDF2_SHA512;
10292 dgst_size = DGST_SIZE_8_16;
10293 parse_func = pbkdf2_sha512_parse_hash;
10294 sort_by_digest = sort_by_digest_8_16;
10295 opti_type = OPTI_TYPE_ZERO_BYTE
10296 | OPTI_TYPE_USES_BITS_64
10297 | OPTI_TYPE_SLOW_HASH_SIMD;
10298 dgst_pos0 = 0;
10299 dgst_pos1 = 1;
10300 dgst_pos2 = 2;
10301 dgst_pos3 = 3;
10302 break;
10303
10304 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10305 salt_type = SALT_TYPE_EMBEDDED;
10306 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10307 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10308 kern_type = KERN_TYPE_ECRYPTFS;
10309 dgst_size = DGST_SIZE_8_8;
10310 parse_func = ecryptfs_parse_hash;
10311 sort_by_digest = sort_by_digest_8_8;
10312 opti_type = OPTI_TYPE_ZERO_BYTE
10313 | OPTI_TYPE_USES_BITS_64;
10314 dgst_pos0 = 0;
10315 dgst_pos1 = 1;
10316 dgst_pos2 = 2;
10317 dgst_pos3 = 3;
10318 break;
10319
10320 case 12300: hash_type = HASH_TYPE_ORACLET;
10321 salt_type = SALT_TYPE_EMBEDDED;
10322 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10323 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10324 kern_type = KERN_TYPE_ORACLET;
10325 dgst_size = DGST_SIZE_8_16;
10326 parse_func = oraclet_parse_hash;
10327 sort_by_digest = sort_by_digest_8_16;
10328 opti_type = OPTI_TYPE_ZERO_BYTE
10329 | OPTI_TYPE_USES_BITS_64;
10330 dgst_pos0 = 0;
10331 dgst_pos1 = 1;
10332 dgst_pos2 = 2;
10333 dgst_pos3 = 3;
10334 break;
10335
10336 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10337 salt_type = SALT_TYPE_EMBEDDED;
10338 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10339 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10340 kern_type = KERN_TYPE_BSDICRYPT;
10341 dgst_size = DGST_SIZE_4_4;
10342 parse_func = bsdicrypt_parse_hash;
10343 sort_by_digest = sort_by_digest_4_4;
10344 opti_type = OPTI_TYPE_ZERO_BYTE
10345 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10346 dgst_pos0 = 0;
10347 dgst_pos1 = 1;
10348 dgst_pos2 = 2;
10349 dgst_pos3 = 3;
10350 break;
10351
10352 case 12500: hash_type = HASH_TYPE_RAR3HP;
10353 salt_type = SALT_TYPE_EMBEDDED;
10354 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10355 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10356 kern_type = KERN_TYPE_RAR3;
10357 dgst_size = DGST_SIZE_4_4;
10358 parse_func = rar3hp_parse_hash;
10359 sort_by_digest = sort_by_digest_4_4;
10360 opti_type = OPTI_TYPE_ZERO_BYTE;
10361 dgst_pos0 = 0;
10362 dgst_pos1 = 1;
10363 dgst_pos2 = 2;
10364 dgst_pos3 = 3;
10365 break;
10366
10367 case 12600: hash_type = HASH_TYPE_SHA256;
10368 salt_type = SALT_TYPE_INTERN;
10369 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10370 opts_type = OPTS_TYPE_PT_GENERATE_BE
10371 | OPTS_TYPE_PT_ADD80;
10372 kern_type = KERN_TYPE_CF10;
10373 dgst_size = DGST_SIZE_4_8;
10374 parse_func = cf10_parse_hash;
10375 sort_by_digest = sort_by_digest_4_8;
10376 opti_type = OPTI_TYPE_ZERO_BYTE
10377 | OPTI_TYPE_PRECOMPUTE_INIT
10378 | OPTI_TYPE_EARLY_SKIP
10379 | OPTI_TYPE_NOT_ITERATED;
10380 dgst_pos0 = 3;
10381 dgst_pos1 = 7;
10382 dgst_pos2 = 2;
10383 dgst_pos3 = 6;
10384 break;
10385
10386 case 12700: hash_type = HASH_TYPE_AES;
10387 salt_type = SALT_TYPE_EMBEDDED;
10388 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10389 opts_type = OPTS_TYPE_PT_GENERATE_LE
10390 | OPTS_TYPE_HASH_COPY;
10391 kern_type = KERN_TYPE_MYWALLET;
10392 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10393 parse_func = mywallet_parse_hash;
10394 sort_by_digest = sort_by_digest_4_5;
10395 opti_type = OPTI_TYPE_ZERO_BYTE;
10396 dgst_pos0 = 0;
10397 dgst_pos1 = 1;
10398 dgst_pos2 = 2;
10399 dgst_pos3 = 3;
10400 break;
10401
10402 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10403 salt_type = SALT_TYPE_EMBEDDED;
10404 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10405 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10406 kern_type = KERN_TYPE_MS_DRSR;
10407 dgst_size = DGST_SIZE_4_8;
10408 parse_func = ms_drsr_parse_hash;
10409 sort_by_digest = sort_by_digest_4_8;
10410 opti_type = OPTI_TYPE_ZERO_BYTE;
10411 dgst_pos0 = 0;
10412 dgst_pos1 = 1;
10413 dgst_pos2 = 2;
10414 dgst_pos3 = 3;
10415 break;
10416
10417 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10418 salt_type = SALT_TYPE_EMBEDDED;
10419 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10420 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10421 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10422 dgst_size = DGST_SIZE_4_8;
10423 parse_func = androidfde_samsung_parse_hash;
10424 sort_by_digest = sort_by_digest_4_8;
10425 opti_type = OPTI_TYPE_ZERO_BYTE;
10426 dgst_pos0 = 0;
10427 dgst_pos1 = 1;
10428 dgst_pos2 = 2;
10429 dgst_pos3 = 3;
10430 break;
10431
10432 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10433 salt_type = SALT_TYPE_EMBEDDED;
10434 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10435 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10436 kern_type = KERN_TYPE_RAR5;
10437 dgst_size = DGST_SIZE_4_4;
10438 parse_func = rar5_parse_hash;
10439 sort_by_digest = sort_by_digest_4_4;
10440 opti_type = OPTI_TYPE_ZERO_BYTE;
10441 dgst_pos0 = 0;
10442 dgst_pos1 = 1;
10443 dgst_pos2 = 2;
10444 dgst_pos3 = 3;
10445 break;
10446
10447 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10448 salt_type = SALT_TYPE_EMBEDDED;
10449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10450 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10451 kern_type = KERN_TYPE_KRB5TGS;
10452 dgst_size = DGST_SIZE_4_4;
10453 parse_func = krb5tgs_parse_hash;
10454 sort_by_digest = sort_by_digest_4_4;
10455 opti_type = OPTI_TYPE_ZERO_BYTE
10456 | OPTI_TYPE_NOT_ITERATED;
10457 dgst_pos0 = 0;
10458 dgst_pos1 = 1;
10459 dgst_pos2 = 2;
10460 dgst_pos3 = 3;
10461 break;
10462
10463 case 13200: hash_type = HASH_TYPE_AES;
10464 salt_type = SALT_TYPE_EMBEDDED;
10465 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10466 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10467 kern_type = KERN_TYPE_AXCRYPT;
10468 dgst_size = DGST_SIZE_4_4;
10469 parse_func = axcrypt_parse_hash;
10470 sort_by_digest = sort_by_digest_4_4;
10471 opti_type = OPTI_TYPE_ZERO_BYTE;
10472 dgst_pos0 = 0;
10473 dgst_pos1 = 1;
10474 dgst_pos2 = 2;
10475 dgst_pos3 = 3;
10476 break;
10477
10478 case 13300: hash_type = HASH_TYPE_SHA1;
10479 salt_type = SALT_TYPE_NONE;
10480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10481 opts_type = OPTS_TYPE_PT_GENERATE_BE
10482 | OPTS_TYPE_PT_ADD80
10483 | OPTS_TYPE_PT_ADDBITS15;
10484 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10485 dgst_size = DGST_SIZE_4_5;
10486 parse_func = sha1axcrypt_parse_hash;
10487 sort_by_digest = sort_by_digest_4_5;
10488 opti_type = OPTI_TYPE_ZERO_BYTE
10489 | OPTI_TYPE_PRECOMPUTE_INIT
10490 | OPTI_TYPE_EARLY_SKIP
10491 | OPTI_TYPE_NOT_ITERATED
10492 | OPTI_TYPE_NOT_SALTED;
10493 dgst_pos0 = 0;
10494 dgst_pos1 = 4;
10495 dgst_pos2 = 3;
10496 dgst_pos3 = 2;
10497 break;
10498
10499 case 13400: hash_type = HASH_TYPE_AES;
10500 salt_type = SALT_TYPE_EMBEDDED;
10501 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10502 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10503 kern_type = KERN_TYPE_KEEPASS;
10504 dgst_size = DGST_SIZE_4_4;
10505 parse_func = keepass_parse_hash;
10506 sort_by_digest = sort_by_digest_4_4;
10507 opti_type = OPTI_TYPE_ZERO_BYTE;
10508 dgst_pos0 = 0;
10509 dgst_pos1 = 1;
10510 dgst_pos2 = 2;
10511 dgst_pos3 = 3;
10512 break;
10513
10514 case 13500: hash_type = HASH_TYPE_SHA1;
10515 salt_type = SALT_TYPE_EMBEDDED;
10516 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10517 opts_type = OPTS_TYPE_PT_GENERATE_BE
10518 | OPTS_TYPE_PT_UNICODE
10519 | OPTS_TYPE_PT_ADD80;
10520 kern_type = KERN_TYPE_PSTOKEN;
10521 dgst_size = DGST_SIZE_4_5;
10522 parse_func = pstoken_parse_hash;
10523 sort_by_digest = sort_by_digest_4_5;
10524 opti_type = OPTI_TYPE_ZERO_BYTE
10525 | OPTI_TYPE_PRECOMPUTE_INIT
10526 | OPTI_TYPE_EARLY_SKIP
10527 | OPTI_TYPE_NOT_ITERATED
10528 | OPTI_TYPE_PREPENDED_SALT
10529 | OPTI_TYPE_RAW_HASH;
10530 dgst_pos0 = 3;
10531 dgst_pos1 = 4;
10532 dgst_pos2 = 2;
10533 dgst_pos3 = 1;
10534 break;
10535
10536 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10537 salt_type = SALT_TYPE_EMBEDDED;
10538 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10539 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10540 kern_type = KERN_TYPE_ZIP2;
10541 dgst_size = DGST_SIZE_4_4;
10542 parse_func = zip2_parse_hash;
10543 sort_by_digest = sort_by_digest_4_4;
10544 opti_type = OPTI_TYPE_ZERO_BYTE;
10545 dgst_pos0 = 0;
10546 dgst_pos1 = 1;
10547 dgst_pos2 = 2;
10548 dgst_pos3 = 3;
10549 break;
10550
10551 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10552 salt_type = SALT_TYPE_EMBEDDED;
10553 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10554 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10555 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10556 dgst_size = DGST_SIZE_4_5;
10557 parse_func = veracrypt_parse_hash_655331;
10558 sort_by_digest = sort_by_digest_4_5;
10559 opti_type = OPTI_TYPE_ZERO_BYTE;
10560 dgst_pos0 = 0;
10561 dgst_pos1 = 1;
10562 dgst_pos2 = 2;
10563 dgst_pos3 = 3;
10564 break;
10565
10566 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10567 salt_type = SALT_TYPE_EMBEDDED;
10568 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10569 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10570 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10571 dgst_size = DGST_SIZE_4_5;
10572 parse_func = veracrypt_parse_hash_655331;
10573 sort_by_digest = sort_by_digest_4_5;
10574 opti_type = OPTI_TYPE_ZERO_BYTE;
10575 dgst_pos0 = 0;
10576 dgst_pos1 = 1;
10577 dgst_pos2 = 2;
10578 dgst_pos3 = 3;
10579 break;
10580
10581 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10582 salt_type = SALT_TYPE_EMBEDDED;
10583 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10584 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10585 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10586 dgst_size = DGST_SIZE_4_5;
10587 parse_func = veracrypt_parse_hash_655331;
10588 sort_by_digest = sort_by_digest_4_5;
10589 opti_type = OPTI_TYPE_ZERO_BYTE;
10590 dgst_pos0 = 0;
10591 dgst_pos1 = 1;
10592 dgst_pos2 = 2;
10593 dgst_pos3 = 3;
10594 break;
10595
10596 case 13721: hash_type = HASH_TYPE_SHA512;
10597 salt_type = SALT_TYPE_EMBEDDED;
10598 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10599 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10600 kern_type = KERN_TYPE_TCSHA512_XTS512;
10601 dgst_size = DGST_SIZE_8_8;
10602 parse_func = veracrypt_parse_hash_500000;
10603 sort_by_digest = sort_by_digest_8_8;
10604 opti_type = OPTI_TYPE_ZERO_BYTE
10605 | OPTI_TYPE_USES_BITS_64;
10606 dgst_pos0 = 0;
10607 dgst_pos1 = 1;
10608 dgst_pos2 = 2;
10609 dgst_pos3 = 3;
10610 break;
10611
10612 case 13722: hash_type = HASH_TYPE_SHA512;
10613 salt_type = SALT_TYPE_EMBEDDED;
10614 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10615 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10616 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10617 dgst_size = DGST_SIZE_8_8;
10618 parse_func = veracrypt_parse_hash_500000;
10619 sort_by_digest = sort_by_digest_8_8;
10620 opti_type = OPTI_TYPE_ZERO_BYTE
10621 | OPTI_TYPE_USES_BITS_64;
10622 dgst_pos0 = 0;
10623 dgst_pos1 = 1;
10624 dgst_pos2 = 2;
10625 dgst_pos3 = 3;
10626 break;
10627
10628 case 13723: hash_type = HASH_TYPE_SHA512;
10629 salt_type = SALT_TYPE_EMBEDDED;
10630 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10631 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10632 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10633 dgst_size = DGST_SIZE_8_8;
10634 parse_func = veracrypt_parse_hash_500000;
10635 sort_by_digest = sort_by_digest_8_8;
10636 opti_type = OPTI_TYPE_ZERO_BYTE
10637 | OPTI_TYPE_USES_BITS_64;
10638 dgst_pos0 = 0;
10639 dgst_pos1 = 1;
10640 dgst_pos2 = 2;
10641 dgst_pos3 = 3;
10642 break;
10643
10644 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10645 salt_type = SALT_TYPE_EMBEDDED;
10646 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10647 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10648 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10649 dgst_size = DGST_SIZE_4_8;
10650 parse_func = veracrypt_parse_hash_500000;
10651 sort_by_digest = sort_by_digest_4_8;
10652 opti_type = OPTI_TYPE_ZERO_BYTE;
10653 dgst_pos0 = 0;
10654 dgst_pos1 = 1;
10655 dgst_pos2 = 2;
10656 dgst_pos3 = 3;
10657 break;
10658
10659 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10660 salt_type = SALT_TYPE_EMBEDDED;
10661 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10662 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10663 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10664 dgst_size = DGST_SIZE_4_8;
10665 parse_func = veracrypt_parse_hash_500000;
10666 sort_by_digest = sort_by_digest_4_8;
10667 opti_type = OPTI_TYPE_ZERO_BYTE;
10668 dgst_pos0 = 0;
10669 dgst_pos1 = 1;
10670 dgst_pos2 = 2;
10671 dgst_pos3 = 3;
10672 break;
10673
10674 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10675 salt_type = SALT_TYPE_EMBEDDED;
10676 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10677 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10678 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10679 dgst_size = DGST_SIZE_4_8;
10680 parse_func = veracrypt_parse_hash_500000;
10681 sort_by_digest = sort_by_digest_4_8;
10682 opti_type = OPTI_TYPE_ZERO_BYTE;
10683 dgst_pos0 = 0;
10684 dgst_pos1 = 1;
10685 dgst_pos2 = 2;
10686 dgst_pos3 = 3;
10687 break;
10688
10689 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10690 salt_type = SALT_TYPE_EMBEDDED;
10691 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10692 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10693 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10694 dgst_size = DGST_SIZE_4_5;
10695 parse_func = veracrypt_parse_hash_327661;
10696 sort_by_digest = sort_by_digest_4_5;
10697 opti_type = OPTI_TYPE_ZERO_BYTE;
10698 dgst_pos0 = 0;
10699 dgst_pos1 = 1;
10700 dgst_pos2 = 2;
10701 dgst_pos3 = 3;
10702 break;
10703
10704 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10705 salt_type = SALT_TYPE_EMBEDDED;
10706 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10707 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10708 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10709 dgst_size = DGST_SIZE_4_5;
10710 parse_func = veracrypt_parse_hash_327661;
10711 sort_by_digest = sort_by_digest_4_5;
10712 opti_type = OPTI_TYPE_ZERO_BYTE;
10713 dgst_pos0 = 0;
10714 dgst_pos1 = 1;
10715 dgst_pos2 = 2;
10716 dgst_pos3 = 3;
10717 break;
10718
10719 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10720 salt_type = SALT_TYPE_EMBEDDED;
10721 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10722 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10723 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10724 dgst_size = DGST_SIZE_4_5;
10725 parse_func = veracrypt_parse_hash_327661;
10726 sort_by_digest = sort_by_digest_4_5;
10727 opti_type = OPTI_TYPE_ZERO_BYTE;
10728 dgst_pos0 = 0;
10729 dgst_pos1 = 1;
10730 dgst_pos2 = 2;
10731 dgst_pos3 = 3;
10732 break;
10733
10734 case 13751: hash_type = HASH_TYPE_SHA256;
10735 salt_type = SALT_TYPE_EMBEDDED;
10736 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10737 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10738 kern_type = KERN_TYPE_VCSHA256_XTS512;
10739 dgst_size = DGST_SIZE_4_8;
10740 parse_func = veracrypt_parse_hash_500000;
10741 sort_by_digest = sort_by_digest_4_8;
10742 opti_type = OPTI_TYPE_ZERO_BYTE;
10743 dgst_pos0 = 0;
10744 dgst_pos1 = 1;
10745 dgst_pos2 = 2;
10746 dgst_pos3 = 3;
10747 break;
10748
10749 case 13752: hash_type = HASH_TYPE_SHA256;
10750 salt_type = SALT_TYPE_EMBEDDED;
10751 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10752 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10753 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10754 dgst_size = DGST_SIZE_4_8;
10755 parse_func = veracrypt_parse_hash_500000;
10756 sort_by_digest = sort_by_digest_4_8;
10757 opti_type = OPTI_TYPE_ZERO_BYTE;
10758 dgst_pos0 = 0;
10759 dgst_pos1 = 1;
10760 dgst_pos2 = 2;
10761 dgst_pos3 = 3;
10762 break;
10763
10764 case 13753: hash_type = HASH_TYPE_SHA256;
10765 salt_type = SALT_TYPE_EMBEDDED;
10766 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10767 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10768 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10769 dgst_size = DGST_SIZE_4_8;
10770 parse_func = veracrypt_parse_hash_500000;
10771 sort_by_digest = sort_by_digest_4_8;
10772 opti_type = OPTI_TYPE_ZERO_BYTE;
10773 dgst_pos0 = 0;
10774 dgst_pos1 = 1;
10775 dgst_pos2 = 2;
10776 dgst_pos3 = 3;
10777 break;
10778
10779 case 13761: hash_type = HASH_TYPE_SHA256;
10780 salt_type = SALT_TYPE_EMBEDDED;
10781 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10782 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10783 kern_type = KERN_TYPE_VCSHA256_XTS512;
10784 dgst_size = DGST_SIZE_4_8;
10785 parse_func = veracrypt_parse_hash_200000;
10786 sort_by_digest = sort_by_digest_4_8;
10787 opti_type = OPTI_TYPE_ZERO_BYTE;
10788 dgst_pos0 = 0;
10789 dgst_pos1 = 1;
10790 dgst_pos2 = 2;
10791 dgst_pos3 = 3;
10792 break;
10793
10794 case 13762: hash_type = HASH_TYPE_SHA256;
10795 salt_type = SALT_TYPE_EMBEDDED;
10796 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10797 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10798 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10799 dgst_size = DGST_SIZE_4_8;
10800 parse_func = veracrypt_parse_hash_200000;
10801 sort_by_digest = sort_by_digest_4_8;
10802 opti_type = OPTI_TYPE_ZERO_BYTE;
10803 dgst_pos0 = 0;
10804 dgst_pos1 = 1;
10805 dgst_pos2 = 2;
10806 dgst_pos3 = 3;
10807 break;
10808
10809 case 13763: hash_type = HASH_TYPE_SHA256;
10810 salt_type = SALT_TYPE_EMBEDDED;
10811 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10812 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10813 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10814 dgst_size = DGST_SIZE_4_8;
10815 parse_func = veracrypt_parse_hash_200000;
10816 sort_by_digest = sort_by_digest_4_8;
10817 opti_type = OPTI_TYPE_ZERO_BYTE;
10818 dgst_pos0 = 0;
10819 dgst_pos1 = 1;
10820 dgst_pos2 = 2;
10821 dgst_pos3 = 3;
10822 break;
10823
10824
10825 default: usage_mini_print (PROGNAME); return (-1);
10826 }
10827
10828 /**
10829 * parser
10830 */
10831
10832 data.parse_func = parse_func;
10833
10834 /**
10835 * misc stuff
10836 */
10837
10838 if (hex_salt)
10839 {
10840 if (salt_type == SALT_TYPE_INTERN)
10841 {
10842 opts_type |= OPTS_TYPE_ST_HEX;
10843 }
10844 else
10845 {
10846 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10847
10848 return (-1);
10849 }
10850 }
10851
10852 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10853 | (salt_type == SALT_TYPE_EXTERN)
10854 | (salt_type == SALT_TYPE_EMBEDDED)
10855 | (salt_type == SALT_TYPE_VIRTUAL));
10856
10857 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10858
10859 data.hash_type = hash_type;
10860 data.attack_mode = attack_mode;
10861 data.attack_kern = attack_kern;
10862 data.attack_exec = attack_exec;
10863 data.kern_type = kern_type;
10864 data.opts_type = opts_type;
10865 data.dgst_size = dgst_size;
10866 data.salt_type = salt_type;
10867 data.isSalted = isSalted;
10868 data.sort_by_digest = sort_by_digest;
10869 data.dgst_pos0 = dgst_pos0;
10870 data.dgst_pos1 = dgst_pos1;
10871 data.dgst_pos2 = dgst_pos2;
10872 data.dgst_pos3 = dgst_pos3;
10873
10874 esalt_size = 0;
10875
10876 switch (hash_mode)
10877 {
10878 case 2500: esalt_size = sizeof (wpa_t); break;
10879 case 5300: esalt_size = sizeof (ikepsk_t); break;
10880 case 5400: esalt_size = sizeof (ikepsk_t); break;
10881 case 5500: esalt_size = sizeof (netntlm_t); break;
10882 case 5600: esalt_size = sizeof (netntlm_t); break;
10883 case 6211: esalt_size = sizeof (tc_t); break;
10884 case 6212: esalt_size = sizeof (tc_t); break;
10885 case 6213: esalt_size = sizeof (tc_t); break;
10886 case 6221: esalt_size = sizeof (tc_t); break;
10887 case 6222: esalt_size = sizeof (tc_t); break;
10888 case 6223: esalt_size = sizeof (tc_t); break;
10889 case 6231: esalt_size = sizeof (tc_t); break;
10890 case 6232: esalt_size = sizeof (tc_t); break;
10891 case 6233: esalt_size = sizeof (tc_t); break;
10892 case 6241: esalt_size = sizeof (tc_t); break;
10893 case 6242: esalt_size = sizeof (tc_t); break;
10894 case 6243: esalt_size = sizeof (tc_t); break;
10895 case 6600: esalt_size = sizeof (agilekey_t); break;
10896 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10897 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10898 case 7300: esalt_size = sizeof (rakp_t); break;
10899 case 7500: esalt_size = sizeof (krb5pa_t); break;
10900 case 8200: esalt_size = sizeof (cloudkey_t); break;
10901 case 8800: esalt_size = sizeof (androidfde_t); break;
10902 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10903 case 9400: esalt_size = sizeof (office2007_t); break;
10904 case 9500: esalt_size = sizeof (office2010_t); break;
10905 case 9600: esalt_size = sizeof (office2013_t); break;
10906 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10907 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10908 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10909 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10910 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10911 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10912 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10913 case 10200: esalt_size = sizeof (cram_md5_t); break;
10914 case 10400: esalt_size = sizeof (pdf_t); break;
10915 case 10410: esalt_size = sizeof (pdf_t); break;
10916 case 10420: esalt_size = sizeof (pdf_t); break;
10917 case 10500: esalt_size = sizeof (pdf_t); break;
10918 case 10600: esalt_size = sizeof (pdf_t); break;
10919 case 10700: esalt_size = sizeof (pdf_t); break;
10920 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10921 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10922 case 11400: esalt_size = sizeof (sip_t); break;
10923 case 11600: esalt_size = sizeof (seven_zip_t); break;
10924 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10925 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10926 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10927 case 13000: esalt_size = sizeof (rar5_t); break;
10928 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10929 case 13400: esalt_size = sizeof (keepass_t); break;
10930 case 13500: esalt_size = sizeof (pstoken_t); break;
10931 case 13600: esalt_size = sizeof (zip2_t); break;
10932 case 13711: esalt_size = sizeof (tc_t); break;
10933 case 13712: esalt_size = sizeof (tc_t); break;
10934 case 13713: esalt_size = sizeof (tc_t); break;
10935 case 13721: esalt_size = sizeof (tc_t); break;
10936 case 13722: esalt_size = sizeof (tc_t); break;
10937 case 13723: esalt_size = sizeof (tc_t); break;
10938 case 13731: esalt_size = sizeof (tc_t); break;
10939 case 13732: esalt_size = sizeof (tc_t); break;
10940 case 13733: esalt_size = sizeof (tc_t); break;
10941 case 13741: esalt_size = sizeof (tc_t); break;
10942 case 13742: esalt_size = sizeof (tc_t); break;
10943 case 13743: esalt_size = sizeof (tc_t); break;
10944 case 13751: esalt_size = sizeof (tc_t); break;
10945 case 13752: esalt_size = sizeof (tc_t); break;
10946 case 13753: esalt_size = sizeof (tc_t); break;
10947 case 13761: esalt_size = sizeof (tc_t); break;
10948 case 13762: esalt_size = sizeof (tc_t); break;
10949 case 13763: esalt_size = sizeof (tc_t); break;
10950 }
10951
10952 data.esalt_size = esalt_size;
10953
10954 /**
10955 * choose dictionary parser
10956 */
10957
10958 if (hash_type == HASH_TYPE_LM)
10959 {
10960 get_next_word_func = get_next_word_lm;
10961 }
10962 else if (opts_type & OPTS_TYPE_PT_UPPER)
10963 {
10964 get_next_word_func = get_next_word_uc;
10965 }
10966 else
10967 {
10968 get_next_word_func = get_next_word_std;
10969 }
10970
10971 /**
10972 * dictstat
10973 */
10974
10975 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10976
10977 #ifdef _POSIX
10978 size_t dictstat_nmemb = 0;
10979 #endif
10980
10981 #ifdef _WIN
10982 uint dictstat_nmemb = 0;
10983 #endif
10984
10985 char dictstat[256] = { 0 };
10986
10987 FILE *dictstat_fp = NULL;
10988
10989 if (keyspace == 0)
10990 {
10991 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10992
10993 dictstat_fp = fopen (dictstat, "rb");
10994
10995 if (dictstat_fp)
10996 {
10997 #ifdef _POSIX
10998 struct stat tmpstat;
10999
11000 fstat (fileno (dictstat_fp), &tmpstat);
11001 #endif
11002
11003 #ifdef _WIN
11004 struct stat64 tmpstat;
11005
11006 _fstat64 (fileno (dictstat_fp), &tmpstat);
11007 #endif
11008
11009 if (tmpstat.st_mtime < COMPTIME)
11010 {
11011 /* with v0.15 the format changed so we have to ensure user is using a good version
11012 since there is no version-header in the dictstat file */
11013
11014 fclose (dictstat_fp);
11015
11016 unlink (dictstat);
11017 }
11018 else
11019 {
11020 while (!feof (dictstat_fp))
11021 {
11022 dictstat_t d;
11023
11024 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11025
11026 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11027
11028 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11029 {
11030 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11031
11032 return -1;
11033 }
11034 }
11035
11036 fclose (dictstat_fp);
11037 }
11038 }
11039 }
11040
11041 /**
11042 * potfile
11043 */
11044
11045 char potfile[256] = { 0 };
11046
11047 if (potfile_path == NULL)
11048 {
11049 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11050 }
11051 else
11052 {
11053 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11054 }
11055
11056 data.pot_fp = NULL;
11057
11058 FILE *out_fp = NULL;
11059 FILE *pot_fp = NULL;
11060
11061 if (show == 1 || left == 1)
11062 {
11063 pot_fp = fopen (potfile, "rb");
11064
11065 if (pot_fp == NULL)
11066 {
11067 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11068
11069 return (-1);
11070 }
11071
11072 if (outfile != NULL)
11073 {
11074 if ((out_fp = fopen (outfile, "ab")) == NULL)
11075 {
11076 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11077
11078 fclose (pot_fp);
11079
11080 return (-1);
11081 }
11082 }
11083 else
11084 {
11085 out_fp = stdout;
11086 }
11087 }
11088 else
11089 {
11090 if (potfile_disable == 0)
11091 {
11092 pot_fp = fopen (potfile, "ab");
11093
11094 if (pot_fp == NULL)
11095 {
11096 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11097
11098 return (-1);
11099 }
11100
11101 data.pot_fp = pot_fp;
11102 }
11103 }
11104
11105 pot_t *pot = NULL;
11106
11107 uint pot_cnt = 0;
11108 uint pot_avail = 0;
11109
11110 if (show == 1 || left == 1)
11111 {
11112 SUPPRESS_OUTPUT = 1;
11113
11114 pot_avail = count_lines (pot_fp);
11115
11116 rewind (pot_fp);
11117
11118 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11119
11120 uint pot_hashes_avail = 0;
11121
11122 uint line_num = 0;
11123
11124 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11125
11126 while (!feof (pot_fp))
11127 {
11128 line_num++;
11129
11130 int line_len = fgetl (pot_fp, line_buf);
11131
11132 if (line_len == 0) continue;
11133
11134 char *plain_buf = line_buf + line_len;
11135
11136 pot_t *pot_ptr = &pot[pot_cnt];
11137
11138 hash_t *hashes_buf = &pot_ptr->hash;
11139
11140 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11141 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11142
11143 if (pot_cnt == pot_hashes_avail)
11144 {
11145 uint pos = 0;
11146
11147 for (pos = 0; pos < INCR_POT; pos++)
11148 {
11149 if ((pot_cnt + pos) >= pot_avail) break;
11150
11151 pot_t *tmp_pot = &pot[pot_cnt + pos];
11152
11153 hash_t *tmp_hash = &tmp_pot->hash;
11154
11155 tmp_hash->digest = mymalloc (dgst_size);
11156
11157 if (isSalted)
11158 {
11159 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11160 }
11161
11162 if (esalt_size)
11163 {
11164 tmp_hash->esalt = mymalloc (esalt_size);
11165 }
11166
11167 pot_hashes_avail++;
11168 }
11169 }
11170
11171 int plain_len = 0;
11172
11173 int parser_status;
11174
11175 int iter = MAX_CUT_TRIES;
11176
11177 do
11178 {
11179 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11180 {
11181 if (line_buf[i] == ':')
11182 {
11183 line_len--;
11184
11185 break;
11186 }
11187 }
11188
11189 if (data.hash_mode != 2500)
11190 {
11191 parser_status = parse_func (line_buf, line_len, hashes_buf);
11192 }
11193 else
11194 {
11195 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11196
11197 if (line_len > max_salt_size)
11198 {
11199 parser_status = PARSER_GLOBAL_LENGTH;
11200 }
11201 else
11202 {
11203 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11204
11205 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11206
11207 hashes_buf->salt->salt_len = line_len;
11208
11209 parser_status = PARSER_OK;
11210 }
11211 }
11212
11213 // if NOT parsed without error, we add the ":" to the plain
11214
11215 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11216 {
11217 plain_len++;
11218 plain_buf--;
11219 }
11220
11221 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11222
11223 if (parser_status < PARSER_GLOBAL_ZERO)
11224 {
11225 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11226
11227 continue;
11228 }
11229
11230 if (plain_len >= 255) continue;
11231
11232 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11233
11234 pot_ptr->plain_len = plain_len;
11235
11236 pot_cnt++;
11237 }
11238
11239 myfree (line_buf);
11240
11241 fclose (pot_fp);
11242
11243 SUPPRESS_OUTPUT = 0;
11244
11245 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11246 }
11247
11248 /**
11249 * word len
11250 */
11251
11252 uint pw_min = PW_MIN;
11253 uint pw_max = PW_MAX;
11254
11255 switch (hash_mode)
11256 {
11257 case 125: if (pw_max > 32) pw_max = 32;
11258 break;
11259 case 400: if (pw_max > 40) pw_max = 40;
11260 break;
11261 case 500: if (pw_max > 16) pw_max = 16;
11262 break;
11263 case 1500: if (pw_max > 8) pw_max = 8;
11264 break;
11265 case 1600: if (pw_max > 16) pw_max = 16;
11266 break;
11267 case 1800: if (pw_max > 16) pw_max = 16;
11268 break;
11269 case 2100: if (pw_max > 16) pw_max = 16;
11270 break;
11271 case 2500: if (pw_min < 8) pw_min = 8;
11272 break;
11273 case 3000: if (pw_max > 7) pw_max = 7;
11274 break;
11275 case 5200: if (pw_max > 24) pw_max = 24;
11276 break;
11277 case 5800: if (pw_max > 16) pw_max = 16;
11278 break;
11279 case 6300: if (pw_max > 16) pw_max = 16;
11280 break;
11281 case 7400: if (pw_max > 16) pw_max = 16;
11282 break;
11283 case 7500: if (pw_max > 8) pw_max = 8;
11284 break;
11285 case 7900: if (pw_max > 48) pw_max = 48;
11286 break;
11287 case 8500: if (pw_max > 8) pw_max = 8;
11288 break;
11289 case 8600: if (pw_max > 16) pw_max = 16;
11290 break;
11291 case 9710: pw_min = 5;
11292 pw_max = 5;
11293 break;
11294 case 9810: pw_min = 5;
11295 pw_max = 5;
11296 break;
11297 case 10410: pw_min = 5;
11298 pw_max = 5;
11299 break;
11300 case 10300: if (pw_max < 3) pw_min = 3;
11301 if (pw_max > 40) pw_max = 40;
11302 break;
11303 case 10500: if (pw_max < 3) pw_min = 3;
11304 if (pw_max > 40) pw_max = 40;
11305 break;
11306 case 10700: if (pw_max > 16) pw_max = 16;
11307 break;
11308 case 11300: if (pw_max > 40) pw_max = 40;
11309 break;
11310 case 11600: if (pw_max > 32) pw_max = 32;
11311 break;
11312 case 12500: if (pw_max > 20) pw_max = 20;
11313 break;
11314 case 12800: if (pw_max > 24) pw_max = 24;
11315 break;
11316 }
11317
11318 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11319 {
11320 switch (attack_kern)
11321 {
11322 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11323 break;
11324 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11325 break;
11326 }
11327 }
11328
11329 /**
11330 * charsets : keep them together for more easy maintainnce
11331 */
11332
11333 cs_t mp_sys[6] = { { { 0 }, 0 } };
11334 cs_t mp_usr[4] = { { { 0 }, 0 } };
11335
11336 mp_setup_sys (mp_sys);
11337
11338 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11339 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11340 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11341 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11342
11343 /**
11344 * load hashes, part I: find input mode, count hashes
11345 */
11346
11347 uint hashlist_mode = 0;
11348 uint hashlist_format = HLFMT_HASHCAT;
11349
11350 uint hashes_avail = 0;
11351
11352 if (benchmark == 0)
11353 {
11354 struct stat f;
11355
11356 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11357
11358 if ((hash_mode == 2500) ||
11359 (hash_mode == 5200) ||
11360 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11361 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11362 (hash_mode == 9000))
11363 {
11364 hashlist_mode = HL_MODE_ARG;
11365
11366 char *hashfile = myargv[optind];
11367
11368 data.hashfile = hashfile;
11369
11370 logfile_top_var_string ("target", hashfile);
11371 }
11372
11373 if (hashlist_mode == HL_MODE_ARG)
11374 {
11375 if (hash_mode == 2500)
11376 {
11377 struct stat st;
11378
11379 if (stat (data.hashfile, &st) == -1)
11380 {
11381 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11382
11383 return (-1);
11384 }
11385
11386 hashes_avail = st.st_size / sizeof (hccap_t);
11387 }
11388 else
11389 {
11390 hashes_avail = 1;
11391 }
11392 }
11393 else if (hashlist_mode == HL_MODE_FILE)
11394 {
11395 char *hashfile = myargv[optind];
11396
11397 data.hashfile = hashfile;
11398
11399 logfile_top_var_string ("target", hashfile);
11400
11401 FILE *fp = NULL;
11402
11403 if ((fp = fopen (hashfile, "rb")) == NULL)
11404 {
11405 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11406
11407 return (-1);
11408 }
11409
11410 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11411
11412 hashes_avail = count_lines (fp);
11413
11414 rewind (fp);
11415
11416 if (hashes_avail == 0)
11417 {
11418 log_error ("ERROR: hashfile is empty or corrupt");
11419
11420 fclose (fp);
11421
11422 return (-1);
11423 }
11424
11425 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11426
11427 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11428 {
11429 log_error ("ERROR: remove not supported in native hashfile-format mode");
11430
11431 fclose (fp);
11432
11433 return (-1);
11434 }
11435
11436 fclose (fp);
11437 }
11438 }
11439 else
11440 {
11441 hashlist_mode = HL_MODE_ARG;
11442
11443 hashes_avail = 1;
11444 }
11445
11446 if (hash_mode == 3000) hashes_avail *= 2;
11447
11448 data.hashlist_mode = hashlist_mode;
11449 data.hashlist_format = hashlist_format;
11450
11451 logfile_top_uint (hashlist_mode);
11452 logfile_top_uint (hashlist_format);
11453
11454 /**
11455 * load hashes, part II: allocate required memory, set pointers
11456 */
11457
11458 hash_t *hashes_buf = NULL;
11459 void *digests_buf = NULL;
11460 salt_t *salts_buf = NULL;
11461 void *esalts_buf = NULL;
11462
11463 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11464
11465 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11466
11467 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11468 {
11469 u32 hash_pos;
11470
11471 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11472 {
11473 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11474
11475 hashes_buf[hash_pos].hash_info = hash_info;
11476
11477 if (username && (remove || show || left))
11478 {
11479 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11480 }
11481
11482 if (benchmark)
11483 {
11484 hash_info->orighash = (char *) mymalloc (256);
11485 }
11486 }
11487 }
11488
11489 if (isSalted)
11490 {
11491 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11492
11493 if (esalt_size)
11494 {
11495 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11496 }
11497 }
11498 else
11499 {
11500 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11501 }
11502
11503 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11504 {
11505 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11506
11507 if (isSalted)
11508 {
11509 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11510
11511 if (esalt_size)
11512 {
11513 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11514 }
11515 }
11516 else
11517 {
11518 hashes_buf[hash_pos].salt = &salts_buf[0];
11519 }
11520 }
11521
11522 /**
11523 * load hashes, part III: parse hashes or generate them if benchmark
11524 */
11525
11526 uint hashes_cnt = 0;
11527
11528 if (benchmark == 0)
11529 {
11530 if (keyspace == 1)
11531 {
11532 // useless to read hash file for keyspace, cheat a little bit w/ optind
11533 }
11534 else if (hashes_avail == 0)
11535 {
11536 }
11537 else if (hashlist_mode == HL_MODE_ARG)
11538 {
11539 char *input_buf = myargv[optind];
11540
11541 uint input_len = strlen (input_buf);
11542
11543 logfile_top_var_string ("target", input_buf);
11544
11545 char *hash_buf = NULL;
11546 int hash_len = 0;
11547
11548 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11549
11550 bool hash_fmt_error = 0;
11551
11552 if (hash_len < 1) hash_fmt_error = 1;
11553 if (hash_buf == NULL) hash_fmt_error = 1;
11554
11555 if (hash_fmt_error)
11556 {
11557 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11558 }
11559 else
11560 {
11561 if (opts_type & OPTS_TYPE_HASH_COPY)
11562 {
11563 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11564
11565 hash_info_tmp->orighash = mystrdup (hash_buf);
11566 }
11567
11568 if (isSalted)
11569 {
11570 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11571 }
11572
11573 int parser_status = PARSER_OK;
11574
11575 if (hash_mode == 2500)
11576 {
11577 if (hash_len == 0)
11578 {
11579 log_error ("ERROR: hccap file not specified");
11580
11581 return (-1);
11582 }
11583
11584 hashlist_mode = HL_MODE_FILE;
11585
11586 data.hashlist_mode = hashlist_mode;
11587
11588 FILE *fp = fopen (hash_buf, "rb");
11589
11590 if (fp == NULL)
11591 {
11592 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11593
11594 return (-1);
11595 }
11596
11597 if (hashes_avail < 1)
11598 {
11599 log_error ("ERROR: hccap file is empty or corrupt");
11600
11601 fclose (fp);
11602
11603 return (-1);
11604 }
11605
11606 uint hccap_size = sizeof (hccap_t);
11607
11608 char *in = (char *) mymalloc (hccap_size);
11609
11610 while (!feof (fp))
11611 {
11612 int n = fread (in, hccap_size, 1, fp);
11613
11614 if (n != 1)
11615 {
11616 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11617
11618 break;
11619 }
11620
11621 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11622
11623 if (parser_status != PARSER_OK)
11624 {
11625 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11626
11627 continue;
11628 }
11629
11630 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11631
11632 if ((show == 1) || (left == 1))
11633 {
11634 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11635
11636 char *salt_ptr = (char *) tmp_salt->salt_buf;
11637
11638 int cur_pos = tmp_salt->salt_len;
11639 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11640
11641 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11642
11643 // do the appending task
11644
11645 snprintf (salt_ptr + cur_pos,
11646 rem_len,
11647 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11648 wpa->orig_mac1[0],
11649 wpa->orig_mac1[1],
11650 wpa->orig_mac1[2],
11651 wpa->orig_mac1[3],
11652 wpa->orig_mac1[4],
11653 wpa->orig_mac1[5],
11654 wpa->orig_mac2[0],
11655 wpa->orig_mac2[1],
11656 wpa->orig_mac2[2],
11657 wpa->orig_mac2[3],
11658 wpa->orig_mac2[4],
11659 wpa->orig_mac2[5]);
11660
11661 // memset () the remaining part of the salt
11662
11663 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11664 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11665
11666 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11667
11668 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11669 }
11670
11671 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);
11672 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);
11673
11674 hashes_cnt++;
11675 }
11676
11677 fclose (fp);
11678
11679 myfree (in);
11680 }
11681 else if (hash_mode == 3000)
11682 {
11683 if (hash_len == 32)
11684 {
11685 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11686
11687 hash_t *lm_hash_left = NULL;
11688
11689 if (parser_status == PARSER_OK)
11690 {
11691 lm_hash_left = &hashes_buf[hashes_cnt];
11692
11693 hashes_cnt++;
11694 }
11695 else
11696 {
11697 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11698 }
11699
11700 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11701
11702 hash_t *lm_hash_right = NULL;
11703
11704 if (parser_status == PARSER_OK)
11705 {
11706 lm_hash_right = &hashes_buf[hashes_cnt];
11707
11708 hashes_cnt++;
11709 }
11710 else
11711 {
11712 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11713 }
11714
11715 // show / left
11716
11717 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11718 {
11719 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);
11720 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);
11721 }
11722 }
11723 else
11724 {
11725 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11726
11727 if (parser_status == PARSER_OK)
11728 {
11729 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11730 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11731 }
11732
11733 if (parser_status == PARSER_OK)
11734 {
11735 hashes_cnt++;
11736 }
11737 else
11738 {
11739 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11740 }
11741 }
11742 }
11743 else
11744 {
11745 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11746
11747 if (parser_status == PARSER_OK)
11748 {
11749 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11750 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11751 }
11752
11753 if (parser_status == PARSER_OK)
11754 {
11755 hashes_cnt++;
11756 }
11757 else
11758 {
11759 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11760 }
11761 }
11762 }
11763 }
11764 else if (hashlist_mode == HL_MODE_FILE)
11765 {
11766 char *hashfile = data.hashfile;
11767
11768 FILE *fp;
11769
11770 if ((fp = fopen (hashfile, "rb")) == NULL)
11771 {
11772 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11773
11774 return (-1);
11775 }
11776
11777 uint line_num = 0;
11778
11779 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11780
11781 while (!feof (fp))
11782 {
11783 line_num++;
11784
11785 int line_len = fgetl (fp, line_buf);
11786
11787 if (line_len == 0) continue;
11788
11789 char *hash_buf = NULL;
11790 int hash_len = 0;
11791
11792 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11793
11794 bool hash_fmt_error = 0;
11795
11796 if (hash_len < 1) hash_fmt_error = 1;
11797 if (hash_buf == NULL) hash_fmt_error = 1;
11798
11799 if (hash_fmt_error)
11800 {
11801 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11802
11803 continue;
11804 }
11805
11806 if (username)
11807 {
11808 char *user_buf = NULL;
11809 int user_len = 0;
11810
11811 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11812
11813 if (remove || show)
11814 {
11815 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11816
11817 *user = (user_t *) mymalloc (sizeof (user_t));
11818
11819 user_t *user_ptr = *user;
11820
11821 if (user_buf != NULL)
11822 {
11823 user_ptr->user_name = mystrdup (user_buf);
11824 }
11825 else
11826 {
11827 user_ptr->user_name = mystrdup ("");
11828 }
11829
11830 user_ptr->user_len = user_len;
11831 }
11832 }
11833
11834 if (opts_type & OPTS_TYPE_HASH_COPY)
11835 {
11836 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11837
11838 hash_info_tmp->orighash = mystrdup (hash_buf);
11839 }
11840
11841 if (isSalted)
11842 {
11843 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11844 }
11845
11846 if (hash_mode == 3000)
11847 {
11848 if (hash_len == 32)
11849 {
11850 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11851
11852 if (parser_status < PARSER_GLOBAL_ZERO)
11853 {
11854 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11855
11856 continue;
11857 }
11858
11859 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11860
11861 hashes_cnt++;
11862
11863 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11864
11865 if (parser_status < PARSER_GLOBAL_ZERO)
11866 {
11867 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11868
11869 continue;
11870 }
11871
11872 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11873
11874 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11875
11876 hashes_cnt++;
11877
11878 // show / left
11879
11880 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);
11881 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);
11882 }
11883 else
11884 {
11885 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11886
11887 if (parser_status < PARSER_GLOBAL_ZERO)
11888 {
11889 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11890
11891 continue;
11892 }
11893
11894 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);
11895
11896 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11897 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11898
11899 hashes_cnt++;
11900 }
11901 }
11902 else
11903 {
11904 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11905
11906 if (parser_status < PARSER_GLOBAL_ZERO)
11907 {
11908 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11909
11910 continue;
11911 }
11912
11913 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);
11914
11915 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11916 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11917
11918 hashes_cnt++;
11919 }
11920 }
11921
11922 myfree (line_buf);
11923
11924 fclose (fp);
11925
11926 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11927
11928 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11929 }
11930 }
11931 else
11932 {
11933 if (isSalted)
11934 {
11935 hashes_buf[0].salt->salt_len = 8;
11936
11937 // special salt handling
11938
11939 switch (hash_mode)
11940 {
11941 case 1500: hashes_buf[0].salt->salt_len = 2;
11942 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11943 break;
11944 case 1731: hashes_buf[0].salt->salt_len = 4;
11945 break;
11946 case 2410: hashes_buf[0].salt->salt_len = 4;
11947 break;
11948 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11949 break;
11950 case 3100: hashes_buf[0].salt->salt_len = 1;
11951 break;
11952 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11953 break;
11954 case 5800: hashes_buf[0].salt->salt_len = 16;
11955 break;
11956 case 6800: hashes_buf[0].salt->salt_len = 32;
11957 break;
11958 case 8400: hashes_buf[0].salt->salt_len = 40;
11959 break;
11960 case 8800: hashes_buf[0].salt->salt_len = 16;
11961 break;
11962 case 8900: hashes_buf[0].salt->salt_len = 16;
11963 hashes_buf[0].salt->scrypt_N = 1024;
11964 hashes_buf[0].salt->scrypt_r = 1;
11965 hashes_buf[0].salt->scrypt_p = 1;
11966 break;
11967 case 9100: hashes_buf[0].salt->salt_len = 16;
11968 break;
11969 case 9300: hashes_buf[0].salt->salt_len = 14;
11970 hashes_buf[0].salt->scrypt_N = 16384;
11971 hashes_buf[0].salt->scrypt_r = 1;
11972 hashes_buf[0].salt->scrypt_p = 1;
11973 break;
11974 case 9400: hashes_buf[0].salt->salt_len = 16;
11975 break;
11976 case 9500: hashes_buf[0].salt->salt_len = 16;
11977 break;
11978 case 9600: hashes_buf[0].salt->salt_len = 16;
11979 break;
11980 case 9700: hashes_buf[0].salt->salt_len = 16;
11981 break;
11982 case 9710: hashes_buf[0].salt->salt_len = 16;
11983 break;
11984 case 9720: hashes_buf[0].salt->salt_len = 16;
11985 break;
11986 case 9800: hashes_buf[0].salt->salt_len = 16;
11987 break;
11988 case 9810: hashes_buf[0].salt->salt_len = 16;
11989 break;
11990 case 9820: hashes_buf[0].salt->salt_len = 16;
11991 break;
11992 case 10300: hashes_buf[0].salt->salt_len = 12;
11993 break;
11994 case 11500: hashes_buf[0].salt->salt_len = 4;
11995 break;
11996 case 11600: hashes_buf[0].salt->salt_len = 4;
11997 break;
11998 case 12400: hashes_buf[0].salt->salt_len = 4;
11999 break;
12000 case 12500: hashes_buf[0].salt->salt_len = 8;
12001 break;
12002 case 12600: hashes_buf[0].salt->salt_len = 64;
12003 break;
12004 }
12005
12006 // special esalt handling
12007
12008 switch (hash_mode)
12009 {
12010 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12011 break;
12012 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12013 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12014 break;
12015 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12016 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12017 break;
12018 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12019 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12020 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12021 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12022 break;
12023 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12024 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12025 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12026 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12027 break;
12028 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12029 break;
12030 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12031 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12032 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12033 break;
12034 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12035 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12036 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12037 break;
12038 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12039 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12040 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12041 break;
12042 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12043 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12044 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12045 break;
12046 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12047 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12048 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12049 break;
12050 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12051 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12052 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12053 break;
12054 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12055 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12056 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12057 break;
12058 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12059 break;
12060 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12061 break;
12062 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12063 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12064 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12065 break;
12066 }
12067 }
12068
12069 // set hashfile
12070
12071 switch (hash_mode)
12072 {
12073 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12074 break;
12075 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12076 break;
12077 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12078 break;
12079 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12080 break;
12081 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12082 break;
12083 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12084 break;
12085 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12086 break;
12087 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12088 break;
12089 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12090 break;
12091 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12092 break;
12093 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12094 break;
12095 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12096 break;
12097 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12098 break;
12099 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12100 break;
12101 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12102 break;
12103 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12104 break;
12105 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12106 break;
12107 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12108 break;
12109 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12110 break;
12111 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12112 break;
12113 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12114 break;
12115 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12116 break;
12117 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12118 break;
12119 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12120 break;
12121 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12122 break;
12123 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12124 break;
12125 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12126 break;
12127 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12128 break;
12129 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12130 break;
12131 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12132 break;
12133 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12134 break;
12135 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12136 break;
12137 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12138 break;
12139 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12140 break;
12141 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12142 break;
12143 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12144 break;
12145 }
12146
12147 // set default iterations
12148
12149 switch (hash_mode)
12150 {
12151 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12152 break;
12153 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12154 break;
12155 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12156 break;
12157 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12158 break;
12159 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12160 break;
12161 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12162 break;
12163 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12164 break;
12165 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12166 break;
12167 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12168 break;
12169 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12170 break;
12171 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12172 break;
12173 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12174 break;
12175 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12176 break;
12177 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12178 break;
12179 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12180 break;
12181 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12182 break;
12183 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12184 break;
12185 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12186 break;
12187 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12188 break;
12189 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12190 break;
12191 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12192 break;
12193 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12194 break;
12195 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12196 break;
12197 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12198 break;
12199 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12200 break;
12201 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12202 break;
12203 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12204 break;
12205 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12206 break;
12207 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12208 break;
12209 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12210 break;
12211 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12212 break;
12213 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12214 break;
12215 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12216 break;
12217 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12218 break;
12219 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12220 break;
12221 case 8900: hashes_buf[0].salt->salt_iter = 1;
12222 break;
12223 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12224 break;
12225 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12226 break;
12227 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12228 break;
12229 case 9300: hashes_buf[0].salt->salt_iter = 1;
12230 break;
12231 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12232 break;
12233 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12234 break;
12235 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12236 break;
12237 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12238 break;
12239 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12240 break;
12241 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12242 break;
12243 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12244 break;
12245 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12246 break;
12247 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12248 break;
12249 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12250 break;
12251 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12252 break;
12253 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12254 break;
12255 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12256 break;
12257 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12258 break;
12259 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12260 break;
12261 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12262 break;
12263 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12264 break;
12265 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12266 break;
12267 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12268 break;
12269 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12270 break;
12271 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12272 break;
12273 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12274 break;
12275 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12276 break;
12277 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12278 break;
12279 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12280 break;
12281 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12282 break;
12283 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12284 break;
12285 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12286 break;
12287 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12288 break;
12289 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12290 break;
12291 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12292 break;
12293 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12294 break;
12295 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12296 break;
12297 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12298 break;
12299 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12300 break;
12301 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12302 break;
12303 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12304 break;
12305 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12306 break;
12307 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12308 break;
12309 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12310 break;
12311 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12312 break;
12313 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12314 break;
12315 }
12316
12317 hashes_cnt = 1;
12318 }
12319
12320 if (show == 1 || left == 1)
12321 {
12322 for (uint i = 0; i < pot_cnt; i++)
12323 {
12324 pot_t *pot_ptr = &pot[i];
12325
12326 hash_t *hashes_buf = &pot_ptr->hash;
12327
12328 local_free (hashes_buf->digest);
12329
12330 if (isSalted)
12331 {
12332 local_free (hashes_buf->salt);
12333 }
12334 }
12335
12336 local_free (pot);
12337
12338 if (data.quiet == 0) log_info_nn ("");
12339
12340 return (0);
12341 }
12342
12343 if (keyspace == 0)
12344 {
12345 if (hashes_cnt == 0)
12346 {
12347 log_error ("ERROR: No hashes loaded");
12348
12349 return (-1);
12350 }
12351 }
12352
12353 /**
12354 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12355 */
12356
12357 if (data.outfile != NULL)
12358 {
12359 if (data.hashfile != NULL)
12360 {
12361 #ifdef _POSIX
12362 struct stat tmpstat_outfile;
12363 struct stat tmpstat_hashfile;
12364 #endif
12365
12366 #ifdef _WIN
12367 struct stat64 tmpstat_outfile;
12368 struct stat64 tmpstat_hashfile;
12369 #endif
12370
12371 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12372
12373 if (tmp_outfile_fp)
12374 {
12375 #ifdef _POSIX
12376 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12377 #endif
12378
12379 #ifdef _WIN
12380 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12381 #endif
12382
12383 fclose (tmp_outfile_fp);
12384 }
12385
12386 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12387
12388 if (tmp_hashfile_fp)
12389 {
12390 #ifdef _POSIX
12391 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12392 #endif
12393
12394 #ifdef _WIN
12395 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12396 #endif
12397
12398 fclose (tmp_hashfile_fp);
12399 }
12400
12401 if (tmp_outfile_fp && tmp_outfile_fp)
12402 {
12403 tmpstat_outfile.st_mode = 0;
12404 tmpstat_outfile.st_nlink = 0;
12405 tmpstat_outfile.st_uid = 0;
12406 tmpstat_outfile.st_gid = 0;
12407 tmpstat_outfile.st_rdev = 0;
12408 tmpstat_outfile.st_atime = 0;
12409
12410 tmpstat_hashfile.st_mode = 0;
12411 tmpstat_hashfile.st_nlink = 0;
12412 tmpstat_hashfile.st_uid = 0;
12413 tmpstat_hashfile.st_gid = 0;
12414 tmpstat_hashfile.st_rdev = 0;
12415 tmpstat_hashfile.st_atime = 0;
12416
12417 #ifdef _POSIX
12418 tmpstat_outfile.st_blksize = 0;
12419 tmpstat_outfile.st_blocks = 0;
12420
12421 tmpstat_hashfile.st_blksize = 0;
12422 tmpstat_hashfile.st_blocks = 0;
12423 #endif
12424
12425 #ifdef _POSIX
12426 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12427 {
12428 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12429
12430 return (-1);
12431 }
12432 #endif
12433
12434 #ifdef _WIN
12435 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12436 {
12437 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12438
12439 return (-1);
12440 }
12441 #endif
12442 }
12443 }
12444 }
12445
12446 /**
12447 * Remove duplicates
12448 */
12449
12450 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12451
12452 if (isSalted)
12453 {
12454 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12455 }
12456 else
12457 {
12458 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12459 }
12460
12461 uint hashes_cnt_orig = hashes_cnt;
12462
12463 hashes_cnt = 1;
12464
12465 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12466 {
12467 if (isSalted)
12468 {
12469 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12470 {
12471 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12472 }
12473 }
12474 else
12475 {
12476 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12477 }
12478
12479 if (hashes_pos > hashes_cnt)
12480 {
12481 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12482 }
12483
12484 hashes_cnt++;
12485 }
12486
12487 /**
12488 * Potfile removes
12489 */
12490
12491 uint potfile_remove_cracks = 0;
12492
12493 if (potfile_disable == 0)
12494 {
12495 hash_t hash_buf;
12496
12497 hash_buf.digest = mymalloc (dgst_size);
12498 hash_buf.salt = NULL;
12499 hash_buf.esalt = NULL;
12500 hash_buf.hash_info = NULL;
12501 hash_buf.cracked = 0;
12502
12503 if (isSalted)
12504 {
12505 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12506 }
12507
12508 if (esalt_size)
12509 {
12510 hash_buf.esalt = mymalloc (esalt_size);
12511 }
12512
12513 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12514
12515 // no solution for these special hash types (for instane because they use hashfile in output etc)
12516 if ((hash_mode != 5200) &&
12517 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12518 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12519 (hash_mode != 9000))
12520 {
12521 FILE *fp = fopen (potfile, "rb");
12522
12523 if (fp != NULL)
12524 {
12525 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12526
12527 // to be safe work with a copy (because of line_len loop, i etc)
12528 // moved up here because it's easier to handle continue case
12529 // it's just 64kb
12530
12531 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12532
12533 while (!feof (fp))
12534 {
12535 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12536
12537 if (ptr == NULL) break;
12538
12539 int line_len = strlen (line_buf);
12540
12541 if (line_len == 0) continue;
12542
12543 int iter = MAX_CUT_TRIES;
12544
12545 for (int i = line_len - 1; i && iter; i--, line_len--)
12546 {
12547 if (line_buf[i] != ':') continue;
12548
12549 if (isSalted)
12550 {
12551 memset (hash_buf.salt, 0, sizeof (salt_t));
12552 }
12553
12554 hash_t *found = NULL;
12555
12556 if (hash_mode == 6800)
12557 {
12558 if (i < 64) // 64 = 16 * uint in salt_buf[]
12559 {
12560 // manipulate salt_buf
12561 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12562
12563 hash_buf.salt->salt_len = i;
12564
12565 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12566 }
12567 }
12568 else if (hash_mode == 2500)
12569 {
12570 if (i < 64) // 64 = 16 * uint in salt_buf[]
12571 {
12572 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12573 // manipulate salt_buf
12574
12575 memcpy (line_buf_cpy, line_buf, i);
12576
12577 char *mac2_pos = strrchr (line_buf_cpy, ':');
12578
12579 if (mac2_pos == NULL) continue;
12580
12581 mac2_pos[0] = 0;
12582 mac2_pos++;
12583
12584 if (strlen (mac2_pos) != 12) continue;
12585
12586 char *mac1_pos = strrchr (line_buf_cpy, ':');
12587
12588 if (mac1_pos == NULL) continue;
12589
12590 mac1_pos[0] = 0;
12591 mac1_pos++;
12592
12593 if (strlen (mac1_pos) != 12) continue;
12594
12595 uint essid_length = mac1_pos - line_buf_cpy - 1;
12596
12597 // here we need the ESSID
12598 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12599
12600 hash_buf.salt->salt_len = essid_length;
12601
12602 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12603
12604 if (found)
12605 {
12606 wpa_t *wpa = (wpa_t *) found->esalt;
12607
12608 // compare hex string(s) vs binary MAC address(es)
12609
12610 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12611 {
12612 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12613 {
12614 found = NULL;
12615
12616 break;
12617 }
12618 }
12619
12620 // early skip ;)
12621 if (!found) continue;
12622
12623 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12624 {
12625 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12626 {
12627 found = NULL;
12628
12629 break;
12630 }
12631 }
12632 }
12633 }
12634 }
12635 else
12636 {
12637 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12638
12639 if (parser_status == PARSER_OK)
12640 {
12641 if (isSalted)
12642 {
12643 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12644 }
12645 else
12646 {
12647 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12648 }
12649 }
12650 }
12651
12652 if (found == NULL) continue;
12653
12654 if (!found->cracked) potfile_remove_cracks++;
12655
12656 found->cracked = 1;
12657
12658 if (found) break;
12659
12660 iter--;
12661 }
12662 }
12663
12664 myfree (line_buf_cpy);
12665
12666 myfree (line_buf);
12667
12668 fclose (fp);
12669 }
12670 }
12671
12672 if (esalt_size)
12673 {
12674 local_free (hash_buf.esalt);
12675 }
12676
12677 if (isSalted)
12678 {
12679 local_free (hash_buf.salt);
12680 }
12681
12682 local_free (hash_buf.digest);
12683 }
12684
12685 /**
12686 * Now generate all the buffers required for later
12687 */
12688
12689 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12690
12691 salt_t *salts_buf_new = NULL;
12692 void *esalts_buf_new = NULL;
12693
12694 if (isSalted)
12695 {
12696 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12697
12698 if (esalt_size)
12699 {
12700 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12701 }
12702 }
12703 else
12704 {
12705 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12706 }
12707
12708 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12709
12710 uint digests_cnt = hashes_cnt;
12711 uint digests_done = 0;
12712
12713 size_t size_digests = digests_cnt * dgst_size;
12714 size_t size_shown = digests_cnt * sizeof (uint);
12715
12716 uint *digests_shown = (uint *) mymalloc (size_shown);
12717 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12718
12719 uint salts_cnt = 0;
12720 uint salts_done = 0;
12721
12722 hashinfo_t **hash_info = NULL;
12723
12724 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12725 {
12726 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12727
12728 if (username && (remove || show))
12729 {
12730 uint user_pos;
12731
12732 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12733 {
12734 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12735
12736 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12737 }
12738 }
12739 }
12740
12741 uint *salts_shown = (uint *) mymalloc (size_shown);
12742
12743 salt_t *salt_buf;
12744
12745 {
12746 // copied from inner loop
12747
12748 salt_buf = &salts_buf_new[salts_cnt];
12749
12750 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12751
12752 if (esalt_size)
12753 {
12754 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12755 }
12756
12757 salt_buf->digests_cnt = 0;
12758 salt_buf->digests_done = 0;
12759 salt_buf->digests_offset = 0;
12760
12761 salts_cnt++;
12762 }
12763
12764 if (hashes_buf[0].cracked == 1)
12765 {
12766 digests_shown[0] = 1;
12767
12768 digests_done++;
12769
12770 salt_buf->digests_done++;
12771 }
12772
12773 salt_buf->digests_cnt++;
12774
12775 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12776
12777 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12778 {
12779 hash_info[0] = hashes_buf[0].hash_info;
12780 }
12781
12782 // copy from inner loop
12783
12784 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12785 {
12786 if (isSalted)
12787 {
12788 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12789 {
12790 salt_buf = &salts_buf_new[salts_cnt];
12791
12792 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12793
12794 if (esalt_size)
12795 {
12796 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12797 }
12798
12799 salt_buf->digests_cnt = 0;
12800 salt_buf->digests_done = 0;
12801 salt_buf->digests_offset = hashes_pos;
12802
12803 salts_cnt++;
12804 }
12805 }
12806
12807 if (hashes_buf[hashes_pos].cracked == 1)
12808 {
12809 digests_shown[hashes_pos] = 1;
12810
12811 digests_done++;
12812
12813 salt_buf->digests_done++;
12814 }
12815
12816 salt_buf->digests_cnt++;
12817
12818 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12819
12820 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12821 {
12822 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12823 }
12824 }
12825
12826 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12827 {
12828 salt_t *salt_buf = &salts_buf_new[salt_pos];
12829
12830 if (salt_buf->digests_done == salt_buf->digests_cnt)
12831 {
12832 salts_shown[salt_pos] = 1;
12833
12834 salts_done++;
12835 }
12836
12837 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12838 }
12839
12840 local_free (digests_buf);
12841 local_free (salts_buf);
12842 local_free (esalts_buf);
12843
12844 digests_buf = digests_buf_new;
12845 salts_buf = salts_buf_new;
12846 esalts_buf = esalts_buf_new;
12847
12848 local_free (hashes_buf);
12849
12850 /**
12851 * special modification not set from parser
12852 */
12853
12854 switch (hash_mode)
12855 {
12856 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12857 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12858 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12859 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12860 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12861 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12862 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12863 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12864 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12865 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12866 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12867 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12868 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12869 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12870 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12871 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12872 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12873 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12874 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12875 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12876 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12877 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12878 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12879 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12880 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12881 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12882 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12883 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12884 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12885 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12886 }
12887
12888 if (truecrypt_keyfiles)
12889 {
12890 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12891
12892 char *keyfiles = strdup (truecrypt_keyfiles);
12893
12894 char *keyfile = strtok (keyfiles, ",");
12895
12896 do
12897 {
12898 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12899
12900 } while ((keyfile = strtok (NULL, ",")) != NULL);
12901
12902 free (keyfiles);
12903 }
12904
12905 if (veracrypt_keyfiles)
12906 {
12907 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12908
12909 char *keyfiles = strdup (veracrypt_keyfiles);
12910
12911 char *keyfile = strtok (keyfiles, ",");
12912
12913 do
12914 {
12915 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12916
12917 } while ((keyfile = strtok (NULL, ",")) != NULL);
12918
12919 free (keyfiles);
12920 }
12921
12922 data.digests_cnt = digests_cnt;
12923 data.digests_done = digests_done;
12924 data.digests_buf = digests_buf;
12925 data.digests_shown = digests_shown;
12926 data.digests_shown_tmp = digests_shown_tmp;
12927
12928 data.salts_cnt = salts_cnt;
12929 data.salts_done = salts_done;
12930 data.salts_buf = salts_buf;
12931 data.salts_shown = salts_shown;
12932
12933 data.esalts_buf = esalts_buf;
12934 data.hash_info = hash_info;
12935
12936 /**
12937 * Automatic Optimizers
12938 */
12939
12940 if (salts_cnt == 1)
12941 opti_type |= OPTI_TYPE_SINGLE_SALT;
12942
12943 if (digests_cnt == 1)
12944 opti_type |= OPTI_TYPE_SINGLE_HASH;
12945
12946 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12947 opti_type |= OPTI_TYPE_NOT_ITERATED;
12948
12949 if (attack_mode == ATTACK_MODE_BF)
12950 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12951
12952 data.opti_type = opti_type;
12953
12954 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12955 {
12956 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12957 {
12958 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12959 {
12960 if (opts_type & OPTS_TYPE_ST_ADD80)
12961 {
12962 opts_type &= ~OPTS_TYPE_ST_ADD80;
12963 opts_type |= OPTS_TYPE_PT_ADD80;
12964 }
12965
12966 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12967 {
12968 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12969 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12970 }
12971
12972 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12973 {
12974 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12975 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12976 }
12977 }
12978 }
12979 }
12980
12981 /**
12982 * Some algorithm, like descrypt, can benefit from JIT compilation
12983 */
12984
12985 int force_jit_compilation = -1;
12986
12987 if (hash_mode == 8900)
12988 {
12989 force_jit_compilation = 8900;
12990 }
12991 else if (hash_mode == 9300)
12992 {
12993 force_jit_compilation = 8900;
12994 }
12995 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12996 {
12997 force_jit_compilation = 1500;
12998 }
12999
13000 /**
13001 * generate bitmap tables
13002 */
13003
13004 const uint bitmap_shift1 = 5;
13005 const uint bitmap_shift2 = 13;
13006
13007 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13008
13009 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13010 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13011 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13012 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13013 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13014 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13015 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13016 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13017
13018 uint bitmap_bits;
13019 uint bitmap_nums;
13020 uint bitmap_mask;
13021 uint bitmap_size;
13022
13023 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13024 {
13025 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13026
13027 bitmap_nums = 1 << bitmap_bits;
13028
13029 bitmap_mask = bitmap_nums - 1;
13030
13031 bitmap_size = bitmap_nums * sizeof (uint);
13032
13033 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13034
13035 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;
13036 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;
13037
13038 break;
13039 }
13040
13041 bitmap_nums = 1 << bitmap_bits;
13042
13043 bitmap_mask = bitmap_nums - 1;
13044
13045 bitmap_size = bitmap_nums * sizeof (uint);
13046
13047 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);
13048 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);
13049
13050 /**
13051 * prepare quick rule
13052 */
13053
13054 data.rule_buf_l = rule_buf_l;
13055 data.rule_buf_r = rule_buf_r;
13056
13057 int rule_len_l = (int) strlen (rule_buf_l);
13058 int rule_len_r = (int) strlen (rule_buf_r);
13059
13060 data.rule_len_l = rule_len_l;
13061 data.rule_len_r = rule_len_r;
13062
13063 /**
13064 * load rules
13065 */
13066
13067 uint *all_kernel_rules_cnt = NULL;
13068
13069 kernel_rule_t **all_kernel_rules_buf = NULL;
13070
13071 if (rp_files_cnt)
13072 {
13073 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13074
13075 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13076 }
13077
13078 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13079
13080 int rule_len = 0;
13081
13082 for (uint i = 0; i < rp_files_cnt; i++)
13083 {
13084 uint kernel_rules_avail = 0;
13085
13086 uint kernel_rules_cnt = 0;
13087
13088 kernel_rule_t *kernel_rules_buf = NULL;
13089
13090 char *rp_file = rp_files[i];
13091
13092 char in[BLOCK_SIZE] = { 0 };
13093 char out[BLOCK_SIZE] = { 0 };
13094
13095 FILE *fp = NULL;
13096
13097 uint rule_line = 0;
13098
13099 if ((fp = fopen (rp_file, "rb")) == NULL)
13100 {
13101 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13102
13103 return (-1);
13104 }
13105
13106 while (!feof (fp))
13107 {
13108 memset (rule_buf, 0, HCBUFSIZ);
13109
13110 rule_len = fgetl (fp, rule_buf);
13111
13112 rule_line++;
13113
13114 if (rule_len == 0) continue;
13115
13116 if (rule_buf[0] == '#') continue;
13117
13118 if (kernel_rules_avail == kernel_rules_cnt)
13119 {
13120 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13121
13122 kernel_rules_avail += INCR_RULES;
13123 }
13124
13125 memset (in, 0, BLOCK_SIZE);
13126 memset (out, 0, BLOCK_SIZE);
13127
13128 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13129
13130 if (result == -1)
13131 {
13132 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13133
13134 continue;
13135 }
13136
13137 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13138 {
13139 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13140
13141 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13142
13143 continue;
13144 }
13145
13146 /* its so slow
13147 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13148 {
13149 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13150
13151 continue;
13152 }
13153 */
13154
13155 kernel_rules_cnt++;
13156 }
13157
13158 fclose (fp);
13159
13160 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13161
13162 all_kernel_rules_buf[i] = kernel_rules_buf;
13163 }
13164
13165 /**
13166 * merge rules or automatic rule generator
13167 */
13168
13169 uint kernel_rules_cnt = 0;
13170
13171 kernel_rule_t *kernel_rules_buf = NULL;
13172
13173 if (attack_mode == ATTACK_MODE_STRAIGHT)
13174 {
13175 if (rp_files_cnt)
13176 {
13177 kernel_rules_cnt = 1;
13178
13179 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13180
13181 repeats[0] = kernel_rules_cnt;
13182
13183 for (uint i = 0; i < rp_files_cnt; i++)
13184 {
13185 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13186
13187 repeats[i + 1] = kernel_rules_cnt;
13188 }
13189
13190 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13191
13192 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13193
13194 for (uint i = 0; i < kernel_rules_cnt; i++)
13195 {
13196 uint out_pos = 0;
13197
13198 kernel_rule_t *out = &kernel_rules_buf[i];
13199
13200 for (uint j = 0; j < rp_files_cnt; j++)
13201 {
13202 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13203 uint in_pos;
13204
13205 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13206
13207 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13208 {
13209 if (out_pos == RULES_MAX - 1)
13210 {
13211 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13212
13213 break;
13214 }
13215
13216 out->cmds[out_pos] = in->cmds[in_pos];
13217 }
13218 }
13219 }
13220
13221 local_free (repeats);
13222 }
13223 else if (rp_gen)
13224 {
13225 uint kernel_rules_avail = 0;
13226
13227 while (kernel_rules_cnt < rp_gen)
13228 {
13229 if (kernel_rules_avail == kernel_rules_cnt)
13230 {
13231 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13232
13233 kernel_rules_avail += INCR_RULES;
13234 }
13235
13236 memset (rule_buf, 0, HCBUFSIZ);
13237
13238 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13239
13240 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13241
13242 kernel_rules_cnt++;
13243 }
13244 }
13245 }
13246
13247 myfree (rule_buf);
13248
13249 /**
13250 * generate NOP rules
13251 */
13252
13253 if (kernel_rules_cnt == 0)
13254 {
13255 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13256
13257 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13258
13259 kernel_rules_cnt++;
13260 }
13261
13262 data.kernel_rules_cnt = kernel_rules_cnt;
13263 data.kernel_rules_buf = kernel_rules_buf;
13264
13265 /**
13266 * OpenCL platforms: detect
13267 */
13268
13269 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13270 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13271
13272 cl_uint platforms_cnt = 0;
13273 cl_uint platform_devices_cnt = 0;
13274
13275 if (keyspace == 0)
13276 {
13277 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13278
13279 if (platforms_cnt == 0)
13280 {
13281 log_info ("");
13282 log_info ("ATTENTION! No OpenCL compatible platform found");
13283 log_info ("");
13284 log_info ("You're probably missing the OpenCL runtime installation");
13285 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13286 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13287 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13288 log_info ("");
13289
13290 return (-1);
13291 }
13292
13293 if (opencl_platforms_filter != (uint) -1)
13294 {
13295 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13296
13297 if (opencl_platforms_filter > platform_cnt_mask)
13298 {
13299 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13300
13301 return (-1);
13302 }
13303 }
13304 }
13305
13306 /**
13307 * OpenCL device types:
13308 * 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.
13309 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13310 */
13311
13312 if (opencl_device_types == NULL)
13313 {
13314 cl_device_type device_types_all = 0;
13315
13316 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13317 {
13318 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13319
13320 cl_platform_id platform = platforms[platform_id];
13321
13322 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13323
13324 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13325 {
13326 cl_device_id device = platform_devices[platform_devices_id];
13327
13328 cl_device_type device_type;
13329
13330 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13331
13332 device_types_all |= device_type;
13333 }
13334 }
13335
13336 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13337 {
13338 device_types_filter |= CL_DEVICE_TYPE_CPU;
13339 }
13340 }
13341
13342 /**
13343 * OpenCL devices: simply push all devices from all platforms into the same device array
13344 */
13345
13346 int need_adl = 0;
13347 int need_nvapi = 0;
13348 int need_nvml = 0;
13349
13350 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13351
13352 data.devices_param = devices_param;
13353
13354 uint devices_cnt = 0;
13355
13356 uint devices_active = 0;
13357
13358 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13359 {
13360 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13361
13362 cl_platform_id platform = platforms[platform_id];
13363
13364 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13365
13366 char platform_vendor[INFOSZ] = { 0 };
13367
13368 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13369
13370 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13371 // this causes trouble with vendor id based macros
13372 // we'll assign generic to those without special optimization available
13373
13374 cl_uint platform_vendor_id = 0;
13375
13376 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13377 {
13378 platform_vendor_id = VENDOR_ID_AMD;
13379 }
13380 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13381 {
13382 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13383 }
13384 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13385 {
13386 platform_vendor_id = VENDOR_ID_APPLE;
13387 }
13388 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13389 {
13390 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13391 }
13392 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13393 {
13394 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13395 }
13396 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13397 {
13398 platform_vendor_id = VENDOR_ID_MESA;
13399 }
13400 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13401 {
13402 platform_vendor_id = VENDOR_ID_NV;
13403 }
13404 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13405 {
13406 platform_vendor_id = VENDOR_ID_POCL;
13407 }
13408 else
13409 {
13410 platform_vendor_id = VENDOR_ID_GENERIC;
13411 }
13412
13413 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13414 {
13415 size_t param_value_size = 0;
13416
13417 const uint device_id = devices_cnt;
13418
13419 hc_device_param_t *device_param = &data.devices_param[device_id];
13420
13421 device_param->platform_vendor_id = platform_vendor_id;
13422
13423 device_param->device = platform_devices[platform_devices_id];
13424
13425 device_param->device_id = device_id;
13426
13427 device_param->platform_devices_id = platform_devices_id;
13428
13429 // device_type
13430
13431 cl_device_type device_type;
13432
13433 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13434
13435 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13436
13437 device_param->device_type = device_type;
13438
13439 // device_name
13440
13441 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13442
13443 char *device_name = (char *) mymalloc (param_value_size);
13444
13445 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13446
13447 device_param->device_name = device_name;
13448
13449 // device_vendor
13450
13451 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13452
13453 char *device_vendor = (char *) mymalloc (param_value_size);
13454
13455 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13456
13457 device_param->device_vendor = device_vendor;
13458
13459 cl_uint device_vendor_id = 0;
13460
13461 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13462 {
13463 device_vendor_id = VENDOR_ID_AMD;
13464 }
13465 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13466 {
13467 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13468 }
13469 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13470 {
13471 device_vendor_id = VENDOR_ID_APPLE;
13472 }
13473 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13474 {
13475 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13476 }
13477 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13478 {
13479 device_vendor_id = VENDOR_ID_INTEL_SDK;
13480 }
13481 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13482 {
13483 device_vendor_id = VENDOR_ID_MESA;
13484 }
13485 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13486 {
13487 device_vendor_id = VENDOR_ID_NV;
13488 }
13489 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13490 {
13491 device_vendor_id = VENDOR_ID_POCL;
13492 }
13493 else
13494 {
13495 device_vendor_id = VENDOR_ID_GENERIC;
13496 }
13497
13498 device_param->device_vendor_id = device_vendor_id;
13499
13500 // tuning db
13501
13502 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13503
13504 // device_version
13505
13506 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13507
13508 char *device_version = (char *) mymalloc (param_value_size);
13509
13510 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13511
13512 device_param->device_version = device_version;
13513
13514 // device_opencl_version
13515
13516 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13517
13518 char *device_opencl_version = (char *) mymalloc (param_value_size);
13519
13520 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13521
13522 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13523
13524 myfree (device_opencl_version);
13525
13526 // vector_width
13527
13528 cl_uint vector_width;
13529
13530 if (opencl_vector_width_chgd == 0)
13531 {
13532 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13533 {
13534 if (opti_type & OPTI_TYPE_USES_BITS_64)
13535 {
13536 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13537 }
13538 else
13539 {
13540 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13541 }
13542 }
13543 else
13544 {
13545 vector_width = (cl_uint) tuningdb_entry->vector_width;
13546 }
13547 }
13548 else
13549 {
13550 vector_width = opencl_vector_width;
13551 }
13552
13553 if (vector_width > 16) vector_width = 16;
13554
13555 device_param->vector_width = vector_width;
13556
13557 // max_compute_units
13558
13559 cl_uint device_processors;
13560
13561 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13562
13563 device_param->device_processors = device_processors;
13564
13565 // device_maxmem_alloc
13566 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13567
13568 cl_ulong device_maxmem_alloc;
13569
13570 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13571
13572 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13573
13574 // device_global_mem
13575
13576 cl_ulong device_global_mem;
13577
13578 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13579
13580 device_param->device_global_mem = device_global_mem;
13581
13582 // max_work_group_size
13583
13584 size_t device_maxworkgroup_size;
13585
13586 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13587
13588 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13589
13590 // max_clock_frequency
13591
13592 cl_uint device_maxclock_frequency;
13593
13594 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13595
13596 device_param->device_maxclock_frequency = device_maxclock_frequency;
13597
13598 // device_endian_little
13599
13600 cl_bool device_endian_little;
13601
13602 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13603
13604 if (device_endian_little == CL_FALSE)
13605 {
13606 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13607
13608 device_param->skipped = 1;
13609 }
13610
13611 // device_available
13612
13613 cl_bool device_available;
13614
13615 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13616
13617 if (device_available == CL_FALSE)
13618 {
13619 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13620
13621 device_param->skipped = 1;
13622 }
13623
13624 // device_compiler_available
13625
13626 cl_bool device_compiler_available;
13627
13628 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13629
13630 if (device_compiler_available == CL_FALSE)
13631 {
13632 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13633
13634 device_param->skipped = 1;
13635 }
13636
13637 // device_execution_capabilities
13638
13639 cl_device_exec_capabilities device_execution_capabilities;
13640
13641 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13642
13643 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13644 {
13645 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13646
13647 device_param->skipped = 1;
13648 }
13649
13650 // device_extensions
13651
13652 size_t device_extensions_size;
13653
13654 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13655
13656 char *device_extensions = mymalloc (device_extensions_size + 1);
13657
13658 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13659
13660 if (strstr (device_extensions, "base_atomics") == 0)
13661 {
13662 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13663
13664 device_param->skipped = 1;
13665 }
13666
13667 if (strstr (device_extensions, "byte_addressable_store") == 0)
13668 {
13669 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13670
13671 device_param->skipped = 1;
13672 }
13673
13674 myfree (device_extensions);
13675
13676 // device_local_mem_size
13677
13678 cl_ulong device_local_mem_size;
13679
13680 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13681
13682 if (device_local_mem_size < 32768)
13683 {
13684 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13685
13686 device_param->skipped = 1;
13687 }
13688
13689 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13690 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13691 // This results in both utilizing it for 50%
13692 // However, Intel has much better SIMD control over their own hardware
13693 // It makes sense to give them full control over their own hardware
13694
13695 if (device_type & CL_DEVICE_TYPE_CPU)
13696 {
13697 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13698 {
13699 if (data.force == 0)
13700 {
13701 if (algorithm_pos == 0)
13702 {
13703 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
13704 log_info (" You can use --force to override this but do not post error reports if you do so");
13705 }
13706
13707 device_param->skipped = 1;
13708 }
13709 }
13710 }
13711
13712 // skipped
13713
13714 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13715 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13716
13717 // driver_version
13718
13719 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13720
13721 char *driver_version = (char *) mymalloc (param_value_size);
13722
13723 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13724
13725 device_param->driver_version = driver_version;
13726
13727 // device_name_chksum
13728
13729 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13730
13731 #if __x86_64__
13732 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);
13733 #else
13734 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);
13735 #endif
13736
13737 uint device_name_digest[4] = { 0 };
13738
13739 md5_64 ((uint *) device_name_chksum, device_name_digest);
13740
13741 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13742
13743 device_param->device_name_chksum = device_name_chksum;
13744
13745 // device_processor_cores
13746
13747 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
13748 {
13749 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
13750 {
13751 need_adl = 1;
13752 }
13753
13754 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
13755 {
13756 need_nvml = 1;
13757
13758 #ifdef _WIN
13759 need_nvapi = 1;
13760 #endif
13761 }
13762 }
13763
13764 // device_processor_cores
13765
13766 if (device_type & CL_DEVICE_TYPE_CPU)
13767 {
13768 cl_uint device_processor_cores = 1;
13769
13770 device_param->device_processor_cores = device_processor_cores;
13771 }
13772
13773 if (device_type & CL_DEVICE_TYPE_GPU)
13774 {
13775 if (device_vendor_id == VENDOR_ID_AMD)
13776 {
13777 cl_uint device_processor_cores = 0;
13778
13779 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13780
13781 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13782
13783 device_param->device_processor_cores = device_processor_cores;
13784 }
13785 else if (device_vendor_id == VENDOR_ID_NV)
13786 {
13787 cl_uint kernel_exec_timeout = 0;
13788
13789 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13790
13791 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13792
13793 device_param->kernel_exec_timeout = kernel_exec_timeout;
13794
13795 cl_uint device_processor_cores = 0;
13796
13797 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13798
13799 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13800
13801 device_param->device_processor_cores = device_processor_cores;
13802
13803 cl_uint sm_minor = 0;
13804 cl_uint sm_major = 0;
13805
13806 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13807 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13808
13809 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13810 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13811
13812 device_param->sm_minor = sm_minor;
13813 device_param->sm_major = sm_major;
13814 }
13815 else
13816 {
13817 cl_uint device_processor_cores = 1;
13818
13819 device_param->device_processor_cores = device_processor_cores;
13820 }
13821 }
13822
13823 // display results
13824
13825 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13826 {
13827 if (machine_readable == 0)
13828 {
13829 if (device_param->skipped == 0)
13830 {
13831 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13832 device_id + 1,
13833 device_name,
13834 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13835 (unsigned int) (device_global_mem / 1024 / 1024),
13836 (unsigned int) device_processors);
13837 }
13838 else
13839 {
13840 log_info ("Device #%u: %s, skipped",
13841 device_id + 1,
13842 device_name);
13843 }
13844 }
13845 }
13846
13847 // common driver check
13848
13849 if (device_param->skipped == 0)
13850 {
13851 if (device_type & CL_DEVICE_TYPE_GPU)
13852 {
13853 if (platform_vendor_id == VENDOR_ID_AMD)
13854 {
13855 int catalyst_check = (force == 1) ? 0 : 1;
13856
13857 int catalyst_warn = 0;
13858
13859 int catalyst_broken = 0;
13860
13861 if (catalyst_check == 1)
13862 {
13863 catalyst_warn = 1;
13864
13865 // v14.9 and higher
13866 if (atoi (device_param->driver_version) >= 1573)
13867 {
13868 catalyst_warn = 0;
13869 }
13870
13871 catalyst_check = 0;
13872 }
13873
13874 if (catalyst_broken == 1)
13875 {
13876 log_info ("");
13877 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13878 log_info ("It will pass over cracked hashes and does not report them as cracked");
13879 log_info ("You are STRONGLY encouraged not to use it");
13880 log_info ("You can use --force to override this but do not post error reports if you do so");
13881 log_info ("");
13882
13883 return (-1);
13884 }
13885
13886 if (catalyst_warn == 1)
13887 {
13888 log_info ("");
13889 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13890 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13891 log_info ("See hashcat's homepage for official supported catalyst drivers");
13892 #ifdef _WIN
13893 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13894 #endif
13895 log_info ("You can use --force to override this but do not post error reports if you do so");
13896 log_info ("");
13897
13898 return (-1);
13899 }
13900 }
13901 else if (platform_vendor_id == VENDOR_ID_NV)
13902 {
13903 if (device_param->kernel_exec_timeout != 0)
13904 {
13905 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);
13906 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13907 }
13908 }
13909 }
13910
13911 /* turns out pocl still creates segfaults (because of llvm)
13912 if (device_type & CL_DEVICE_TYPE_CPU)
13913 {
13914 if (platform_vendor_id == VENDOR_ID_AMD)
13915 {
13916 if (force == 0)
13917 {
13918 log_info ("");
13919 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13920 log_info ("You are STRONGLY encouraged not to use it");
13921 log_info ("You can use --force to override this but do not post error reports if you do so");
13922 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13923 log_info ("");
13924
13925 return (-1);
13926 }
13927 }
13928 }
13929 */
13930
13931 /**
13932 * kernel accel and loops tuning db adjustment
13933 */
13934
13935 device_param->kernel_accel_min = 1;
13936 device_param->kernel_accel_max = 1024;
13937
13938 device_param->kernel_loops_min = 1;
13939 device_param->kernel_loops_max = 1024;
13940
13941 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13942
13943 if (tuningdb_entry)
13944 {
13945 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13946 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13947
13948 if (_kernel_accel)
13949 {
13950 device_param->kernel_accel_min = _kernel_accel;
13951 device_param->kernel_accel_max = _kernel_accel;
13952 }
13953
13954 if (_kernel_loops)
13955 {
13956 if (workload_profile == 1)
13957 {
13958 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13959 }
13960 else if (workload_profile == 2)
13961 {
13962 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13963 }
13964
13965 device_param->kernel_loops_min = _kernel_loops;
13966 device_param->kernel_loops_max = _kernel_loops;
13967 }
13968 }
13969
13970 // commandline parameters overwrite tuningdb entries
13971
13972 if (kernel_accel)
13973 {
13974 device_param->kernel_accel_min = kernel_accel;
13975 device_param->kernel_accel_max = kernel_accel;
13976 }
13977
13978 if (kernel_loops)
13979 {
13980 device_param->kernel_loops_min = kernel_loops;
13981 device_param->kernel_loops_max = kernel_loops;
13982 }
13983
13984 /**
13985 * activate device
13986 */
13987
13988 devices_active++;
13989 }
13990
13991 // next please
13992
13993 devices_cnt++;
13994 }
13995 }
13996
13997 if (keyspace == 0 && devices_active == 0)
13998 {
13999 log_error ("ERROR: No devices found/left");
14000
14001 return (-1);
14002 }
14003
14004 // 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)
14005
14006 if (devices_filter != (uint) -1)
14007 {
14008 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14009
14010 if (devices_filter > devices_cnt_mask)
14011 {
14012 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14013
14014 return (-1);
14015 }
14016 }
14017
14018 data.devices_cnt = devices_cnt;
14019
14020 data.devices_active = devices_active;
14021
14022 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14023 {
14024 if (machine_readable == 0)
14025 {
14026 log_info ("");
14027 }
14028 }
14029
14030 /**
14031 * HM devices: init
14032 */
14033
14034 #ifdef HAVE_HWMON
14035 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14036 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14037 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14038
14039 if (gpu_temp_disable == 0)
14040 {
14041 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14042 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14043 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14044
14045 data.hm_adl = NULL;
14046 data.hm_nvapi = NULL;
14047 data.hm_nvml = NULL;
14048
14049 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14050 {
14051 data.hm_nvml = nvml;
14052 }
14053
14054 if (data.hm_nvml)
14055 {
14056 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14057 {
14058 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14059
14060 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14061
14062 int tmp_out = 0;
14063
14064 for (int i = 0; i < tmp_in; i++)
14065 {
14066 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14067 }
14068
14069 for (int i = 0; i < tmp_out; i++)
14070 {
14071 unsigned int speed;
14072
14073 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14074
14075 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14076
14077 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14078 }
14079 }
14080 }
14081
14082 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14083 {
14084 data.hm_nvapi = nvapi;
14085 }
14086
14087 if (data.hm_nvapi)
14088 {
14089 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14090 {
14091 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14092
14093 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14094
14095 int tmp_out = 0;
14096
14097 for (int i = 0; i < tmp_in; i++)
14098 {
14099 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14100 }
14101 }
14102 }
14103
14104 if ((need_adl == 1) && (adl_init (adl) == 0))
14105 {
14106 data.hm_adl = adl;
14107 }
14108
14109 if (data.hm_adl)
14110 {
14111 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14112 {
14113 // total number of adapters
14114
14115 int hm_adapters_num;
14116
14117 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14118
14119 // adapter info
14120
14121 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14122
14123 if (lpAdapterInfo == NULL) return (-1);
14124
14125 // get a list (of ids of) valid/usable adapters
14126
14127 int num_adl_adapters = 0;
14128
14129 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14130
14131 if (num_adl_adapters > 0)
14132 {
14133 hc_thread_mutex_lock (mux_adl);
14134
14135 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14136
14137 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14138
14139 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14140 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14141
14142 hc_thread_mutex_unlock (mux_adl);
14143 }
14144
14145 myfree (valid_adl_device_list);
14146 myfree (lpAdapterInfo);
14147 }
14148 }
14149
14150 if (data.hm_adl == NULL && data.hm_nvml == NULL)
14151 {
14152 gpu_temp_disable = 1;
14153 }
14154 }
14155
14156 /**
14157 * OpenCL devices: allocate buffer for device specific information
14158 */
14159
14160 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14161 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14162
14163 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14164
14165 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14166
14167 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14168
14169 /**
14170 * User-defined GPU temp handling
14171 */
14172
14173 if (gpu_temp_disable == 1)
14174 {
14175 gpu_temp_abort = 0;
14176 gpu_temp_retain = 0;
14177 }
14178
14179 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14180 {
14181 if (gpu_temp_abort < gpu_temp_retain)
14182 {
14183 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14184
14185 return (-1);
14186 }
14187 }
14188
14189 data.gpu_temp_disable = gpu_temp_disable;
14190 data.gpu_temp_abort = gpu_temp_abort;
14191 data.gpu_temp_retain = gpu_temp_retain;
14192 #endif
14193
14194 /**
14195 * enable custom signal handler(s)
14196 */
14197
14198 if (benchmark == 0)
14199 {
14200 hc_signal (sigHandler_default);
14201 }
14202 else
14203 {
14204 hc_signal (sigHandler_benchmark);
14205 }
14206
14207 /**
14208 * inform the user
14209 */
14210
14211 if (data.quiet == 0)
14212 {
14213 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14214
14215 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);
14216
14217 if (attack_mode == ATTACK_MODE_STRAIGHT)
14218 {
14219 log_info ("Rules: %u", kernel_rules_cnt);
14220 }
14221
14222 if (opti_type)
14223 {
14224 log_info ("Applicable Optimizers:");
14225
14226 for (uint i = 0; i < 32; i++)
14227 {
14228 const uint opti_bit = 1u << i;
14229
14230 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14231 }
14232 }
14233
14234 /**
14235 * Watchdog and Temperature balance
14236 */
14237
14238 #ifdef HAVE_HWMON
14239 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
14240 {
14241 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14242 }
14243
14244 if (gpu_temp_abort == 0)
14245 {
14246 log_info ("Watchdog: Temperature abort trigger disabled");
14247 }
14248 else
14249 {
14250 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14251 }
14252
14253 if (gpu_temp_retain == 0)
14254 {
14255 log_info ("Watchdog: Temperature retain trigger disabled");
14256 }
14257 else
14258 {
14259 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14260 }
14261
14262 if (data.quiet == 0) log_info ("");
14263 #endif
14264 }
14265
14266 #ifdef HAVE_HWMON
14267
14268 /**
14269 * HM devices: copy
14270 */
14271
14272 if (gpu_temp_disable == 0)
14273 {
14274 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14275 {
14276 hc_device_param_t *device_param = &data.devices_param[device_id];
14277
14278 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14279
14280 if (device_param->skipped) continue;
14281
14282 const uint platform_devices_id = device_param->platform_devices_id;
14283
14284 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14285 {
14286 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14287 data.hm_device[device_id].nvapi = 0;
14288 data.hm_device[device_id].nvml = 0;
14289 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14290 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14291 data.hm_device[device_id].fan_set_supported = hm_adapters_adl[platform_devices_id].fan_set_supported;
14292 }
14293
14294 if (device_param->device_vendor_id == VENDOR_ID_NV)
14295 {
14296 data.hm_device[device_id].adl = 0;
14297 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14298 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14299 data.hm_device[device_id].od_version = 0;
14300 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14301 data.hm_device[device_id].fan_set_supported = 0;
14302 }
14303 }
14304 }
14305
14306 /**
14307 * powertune on user request
14308 */
14309
14310 if (powertune_enable == 1)
14311 {
14312 hc_thread_mutex_lock (mux_adl);
14313
14314 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14315 {
14316 hc_device_param_t *device_param = &data.devices_param[device_id];
14317
14318 if (device_param->skipped) continue;
14319
14320 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14321 {
14322 /**
14323 * Temporary fix:
14324 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14325 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14326 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14327 * Driver / ADL bug?
14328 */
14329
14330 if (data.hm_device[device_id].od_version == 6)
14331 {
14332 int ADL_rc;
14333
14334 // check powertune capabilities first, if not available then skip device
14335
14336 int powertune_supported = 0;
14337
14338 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14339 {
14340 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14341
14342 return (-1);
14343 }
14344
14345 // first backup current value, we will restore it later
14346
14347 if (powertune_supported != 0)
14348 {
14349 // powercontrol settings
14350
14351 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14352
14353 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14354 {
14355 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14356 }
14357
14358 if (ADL_rc != ADL_OK)
14359 {
14360 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14361
14362 return (-1);
14363 }
14364
14365 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14366 {
14367 log_error ("ERROR: Failed to set new ADL PowerControl values");
14368
14369 return (-1);
14370 }
14371
14372 // clocks
14373
14374 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14375
14376 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14377
14378 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)
14379 {
14380 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14381
14382 return (-1);
14383 }
14384
14385 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14386
14387 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14388
14389 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14390 {
14391 log_error ("ERROR: Failed to get ADL device capabilities");
14392
14393 return (-1);
14394 }
14395
14396 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14397 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14398
14399 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14400 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14401
14402 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14403 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14404
14405 // warning if profile has too low max values
14406
14407 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14408 {
14409 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14410 }
14411
14412 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14413 {
14414 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14415 }
14416
14417 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14418
14419 performance_state->iNumberOfPerformanceLevels = 2;
14420
14421 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14422 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14423 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14424 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14425
14426 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)
14427 {
14428 log_info ("ERROR: Failed to set ADL performance state");
14429
14430 return (-1);
14431 }
14432
14433 local_free (performance_state);
14434 }
14435
14436 // set powertune value only
14437
14438 if (powertune_supported != 0)
14439 {
14440 // powertune set
14441 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14442
14443 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14444 {
14445 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14446
14447 return (-1);
14448 }
14449
14450 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14451 {
14452 log_error ("ERROR: Failed to set new ADL PowerControl values");
14453
14454 return (-1);
14455 }
14456 }
14457 }
14458 }
14459
14460 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14461 {
14462 // first backup current value, we will restore it later
14463
14464 unsigned int limit;
14465
14466 int powertune_supported = 0;
14467
14468 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14469 {
14470 powertune_supported = 1;
14471 }
14472
14473 // if backup worked, activate the maximum allowed
14474
14475 if (powertune_supported != 0)
14476 {
14477 unsigned int minLimit;
14478 unsigned int maxLimit;
14479
14480 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14481 {
14482 if (maxLimit > 0)
14483 {
14484 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14485 {
14486 // now we can be sure we need to reset later
14487
14488 nvml_power_limit[device_id] = limit;
14489 }
14490 }
14491 }
14492 }
14493 }
14494 }
14495
14496 hc_thread_mutex_unlock (mux_adl);
14497 }
14498
14499 #endif // HAVE_HWMON
14500
14501 #ifdef DEBUG
14502 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14503 #endif
14504
14505 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14506
14507 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14508 {
14509 /**
14510 * host buffer
14511 */
14512
14513 hc_device_param_t *device_param = &data.devices_param[device_id];
14514
14515 if (device_param->skipped) continue;
14516
14517 /**
14518 * device properties
14519 */
14520
14521 const char *device_name_chksum = device_param->device_name_chksum;
14522 const u32 device_processors = device_param->device_processors;
14523 const u32 device_processor_cores = device_param->device_processor_cores;
14524
14525 /**
14526 * create context for each device
14527 */
14528
14529 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14530
14531 /**
14532 * create command-queue
14533 */
14534
14535 // not supported with NV
14536 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14537
14538 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14539
14540 /**
14541 * kernel threads: some algorithms need a fixed kernel-threads count
14542 * because of shared memory usage or bitslice
14543 * there needs to be some upper limit, otherwise there's too much overhead
14544 */
14545
14546 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14547
14548 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14549 {
14550 kernel_threads = KERNEL_THREADS_MAX_CPU;
14551 }
14552
14553 if (hash_mode == 1500) kernel_threads = 64; // DES
14554 if (hash_mode == 3000) kernel_threads = 64; // DES
14555 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14556 if (hash_mode == 7500) kernel_threads = 64; // RC4
14557 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14558 if (hash_mode == 9700) kernel_threads = 64; // RC4
14559 if (hash_mode == 9710) kernel_threads = 64; // RC4
14560 if (hash_mode == 9800) kernel_threads = 64; // RC4
14561 if (hash_mode == 9810) kernel_threads = 64; // RC4
14562 if (hash_mode == 10400) kernel_threads = 64; // RC4
14563 if (hash_mode == 10410) kernel_threads = 64; // RC4
14564 if (hash_mode == 10500) kernel_threads = 64; // RC4
14565 if (hash_mode == 13100) kernel_threads = 64; // RC4
14566
14567 device_param->kernel_threads = kernel_threads;
14568
14569 /**
14570 * create input buffers on device : calculate size of fixed memory buffers
14571 */
14572
14573 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14574 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14575
14576 device_param->size_root_css = size_root_css;
14577 device_param->size_markov_css = size_markov_css;
14578
14579 size_t size_results = sizeof (uint);
14580
14581 device_param->size_results = size_results;
14582
14583 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14584 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14585
14586 size_t size_plains = digests_cnt * sizeof (plain_t);
14587 size_t size_salts = salts_cnt * sizeof (salt_t);
14588 size_t size_esalts = salts_cnt * esalt_size;
14589
14590 device_param->size_plains = size_plains;
14591 device_param->size_digests = size_digests;
14592 device_param->size_shown = size_shown;
14593 device_param->size_salts = size_salts;
14594
14595 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14596 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14597 size_t size_tm = 32 * sizeof (bs_word_t);
14598
14599 // scryptV stuff
14600
14601 size_t size_scryptV = 1;
14602
14603 if ((hash_mode == 8900) || (hash_mode == 9300))
14604 {
14605 uint tmto_start = 0;
14606 uint tmto_stop = 10;
14607
14608 if (scrypt_tmto)
14609 {
14610 tmto_start = scrypt_tmto;
14611 }
14612 else
14613 {
14614 // in case the user did not specify the tmto manually
14615 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14616 // but set the lower end only in case the user has a device with too less memory
14617
14618 if (hash_mode == 8900)
14619 {
14620 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14621 {
14622 tmto_start = 1;
14623 }
14624 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14625 {
14626 tmto_start = 2;
14627 }
14628 }
14629 else if (hash_mode == 9300)
14630 {
14631 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14632 {
14633 tmto_start = 2;
14634 }
14635 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14636 {
14637 tmto_start = 2;
14638 }
14639 }
14640 }
14641
14642 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14643 {
14644 // TODO: in theory the following calculation needs to be done per salt, not global
14645 // we assume all hashes have the same scrypt settings
14646
14647 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14648
14649 size_scryptV /= 1 << tmto;
14650
14651 size_scryptV *= device_processors * device_processor_cores;
14652
14653 if (size_scryptV > device_param->device_maxmem_alloc)
14654 {
14655 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14656
14657 continue;
14658 }
14659
14660 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14661 {
14662 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14663 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14664 }
14665
14666 break;
14667 }
14668
14669 if (data.salts_buf[0].scrypt_phy == 0)
14670 {
14671 log_error ("ERROR: can't allocate enough device memory");
14672
14673 return -1;
14674 }
14675
14676 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14677 }
14678
14679 /**
14680 * some algorithms need a fixed kernel-loops count
14681 */
14682
14683 if (hash_mode == 1500)
14684 {
14685 const u32 kernel_loops_fixed = 1024;
14686
14687 device_param->kernel_loops_min = kernel_loops_fixed;
14688 device_param->kernel_loops_max = kernel_loops_fixed;
14689 }
14690
14691 if (hash_mode == 3000)
14692 {
14693 const u32 kernel_loops_fixed = 1024;
14694
14695 device_param->kernel_loops_min = kernel_loops_fixed;
14696 device_param->kernel_loops_max = kernel_loops_fixed;
14697 }
14698
14699 if (hash_mode == 8900)
14700 {
14701 const u32 kernel_loops_fixed = 1;
14702
14703 device_param->kernel_loops_min = kernel_loops_fixed;
14704 device_param->kernel_loops_max = kernel_loops_fixed;
14705 }
14706
14707 if (hash_mode == 9300)
14708 {
14709 const u32 kernel_loops_fixed = 1;
14710
14711 device_param->kernel_loops_min = kernel_loops_fixed;
14712 device_param->kernel_loops_max = kernel_loops_fixed;
14713 }
14714
14715 if (hash_mode == 12500)
14716 {
14717 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14718
14719 device_param->kernel_loops_min = kernel_loops_fixed;
14720 device_param->kernel_loops_max = kernel_loops_fixed;
14721 }
14722
14723 /**
14724 * some algorithms have a maximum kernel-loops count
14725 */
14726
14727 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14728 {
14729 u32 innerloop_cnt = 0;
14730
14731 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14732 {
14733 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14734 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14735 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14736 }
14737 else
14738 {
14739 innerloop_cnt = data.salts_buf[0].salt_iter;
14740 }
14741
14742 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14743 (innerloop_cnt <= device_param->kernel_loops_max))
14744 {
14745 device_param->kernel_loops_max = innerloop_cnt;
14746 }
14747 }
14748
14749 u32 kernel_accel_min = device_param->kernel_accel_min;
14750 u32 kernel_accel_max = device_param->kernel_accel_max;
14751
14752 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14753
14754 size_t size_pws = 4;
14755 size_t size_tmps = 4;
14756 size_t size_hooks = 4;
14757
14758 while (kernel_accel_max >= kernel_accel_min)
14759 {
14760 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14761
14762 // size_pws
14763
14764 size_pws = kernel_power_max * sizeof (pw_t);
14765
14766 // size_tmps
14767
14768 switch (hash_mode)
14769 {
14770 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14771 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14772 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14773 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14774 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14775 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14776 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14777 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14778 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14779 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14780 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14781 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14782 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14783 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14784 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14785 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14786 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14787 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14788 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14789 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14790 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14791 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14792 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14793 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14794 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14795 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14796 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14797 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14798 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14799 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14800 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14801 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14802 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14803 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14804 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14805 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14806 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14807 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14808 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14809 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14810 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14811 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14812 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14813 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14814 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14815 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14816 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14817 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14818 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14819 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14820 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14821 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14822 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14823 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14824 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14825 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14826 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14827 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14828 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14829 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14830 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14831 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14832 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14833 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14834 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14835 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14836 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14837 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14838 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14839 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14840 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14841 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14842 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14843 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14844 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14845 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14846 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14847 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14848 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14849 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14850 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14851 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14852 };
14853
14854 // size_hooks
14855
14856 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14857 {
14858 // none yet
14859 }
14860
14861 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14862 // if not, decrease amplifier and try again
14863
14864 int skip = 0;
14865
14866 const u64 size_total
14867 = bitmap_size
14868 + bitmap_size
14869 + bitmap_size
14870 + bitmap_size
14871 + bitmap_size
14872 + bitmap_size
14873 + bitmap_size
14874 + bitmap_size
14875 + size_bfs
14876 + size_combs
14877 + size_digests
14878 + size_esalts
14879 + size_hooks
14880 + size_markov_css
14881 + size_plains
14882 + size_pws
14883 + size_pws // not a bug
14884 + size_results
14885 + size_root_css
14886 + size_rules
14887 + size_rules_c
14888 + size_salts
14889 + size_scryptV
14890 + size_shown
14891 + size_tm
14892 + size_tmps;
14893
14894 // Don't ask me, ask AMD!
14895
14896 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14897 if (size_total > device_param->device_global_mem) skip = 1;
14898
14899 if (skip == 1)
14900 {
14901 kernel_accel_max--;
14902
14903 continue;
14904 }
14905
14906 break;
14907 }
14908
14909 /*
14910 if (kernel_accel_max == 0)
14911 {
14912 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14913
14914 return -1;
14915 }
14916 */
14917
14918 device_param->kernel_accel_min = kernel_accel_min;
14919 device_param->kernel_accel_max = kernel_accel_max;
14920
14921 /*
14922 if (kernel_accel_max < kernel_accel)
14923 {
14924 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14925
14926 device_param->kernel_accel = kernel_accel_max;
14927 }
14928 */
14929
14930 device_param->size_bfs = size_bfs;
14931 device_param->size_combs = size_combs;
14932 device_param->size_rules = size_rules;
14933 device_param->size_rules_c = size_rules_c;
14934 device_param->size_pws = size_pws;
14935 device_param->size_tmps = size_tmps;
14936 device_param->size_hooks = size_hooks;
14937
14938 /**
14939 * default building options
14940 */
14941
14942 char build_opts[1024] = { 0 };
14943
14944 // we don't have sm_* on vendors not NV but it doesn't matter
14945
14946 #if _WIN
14947 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\\OpenCL\\\" -I '%s\\OpenCL\\' -I %s\\OpenCL\\ -I\"%s\\OpenCL\\\" -I'%s\\OpenCL\\' -I%s\\OpenCL\\", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
14948 #else
14949 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s/OpenCL/\" -I '%s/OpenCL/' -I %s/OpenCL/ -I\"%s/OpenCL/\" -I'%s/OpenCL/' -I%s/OpenCL/", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
14950 #endif
14951
14952 char build_opts_new[1024] = { 0 };
14953
14954 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
14955
14956 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14957
14958 /*
14959 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14960 {
14961 // we do vectorizing much better than the auto-vectorizer
14962
14963 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14964
14965 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14966 }
14967 */
14968
14969 #ifdef DEBUG
14970 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14971 #endif
14972
14973 /**
14974 * main kernel
14975 */
14976
14977 {
14978 /**
14979 * kernel source filename
14980 */
14981
14982 char source_file[256] = { 0 };
14983
14984 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14985
14986 struct stat sst;
14987
14988 if (stat (source_file, &sst) == -1)
14989 {
14990 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14991
14992 return -1;
14993 }
14994
14995 /**
14996 * kernel cached filename
14997 */
14998
14999 char cached_file[256] = { 0 };
15000
15001 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15002
15003 int cached = 1;
15004
15005 struct stat cst;
15006
15007 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15008 {
15009 cached = 0;
15010 }
15011
15012 /**
15013 * kernel compile or load
15014 */
15015
15016 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15017
15018 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15019
15020 if (force_jit_compilation == -1)
15021 {
15022 if (cached == 0)
15023 {
15024 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15025
15026 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15027
15028 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15029
15030 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15031
15032 #ifdef DEBUG
15033 size_t build_log_size = 0;
15034
15035 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15036
15037 if (build_log_size > 1)
15038 {
15039 char *build_log = (char *) malloc (build_log_size + 1);
15040
15041 memset (build_log, 0, build_log_size + 1);
15042
15043 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15044
15045 puts (build_log);
15046
15047 free (build_log);
15048 }
15049 #endif
15050
15051 if (rc != 0)
15052 {
15053 device_param->skipped = true;
15054
15055 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15056
15057 continue;
15058 }
15059
15060 size_t binary_size;
15061
15062 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15063
15064 u8 *binary = (u8 *) mymalloc (binary_size);
15065
15066 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15067
15068 writeProgramBin (cached_file, binary, binary_size);
15069
15070 local_free (binary);
15071 }
15072 else
15073 {
15074 #ifdef DEBUG
15075 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15076 #endif
15077
15078 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15079
15080 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15081
15082 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15083 }
15084 }
15085 else
15086 {
15087 #ifdef DEBUG
15088 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15089 #endif
15090
15091 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15092
15093 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15094
15095 char build_opts_update[1024] = { 0 };
15096
15097 if (force_jit_compilation == 1500)
15098 {
15099 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15100 }
15101 else if (force_jit_compilation == 8900)
15102 {
15103 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%d -DSCRYPT_R=%d -DSCRYPT_P=%d -DSCRYPT_TMTO=%d", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.salts_buf[0].scrypt_tmto);
15104 }
15105 else
15106 {
15107 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15108 }
15109
15110 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15111
15112 #ifdef DEBUG
15113 size_t build_log_size = 0;
15114
15115 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15116
15117 if (build_log_size > 1)
15118 {
15119 char *build_log = (char *) malloc (build_log_size + 1);
15120
15121 memset (build_log, 0, build_log_size + 1);
15122
15123 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15124
15125 puts (build_log);
15126
15127 free (build_log);
15128 }
15129 #endif
15130
15131 if (rc != 0)
15132 {
15133 device_param->skipped = true;
15134
15135 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15136 }
15137 }
15138
15139 local_free (kernel_lengths);
15140 local_free (kernel_sources[0]);
15141 local_free (kernel_sources);
15142 }
15143
15144 /**
15145 * word generator kernel
15146 */
15147
15148 if (attack_mode != ATTACK_MODE_STRAIGHT)
15149 {
15150 /**
15151 * kernel mp source filename
15152 */
15153
15154 char source_file[256] = { 0 };
15155
15156 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15157
15158 struct stat sst;
15159
15160 if (stat (source_file, &sst) == -1)
15161 {
15162 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15163
15164 return -1;
15165 }
15166
15167 /**
15168 * kernel mp cached filename
15169 */
15170
15171 char cached_file[256] = { 0 };
15172
15173 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15174
15175 int cached = 1;
15176
15177 struct stat cst;
15178
15179 if (stat (cached_file, &cst) == -1)
15180 {
15181 cached = 0;
15182 }
15183
15184 /**
15185 * kernel compile or load
15186 */
15187
15188 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15189
15190 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15191
15192 if (cached == 0)
15193 {
15194 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15195 if (quiet == 0) log_info ("");
15196
15197 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15198
15199 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15200
15201 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15202
15203 if (rc != 0)
15204 {
15205 device_param->skipped = true;
15206
15207 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15208
15209 continue;
15210 }
15211
15212 size_t binary_size;
15213
15214 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15215
15216 u8 *binary = (u8 *) mymalloc (binary_size);
15217
15218 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15219
15220 writeProgramBin (cached_file, binary, binary_size);
15221
15222 local_free (binary);
15223 }
15224 else
15225 {
15226 #ifdef DEBUG
15227 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15228 #endif
15229
15230 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15231
15232 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15233
15234 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15235 }
15236
15237 local_free (kernel_lengths);
15238 local_free (kernel_sources[0]);
15239 local_free (kernel_sources);
15240 }
15241
15242 /**
15243 * amplifier kernel
15244 */
15245
15246 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15247 {
15248
15249 }
15250 else
15251 {
15252 /**
15253 * kernel amp source filename
15254 */
15255
15256 char source_file[256] = { 0 };
15257
15258 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15259
15260 struct stat sst;
15261
15262 if (stat (source_file, &sst) == -1)
15263 {
15264 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15265
15266 return -1;
15267 }
15268
15269 /**
15270 * kernel amp cached filename
15271 */
15272
15273 char cached_file[256] = { 0 };
15274
15275 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15276
15277 int cached = 1;
15278
15279 struct stat cst;
15280
15281 if (stat (cached_file, &cst) == -1)
15282 {
15283 cached = 0;
15284 }
15285
15286 /**
15287 * kernel compile or load
15288 */
15289
15290 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15291
15292 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15293
15294 if (cached == 0)
15295 {
15296 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15297 if (quiet == 0) log_info ("");
15298
15299 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15300
15301 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15302
15303 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15304
15305 if (rc != 0)
15306 {
15307 device_param->skipped = true;
15308
15309 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15310
15311 continue;
15312 }
15313
15314 size_t binary_size;
15315
15316 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15317
15318 u8 *binary = (u8 *) mymalloc (binary_size);
15319
15320 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15321
15322 writeProgramBin (cached_file, binary, binary_size);
15323
15324 local_free (binary);
15325 }
15326 else
15327 {
15328 #ifdef DEBUG
15329 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15330 #endif
15331
15332 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15333
15334 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15335
15336 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15337 }
15338
15339 local_free (kernel_lengths);
15340 local_free (kernel_sources[0]);
15341 local_free (kernel_sources);
15342 }
15343
15344 // some algorithm collide too fast, make that impossible
15345
15346 if (benchmark == 1)
15347 {
15348 ((uint *) digests_buf)[0] = -1;
15349 ((uint *) digests_buf)[1] = -1;
15350 ((uint *) digests_buf)[2] = -1;
15351 ((uint *) digests_buf)[3] = -1;
15352 }
15353
15354 /**
15355 * global buffers
15356 */
15357
15358 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15359 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15360 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15361 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15362 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15363 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15364 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15365 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15366 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15367 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15368 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15369 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15370 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15371 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15372 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15373 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15374 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15375 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15376
15377 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL);
15378 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL);
15379 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_c, CL_TRUE, 0, bitmap_size, bitmap_s1_c, 0, NULL, NULL);
15380 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_d, CL_TRUE, 0, bitmap_size, bitmap_s1_d, 0, NULL, NULL);
15381 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_a, CL_TRUE, 0, bitmap_size, bitmap_s2_a, 0, NULL, NULL);
15382 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_b, CL_TRUE, 0, bitmap_size, bitmap_s2_b, 0, NULL, NULL);
15383 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_c, CL_TRUE, 0, bitmap_size, bitmap_s2_c, 0, NULL, NULL);
15384 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s2_d, CL_TRUE, 0, bitmap_size, bitmap_s2_d, 0, NULL, NULL);
15385 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15386 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15387 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15388
15389 /**
15390 * special buffers
15391 */
15392
15393 if (attack_kern == ATTACK_KERN_STRAIGHT)
15394 {
15395 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15396 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15397
15398 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15399 }
15400 else if (attack_kern == ATTACK_KERN_COMBI)
15401 {
15402 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15403 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15404 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15405 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15406 }
15407 else if (attack_kern == ATTACK_KERN_BF)
15408 {
15409 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15410 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15411 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15412 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15413 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15414 }
15415
15416 if (size_esalts)
15417 {
15418 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15419
15420 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15421 }
15422
15423 /**
15424 * main host data
15425 */
15426
15427 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15428
15429 device_param->pws_buf = pws_buf;
15430
15431 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15432
15433 device_param->combs_buf = combs_buf;
15434
15435 void *hooks_buf = mymalloc (size_hooks);
15436
15437 device_param->hooks_buf = hooks_buf;
15438
15439 /**
15440 * kernel args
15441 */
15442
15443 device_param->kernel_params_buf32[21] = bitmap_mask;
15444 device_param->kernel_params_buf32[22] = bitmap_shift1;
15445 device_param->kernel_params_buf32[23] = bitmap_shift2;
15446 device_param->kernel_params_buf32[24] = 0; // salt_pos
15447 device_param->kernel_params_buf32[25] = 0; // loop_pos
15448 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15449 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15450 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15451 device_param->kernel_params_buf32[29] = 0; // digests_offset
15452 device_param->kernel_params_buf32[30] = 0; // combs_mode
15453 device_param->kernel_params_buf32[31] = 0; // gid_max
15454
15455 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15456 ? &device_param->d_pws_buf
15457 : &device_param->d_pws_amp_buf;
15458 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15459 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15460 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15461 device_param->kernel_params[ 4] = &device_param->d_tmps;
15462 device_param->kernel_params[ 5] = &device_param->d_hooks;
15463 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15464 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15465 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15466 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15467 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15468 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15469 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15470 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15471 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15472 device_param->kernel_params[15] = &device_param->d_digests_buf;
15473 device_param->kernel_params[16] = &device_param->d_digests_shown;
15474 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15475 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15476 device_param->kernel_params[19] = &device_param->d_result;
15477 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15478 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15479 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15480 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15481 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15482 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15483 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15484 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15485 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15486 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15487 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15488 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15489
15490 device_param->kernel_params_mp_buf64[3] = 0;
15491 device_param->kernel_params_mp_buf32[4] = 0;
15492 device_param->kernel_params_mp_buf32[5] = 0;
15493 device_param->kernel_params_mp_buf32[6] = 0;
15494 device_param->kernel_params_mp_buf32[7] = 0;
15495 device_param->kernel_params_mp_buf32[8] = 0;
15496
15497 device_param->kernel_params_mp[0] = NULL;
15498 device_param->kernel_params_mp[1] = NULL;
15499 device_param->kernel_params_mp[2] = NULL;
15500 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15501 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15502 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15503 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15504 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15505 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15506
15507 device_param->kernel_params_mp_l_buf64[3] = 0;
15508 device_param->kernel_params_mp_l_buf32[4] = 0;
15509 device_param->kernel_params_mp_l_buf32[5] = 0;
15510 device_param->kernel_params_mp_l_buf32[6] = 0;
15511 device_param->kernel_params_mp_l_buf32[7] = 0;
15512 device_param->kernel_params_mp_l_buf32[8] = 0;
15513 device_param->kernel_params_mp_l_buf32[9] = 0;
15514
15515 device_param->kernel_params_mp_l[0] = NULL;
15516 device_param->kernel_params_mp_l[1] = NULL;
15517 device_param->kernel_params_mp_l[2] = NULL;
15518 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15519 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15520 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15521 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15522 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15523 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15524 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15525
15526 device_param->kernel_params_mp_r_buf64[3] = 0;
15527 device_param->kernel_params_mp_r_buf32[4] = 0;
15528 device_param->kernel_params_mp_r_buf32[5] = 0;
15529 device_param->kernel_params_mp_r_buf32[6] = 0;
15530 device_param->kernel_params_mp_r_buf32[7] = 0;
15531 device_param->kernel_params_mp_r_buf32[8] = 0;
15532
15533 device_param->kernel_params_mp_r[0] = NULL;
15534 device_param->kernel_params_mp_r[1] = NULL;
15535 device_param->kernel_params_mp_r[2] = NULL;
15536 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15537 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15538 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15539 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15540 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15541 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15542
15543 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15544 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15545
15546 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15547 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15548 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15549 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15550 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15551 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15552 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15553
15554 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15555 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15556
15557 device_param->kernel_params_memset_buf32[1] = 0; // value
15558 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15559
15560 device_param->kernel_params_memset[0] = NULL;
15561 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15562 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15563
15564 /**
15565 * kernel name
15566 */
15567
15568 size_t kernel_wgs_tmp;
15569
15570 char kernel_name[64] = { 0 };
15571
15572 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15573 {
15574 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15575 {
15576 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15577
15578 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15579
15580 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15581
15582 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15583
15584 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15585
15586 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15587 }
15588 else
15589 {
15590 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15591
15592 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15593
15594 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15595
15596 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15597
15598 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15599
15600 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15601 }
15602
15603 if (data.attack_mode == ATTACK_MODE_BF)
15604 {
15605 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15606 {
15607 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15608
15609 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15610
15611 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_tm, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15612 }
15613 }
15614 }
15615 else
15616 {
15617 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15618
15619 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15620
15621 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15622
15623 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15624
15625 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15626
15627 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15628
15629 if (opts_type & OPTS_TYPE_HOOK12)
15630 {
15631 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15632
15633 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15634
15635 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel12, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15636 }
15637
15638 if (opts_type & OPTS_TYPE_HOOK23)
15639 {
15640 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15641
15642 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15643
15644 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel23, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15645 }
15646 }
15647
15648 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel1, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15649 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel2, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15650 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel3, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15651
15652 for (uint i = 0; i <= 20; i++)
15653 {
15654 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15655 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15656 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15657
15658 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15659 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15660 }
15661
15662 for (uint i = 21; i <= 31; i++)
15663 {
15664 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15665 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15666 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15667
15668 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15669 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15670 }
15671
15672 // GPU memset
15673
15674 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15675
15676 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_memset, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15677
15678 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15679 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15680 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15681
15682 // MP start
15683
15684 if (attack_mode == ATTACK_MODE_BF)
15685 {
15686 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15687 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15688
15689 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp_l, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15690 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp_r, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15691
15692 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15693 {
15694 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15695 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15696 }
15697 }
15698 else if (attack_mode == ATTACK_MODE_HYBRID1)
15699 {
15700 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15701
15702 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15703 }
15704 else if (attack_mode == ATTACK_MODE_HYBRID2)
15705 {
15706 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15707
15708 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_mp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15709 }
15710
15711 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15712 {
15713 // nothing to do
15714 }
15715 else
15716 {
15717 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15718
15719 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_amp, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15720 }
15721
15722 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15723 {
15724 // nothing to do
15725 }
15726 else
15727 {
15728 for (uint i = 0; i < 5; i++)
15729 {
15730 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15731 }
15732
15733 for (uint i = 5; i < 7; i++)
15734 {
15735 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15736 }
15737 }
15738
15739 // maybe this has been updated by clGetKernelWorkGroupInfo()
15740 // value can only be decreased, so we don't need to reallocate buffers
15741
15742 device_param->kernel_threads = kernel_threads;
15743
15744 // zero some data buffers
15745
15746 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15747 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15748 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15749 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15750 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15751 run_kernel_bzero (device_param, device_param->d_result, size_results);
15752
15753 /**
15754 * special buffers
15755 */
15756
15757 if (attack_kern == ATTACK_KERN_STRAIGHT)
15758 {
15759 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15760 }
15761 else if (attack_kern == ATTACK_KERN_COMBI)
15762 {
15763 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15764 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15765 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15766 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15767 }
15768 else if (attack_kern == ATTACK_KERN_BF)
15769 {
15770 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15771 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15772 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15773 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15774 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15775 }
15776
15777 #if defined(HAVE_HWMON)
15778
15779 /**
15780 * Store initial fanspeed if gpu_temp_retain is enabled
15781 */
15782
15783 if (gpu_temp_disable == 0)
15784 {
15785 if (gpu_temp_retain != 0)
15786 {
15787 hc_thread_mutex_lock (mux_adl);
15788
15789 if (data.hm_device[device_id].fan_get_supported == 1)
15790 {
15791 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15792 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15793
15794 temp_retain_fanspeed_value[device_id] = fanspeed;
15795 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15796
15797 // we also set it to tell the OS we take control over the fan and it's automatic controller
15798 // if it was set to automatic. we do not control user-defined fanspeeds.
15799
15800 if (fanpolicy == 1)
15801 {
15802 data.hm_device[device_id].fan_set_supported = 1;
15803
15804 int rc = -1;
15805
15806 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15807 {
15808 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
15809 }
15810 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15811 {
15812
15813 }
15814
15815 if (rc == 0)
15816 {
15817 data.hm_device[device_id].fan_set_supported = 1;
15818 }
15819 else
15820 {
15821 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15822
15823 data.hm_device[device_id].fan_set_supported = 0;
15824 }
15825 }
15826 else
15827 {
15828 data.hm_device[device_id].fan_set_supported = 0;
15829 }
15830 }
15831
15832 hc_thread_mutex_unlock (mux_adl);
15833 }
15834 }
15835
15836 #endif // HAVE_HWMON
15837 }
15838
15839 if (data.quiet == 0) log_info_nn ("");
15840
15841 /**
15842 * In benchmark-mode, inform user which algorithm is checked
15843 */
15844
15845 if (benchmark == 1)
15846 {
15847 if (machine_readable == 0)
15848 {
15849 quiet = 0;
15850
15851 data.quiet = quiet;
15852
15853 char *hash_type = strhashtype (data.hash_mode); // not a bug
15854
15855 log_info ("Hashtype: %s", hash_type);
15856 log_info ("");
15857 }
15858 }
15859
15860 /**
15861 * keep track of the progress
15862 */
15863
15864 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15865 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15866 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15867
15868 /**
15869 * open filehandles
15870 */
15871
15872 #if _WIN
15873 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15874 {
15875 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15876
15877 return (-1);
15878 }
15879
15880 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15881 {
15882 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15883
15884 return (-1);
15885 }
15886
15887 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15888 {
15889 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15890
15891 return (-1);
15892 }
15893 #endif
15894
15895 /**
15896 * dictionary pad
15897 */
15898
15899 segment_size *= (1024 * 1024);
15900
15901 data.segment_size = segment_size;
15902
15903 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15904
15905 wl_data->buf = (char *) mymalloc (segment_size);
15906 wl_data->avail = segment_size;
15907 wl_data->incr = segment_size;
15908 wl_data->cnt = 0;
15909 wl_data->pos = 0;
15910
15911 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15912
15913 data.wordlist_mode = wordlist_mode;
15914
15915 cs_t *css_buf = NULL;
15916 uint css_cnt = 0;
15917 uint dictcnt = 0;
15918 uint maskcnt = 1;
15919 char **masks = NULL;
15920 char **dictfiles = NULL;
15921
15922 uint mask_from_file = 0;
15923
15924 if (attack_mode == ATTACK_MODE_STRAIGHT)
15925 {
15926 if (wordlist_mode == WL_MODE_FILE)
15927 {
15928 int wls_left = myargc - (optind + 1);
15929
15930 for (int i = 0; i < wls_left; i++)
15931 {
15932 char *l0_filename = myargv[optind + 1 + i];
15933
15934 struct stat l0_stat;
15935
15936 if (stat (l0_filename, &l0_stat) == -1)
15937 {
15938 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15939
15940 return (-1);
15941 }
15942
15943 uint is_dir = S_ISDIR (l0_stat.st_mode);
15944
15945 if (is_dir == 0)
15946 {
15947 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15948
15949 dictcnt++;
15950
15951 dictfiles[dictcnt - 1] = l0_filename;
15952 }
15953 else
15954 {
15955 // do not allow --keyspace w/ a directory
15956
15957 if (keyspace == 1)
15958 {
15959 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15960
15961 return (-1);
15962 }
15963
15964 char **dictionary_files = NULL;
15965
15966 dictionary_files = scan_directory (l0_filename);
15967
15968 if (dictionary_files != NULL)
15969 {
15970 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15971
15972 for (int d = 0; dictionary_files[d] != NULL; d++)
15973 {
15974 char *l1_filename = dictionary_files[d];
15975
15976 struct stat l1_stat;
15977
15978 if (stat (l1_filename, &l1_stat) == -1)
15979 {
15980 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15981
15982 return (-1);
15983 }
15984
15985 if (S_ISREG (l1_stat.st_mode))
15986 {
15987 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15988
15989 dictcnt++;
15990
15991 dictfiles[dictcnt - 1] = strdup (l1_filename);
15992 }
15993 }
15994 }
15995
15996 local_free (dictionary_files);
15997 }
15998 }
15999
16000 if (dictcnt < 1)
16001 {
16002 log_error ("ERROR: No usable dictionary file found.");
16003
16004 return (-1);
16005 }
16006 }
16007 else if (wordlist_mode == WL_MODE_STDIN)
16008 {
16009 dictcnt = 1;
16010 }
16011 }
16012 else if (attack_mode == ATTACK_MODE_COMBI)
16013 {
16014 // display
16015
16016 char *dictfile1 = myargv[optind + 1 + 0];
16017 char *dictfile2 = myargv[optind + 1 + 1];
16018
16019 // find the bigger dictionary and use as base
16020
16021 FILE *fp1 = NULL;
16022 FILE *fp2 = NULL;
16023
16024 struct stat tmp_stat;
16025
16026 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16027 {
16028 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16029
16030 return (-1);
16031 }
16032
16033 if (stat (dictfile1, &tmp_stat) == -1)
16034 {
16035 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16036
16037 fclose (fp1);
16038
16039 return (-1);
16040 }
16041
16042 if (S_ISDIR (tmp_stat.st_mode))
16043 {
16044 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16045
16046 fclose (fp1);
16047
16048 return (-1);
16049 }
16050
16051 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16052 {
16053 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16054
16055 fclose (fp1);
16056
16057 return (-1);
16058 }
16059
16060 if (stat (dictfile2, &tmp_stat) == -1)
16061 {
16062 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16063
16064 fclose (fp1);
16065 fclose (fp2);
16066
16067 return (-1);
16068 }
16069
16070 if (S_ISDIR (tmp_stat.st_mode))
16071 {
16072 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16073
16074 fclose (fp1);
16075 fclose (fp2);
16076
16077 return (-1);
16078 }
16079
16080 data.combs_cnt = 1;
16081
16082 data.quiet = 1;
16083
16084 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16085
16086 data.quiet = quiet;
16087
16088 if (words1_cnt == 0)
16089 {
16090 log_error ("ERROR: %s: empty file", dictfile1);
16091
16092 fclose (fp1);
16093 fclose (fp2);
16094
16095 return (-1);
16096 }
16097
16098 data.combs_cnt = 1;
16099
16100 data.quiet = 1;
16101
16102 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16103
16104 data.quiet = quiet;
16105
16106 if (words2_cnt == 0)
16107 {
16108 log_error ("ERROR: %s: empty file", dictfile2);
16109
16110 fclose (fp1);
16111 fclose (fp2);
16112
16113 return (-1);
16114 }
16115
16116 fclose (fp1);
16117 fclose (fp2);
16118
16119 data.dictfile = dictfile1;
16120 data.dictfile2 = dictfile2;
16121
16122 if (words1_cnt >= words2_cnt)
16123 {
16124 data.combs_cnt = words2_cnt;
16125 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16126
16127 dictfiles = &data.dictfile;
16128
16129 dictcnt = 1;
16130 }
16131 else
16132 {
16133 data.combs_cnt = words1_cnt;
16134 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16135
16136 dictfiles = &data.dictfile2;
16137
16138 dictcnt = 1;
16139
16140 // we also have to switch wordlist related rules!
16141
16142 char *tmpc = data.rule_buf_l;
16143
16144 data.rule_buf_l = data.rule_buf_r;
16145 data.rule_buf_r = tmpc;
16146
16147 int tmpi = data.rule_len_l;
16148
16149 data.rule_len_l = data.rule_len_r;
16150 data.rule_len_r = tmpi;
16151 }
16152 }
16153 else if (attack_mode == ATTACK_MODE_BF)
16154 {
16155 char *mask = NULL;
16156
16157 maskcnt = 0;
16158
16159 if (benchmark == 0)
16160 {
16161 mask = myargv[optind + 1];
16162
16163 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16164
16165 if ((optind + 2) <= myargc)
16166 {
16167 struct stat file_stat;
16168
16169 if (stat (mask, &file_stat) == -1)
16170 {
16171 maskcnt = 1;
16172
16173 masks[maskcnt - 1] = mystrdup (mask);
16174 }
16175 else
16176 {
16177 int wls_left = myargc - (optind + 1);
16178
16179 uint masks_avail = INCR_MASKS;
16180
16181 for (int i = 0; i < wls_left; i++)
16182 {
16183 if (i != 0)
16184 {
16185 mask = myargv[optind + 1 + i];
16186
16187 if (stat (mask, &file_stat) == -1)
16188 {
16189 log_error ("ERROR: %s: %s", mask, strerror (errno));
16190
16191 return (-1);
16192 }
16193 }
16194
16195 uint is_file = S_ISREG (file_stat.st_mode);
16196
16197 if (is_file == 1)
16198 {
16199 FILE *mask_fp;
16200
16201 if ((mask_fp = fopen (mask, "r")) == NULL)
16202 {
16203 log_error ("ERROR: %s: %s", mask, strerror (errno));
16204
16205 return (-1);
16206 }
16207
16208 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16209
16210 while (!feof (mask_fp))
16211 {
16212 memset (line_buf, 0, HCBUFSIZ);
16213
16214 int line_len = fgetl (mask_fp, line_buf);
16215
16216 if (line_len == 0) continue;
16217
16218 if (line_buf[0] == '#') continue;
16219
16220 if (masks_avail == maskcnt)
16221 {
16222 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16223
16224 masks_avail += INCR_MASKS;
16225 }
16226
16227 masks[maskcnt] = mystrdup (line_buf);
16228
16229 maskcnt++;
16230 }
16231
16232 myfree (line_buf);
16233
16234 fclose (mask_fp);
16235 }
16236 else
16237 {
16238 log_error ("ERROR: %s: unsupported file-type", mask);
16239
16240 return (-1);
16241 }
16242 }
16243
16244 mask_from_file = 1;
16245 }
16246 }
16247 else
16248 {
16249 custom_charset_1 = (char *) "?l?d?u";
16250 custom_charset_2 = (char *) "?l?d";
16251 custom_charset_3 = (char *) "?l?d*!$@_";
16252
16253 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16254 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16255 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16256
16257 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16258
16259 wordlist_mode = WL_MODE_MASK;
16260
16261 data.wordlist_mode = wordlist_mode;
16262
16263 increment = 1;
16264
16265 maskcnt = 1;
16266 }
16267 }
16268 else
16269 {
16270 /**
16271 * generate full masks and charsets
16272 */
16273
16274 masks = (char **) mymalloc (sizeof (char *));
16275
16276 switch (hash_mode)
16277 {
16278 case 1731: pw_min = 5;
16279 pw_max = 5;
16280 mask = mystrdup ("?b?b?b?b?b");
16281 break;
16282 case 12500: pw_min = 5;
16283 pw_max = 5;
16284 mask = mystrdup ("?b?b?b?b?b");
16285 break;
16286 default: pw_min = 7;
16287 pw_max = 7;
16288 mask = mystrdup ("?b?b?b?b?b?b?b");
16289 break;
16290 }
16291
16292 maskcnt = 1;
16293
16294 masks[maskcnt - 1] = mystrdup (mask);
16295
16296 wordlist_mode = WL_MODE_MASK;
16297
16298 data.wordlist_mode = wordlist_mode;
16299
16300 increment = 1;
16301 }
16302
16303 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16304
16305 if (increment)
16306 {
16307 if (increment_min > pw_min) pw_min = increment_min;
16308
16309 if (increment_max < pw_max) pw_max = increment_max;
16310 }
16311 }
16312 else if (attack_mode == ATTACK_MODE_HYBRID1)
16313 {
16314 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16315
16316 // display
16317
16318 char *mask = myargv[myargc - 1];
16319
16320 maskcnt = 0;
16321
16322 masks = (char **) mymalloc (1 * sizeof (char *));
16323
16324 // mod
16325
16326 struct stat file_stat;
16327
16328 if (stat (mask, &file_stat) == -1)
16329 {
16330 maskcnt = 1;
16331
16332 masks[maskcnt - 1] = mystrdup (mask);
16333 }
16334 else
16335 {
16336 uint is_file = S_ISREG (file_stat.st_mode);
16337
16338 if (is_file == 1)
16339 {
16340 FILE *mask_fp;
16341
16342 if ((mask_fp = fopen (mask, "r")) == NULL)
16343 {
16344 log_error ("ERROR: %s: %s", mask, strerror (errno));
16345
16346 return (-1);
16347 }
16348
16349 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16350
16351 uint masks_avail = 1;
16352
16353 while (!feof (mask_fp))
16354 {
16355 memset (line_buf, 0, HCBUFSIZ);
16356
16357 int line_len = fgetl (mask_fp, line_buf);
16358
16359 if (line_len == 0) continue;
16360
16361 if (line_buf[0] == '#') continue;
16362
16363 if (masks_avail == maskcnt)
16364 {
16365 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16366
16367 masks_avail += INCR_MASKS;
16368 }
16369
16370 masks[maskcnt] = mystrdup (line_buf);
16371
16372 maskcnt++;
16373 }
16374
16375 myfree (line_buf);
16376
16377 fclose (mask_fp);
16378
16379 mask_from_file = 1;
16380 }
16381 else
16382 {
16383 maskcnt = 1;
16384
16385 masks[maskcnt - 1] = mystrdup (mask);
16386 }
16387 }
16388
16389 // base
16390
16391 int wls_left = myargc - (optind + 2);
16392
16393 for (int i = 0; i < wls_left; i++)
16394 {
16395 char *filename = myargv[optind + 1 + i];
16396
16397 struct stat file_stat;
16398
16399 if (stat (filename, &file_stat) == -1)
16400 {
16401 log_error ("ERROR: %s: %s", filename, strerror (errno));
16402
16403 return (-1);
16404 }
16405
16406 uint is_dir = S_ISDIR (file_stat.st_mode);
16407
16408 if (is_dir == 0)
16409 {
16410 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16411
16412 dictcnt++;
16413
16414 dictfiles[dictcnt - 1] = filename;
16415 }
16416 else
16417 {
16418 // do not allow --keyspace w/ a directory
16419
16420 if (keyspace == 1)
16421 {
16422 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16423
16424 return (-1);
16425 }
16426
16427 char **dictionary_files = NULL;
16428
16429 dictionary_files = scan_directory (filename);
16430
16431 if (dictionary_files != NULL)
16432 {
16433 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16434
16435 for (int d = 0; dictionary_files[d] != NULL; d++)
16436 {
16437 char *l1_filename = dictionary_files[d];
16438
16439 struct stat l1_stat;
16440
16441 if (stat (l1_filename, &l1_stat) == -1)
16442 {
16443 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16444
16445 return (-1);
16446 }
16447
16448 if (S_ISREG (l1_stat.st_mode))
16449 {
16450 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16451
16452 dictcnt++;
16453
16454 dictfiles[dictcnt - 1] = strdup (l1_filename);
16455 }
16456 }
16457 }
16458
16459 local_free (dictionary_files);
16460 }
16461 }
16462
16463 if (dictcnt < 1)
16464 {
16465 log_error ("ERROR: No usable dictionary file found.");
16466
16467 return (-1);
16468 }
16469
16470 if (increment)
16471 {
16472 maskcnt = 0;
16473
16474 uint mask_min = increment_min; // we can't reject smaller masks here
16475 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16476
16477 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16478 {
16479 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16480
16481 if (cur_mask == NULL) break;
16482
16483 masks[maskcnt] = cur_mask;
16484
16485 maskcnt++;
16486
16487 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16488 }
16489 }
16490 }
16491 else if (attack_mode == ATTACK_MODE_HYBRID2)
16492 {
16493 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16494
16495 // display
16496
16497 char *mask = myargv[optind + 1 + 0];
16498
16499 maskcnt = 0;
16500
16501 masks = (char **) mymalloc (1 * sizeof (char *));
16502
16503 // mod
16504
16505 struct stat file_stat;
16506
16507 if (stat (mask, &file_stat) == -1)
16508 {
16509 maskcnt = 1;
16510
16511 masks[maskcnt - 1] = mystrdup (mask);
16512 }
16513 else
16514 {
16515 uint is_file = S_ISREG (file_stat.st_mode);
16516
16517 if (is_file == 1)
16518 {
16519 FILE *mask_fp;
16520
16521 if ((mask_fp = fopen (mask, "r")) == NULL)
16522 {
16523 log_error ("ERROR: %s: %s", mask, strerror (errno));
16524
16525 return (-1);
16526 }
16527
16528 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16529
16530 uint masks_avail = 1;
16531
16532 while (!feof (mask_fp))
16533 {
16534 memset (line_buf, 0, HCBUFSIZ);
16535
16536 int line_len = fgetl (mask_fp, line_buf);
16537
16538 if (line_len == 0) continue;
16539
16540 if (line_buf[0] == '#') continue;
16541
16542 if (masks_avail == maskcnt)
16543 {
16544 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16545
16546 masks_avail += INCR_MASKS;
16547 }
16548
16549 masks[maskcnt] = mystrdup (line_buf);
16550
16551 maskcnt++;
16552 }
16553
16554 myfree (line_buf);
16555
16556 fclose (mask_fp);
16557
16558 mask_from_file = 1;
16559 }
16560 else
16561 {
16562 maskcnt = 1;
16563
16564 masks[maskcnt - 1] = mystrdup (mask);
16565 }
16566 }
16567
16568 // base
16569
16570 int wls_left = myargc - (optind + 2);
16571
16572 for (int i = 0; i < wls_left; i++)
16573 {
16574 char *filename = myargv[optind + 2 + i];
16575
16576 struct stat file_stat;
16577
16578 if (stat (filename, &file_stat) == -1)
16579 {
16580 log_error ("ERROR: %s: %s", filename, strerror (errno));
16581
16582 return (-1);
16583 }
16584
16585 uint is_dir = S_ISDIR (file_stat.st_mode);
16586
16587 if (is_dir == 0)
16588 {
16589 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16590
16591 dictcnt++;
16592
16593 dictfiles[dictcnt - 1] = filename;
16594 }
16595 else
16596 {
16597 // do not allow --keyspace w/ a directory
16598
16599 if (keyspace == 1)
16600 {
16601 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16602
16603 return (-1);
16604 }
16605
16606 char **dictionary_files = NULL;
16607
16608 dictionary_files = scan_directory (filename);
16609
16610 if (dictionary_files != NULL)
16611 {
16612 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16613
16614 for (int d = 0; dictionary_files[d] != NULL; d++)
16615 {
16616 char *l1_filename = dictionary_files[d];
16617
16618 struct stat l1_stat;
16619
16620 if (stat (l1_filename, &l1_stat) == -1)
16621 {
16622 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16623
16624 return (-1);
16625 }
16626
16627 if (S_ISREG (l1_stat.st_mode))
16628 {
16629 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16630
16631 dictcnt++;
16632
16633 dictfiles[dictcnt - 1] = strdup (l1_filename);
16634 }
16635 }
16636 }
16637
16638 local_free (dictionary_files);
16639 }
16640 }
16641
16642 if (dictcnt < 1)
16643 {
16644 log_error ("ERROR: No usable dictionary file found.");
16645
16646 return (-1);
16647 }
16648
16649 if (increment)
16650 {
16651 maskcnt = 0;
16652
16653 uint mask_min = increment_min; // we can't reject smaller masks here
16654 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16655
16656 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16657 {
16658 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16659
16660 if (cur_mask == NULL) break;
16661
16662 masks[maskcnt] = cur_mask;
16663
16664 maskcnt++;
16665
16666 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16667 }
16668 }
16669 }
16670
16671 data.pw_min = pw_min;
16672 data.pw_max = pw_max;
16673
16674 /**
16675 * weak hash check
16676 */
16677
16678 if (weak_hash_threshold >= salts_cnt)
16679 {
16680 hc_device_param_t *device_param = NULL;
16681
16682 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16683 {
16684 device_param = &data.devices_param[device_id];
16685
16686 if (device_param->skipped) continue;
16687
16688 break;
16689 }
16690
16691 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16692
16693 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16694 {
16695 weak_hash_check (device_param, salt_pos);
16696 }
16697
16698 // Display hack, guarantee that there is at least one \r before real start
16699
16700 //if (data.quiet == 0) log_info ("");
16701 }
16702
16703 /**
16704 * status and monitor threads
16705 */
16706
16707 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16708
16709 hc_thread_t i_thread = 0;
16710
16711 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16712 {
16713 hc_thread_create (i_thread, thread_keypress, &benchmark);
16714 }
16715
16716 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16717
16718 uint ni_threads_cnt = 0;
16719
16720 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16721
16722 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16723
16724 ni_threads_cnt++;
16725
16726 /**
16727 * Outfile remove
16728 */
16729
16730 if (keyspace == 0)
16731 {
16732 if (outfile_check_timer != 0)
16733 {
16734 if (data.outfile_check_directory != NULL)
16735 {
16736 if ((hash_mode != 5200) &&
16737 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16738 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16739 (hash_mode != 9000))
16740 {
16741 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16742
16743 ni_threads_cnt++;
16744 }
16745 else
16746 {
16747 outfile_check_timer = 0;
16748 }
16749 }
16750 else
16751 {
16752 outfile_check_timer = 0;
16753 }
16754 }
16755 }
16756
16757 /**
16758 * Inform the user if we got some hashes remove because of the pot file remove feature
16759 */
16760
16761 if (data.quiet == 0)
16762 {
16763 if (potfile_remove_cracks > 0)
16764 {
16765 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16766 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16767 }
16768 }
16769
16770 data.outfile_check_timer = outfile_check_timer;
16771
16772 /**
16773 * main loop
16774 */
16775
16776 char **induction_dictionaries = NULL;
16777
16778 int induction_dictionaries_cnt = 0;
16779
16780 hcstat_table_t *root_table_buf = NULL;
16781 hcstat_table_t *markov_table_buf = NULL;
16782
16783 uint initial_restore_done = 0;
16784
16785 data.maskcnt = maskcnt;
16786
16787 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16788 {
16789 if (data.devices_status == STATUS_CRACKED) break;
16790
16791 data.devices_status = STATUS_INIT;
16792
16793 if (maskpos > rd->maskpos)
16794 {
16795 rd->dictpos = 0;
16796 }
16797
16798 rd->maskpos = maskpos;
16799 data.maskpos = maskpos;
16800
16801 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16802 {
16803 char *mask = masks[maskpos];
16804
16805 if (mask_from_file == 1)
16806 {
16807 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16808
16809 char *str_ptr;
16810 uint str_pos;
16811
16812 uint mask_offset = 0;
16813
16814 uint separator_cnt;
16815
16816 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16817 {
16818 str_ptr = strstr (mask + mask_offset, ",");
16819
16820 if (str_ptr == NULL) break;
16821
16822 str_pos = str_ptr - mask;
16823
16824 // escaped separator, i.e. "\,"
16825
16826 if (str_pos > 0)
16827 {
16828 if (mask[str_pos - 1] == '\\')
16829 {
16830 separator_cnt --;
16831
16832 mask_offset = str_pos + 1;
16833
16834 continue;
16835 }
16836 }
16837
16838 // reset the offset
16839
16840 mask_offset = 0;
16841
16842 mask[str_pos] = '\0';
16843
16844 switch (separator_cnt)
16845 {
16846 case 0:
16847 mp_reset_usr (mp_usr, 0);
16848
16849 custom_charset_1 = mask;
16850 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16851 break;
16852
16853 case 1:
16854 mp_reset_usr (mp_usr, 1);
16855
16856 custom_charset_2 = mask;
16857 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16858 break;
16859
16860 case 2:
16861 mp_reset_usr (mp_usr, 2);
16862
16863 custom_charset_3 = mask;
16864 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16865 break;
16866
16867 case 3:
16868 mp_reset_usr (mp_usr, 3);
16869
16870 custom_charset_4 = mask;
16871 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16872 break;
16873 }
16874
16875 mask = mask + str_pos + 1;
16876 }
16877 }
16878
16879 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16880 {
16881 if (maskpos > 0)
16882 {
16883 local_free (css_buf);
16884 local_free (data.root_css_buf);
16885 local_free (data.markov_css_buf);
16886
16887 local_free (masks[maskpos - 1]);
16888 }
16889
16890 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16891
16892 data.mask = mask;
16893 data.css_cnt = css_cnt;
16894 data.css_buf = css_buf;
16895
16896 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16897
16898 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16899
16900 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16901 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16902
16903 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16904
16905 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16906
16907 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16908 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16909
16910 data.root_css_buf = root_css_buf;
16911 data.markov_css_buf = markov_css_buf;
16912
16913 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16914
16915 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16916
16917 local_free (root_table_buf);
16918 local_free (markov_table_buf);
16919
16920 // args
16921
16922 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16923 {
16924 hc_device_param_t *device_param = &data.devices_param[device_id];
16925
16926 if (device_param->skipped) continue;
16927
16928 device_param->kernel_params_mp[0] = &device_param->d_combs;
16929 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16930 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16931
16932 device_param->kernel_params_mp_buf64[3] = 0;
16933 device_param->kernel_params_mp_buf32[4] = css_cnt;
16934 device_param->kernel_params_mp_buf32[5] = 0;
16935 device_param->kernel_params_mp_buf32[6] = 0;
16936 device_param->kernel_params_mp_buf32[7] = 0;
16937
16938 if (attack_mode == ATTACK_MODE_HYBRID1)
16939 {
16940 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16941 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16942 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16943 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16944 }
16945 else if (attack_mode == ATTACK_MODE_HYBRID2)
16946 {
16947 device_param->kernel_params_mp_buf32[5] = 0;
16948 device_param->kernel_params_mp_buf32[6] = 0;
16949 device_param->kernel_params_mp_buf32[7] = 0;
16950 }
16951
16952 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
16953 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
16954 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
16955
16956 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
16957 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
16958 }
16959 }
16960 else if (attack_mode == ATTACK_MODE_BF)
16961 {
16962 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16963
16964 if (increment)
16965 {
16966 for (uint i = 0; i < dictcnt; i++)
16967 {
16968 local_free (dictfiles[i]);
16969 }
16970
16971 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16972 {
16973 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16974
16975 if (l1_filename == NULL) break;
16976
16977 dictcnt++;
16978
16979 dictfiles[dictcnt - 1] = l1_filename;
16980 }
16981 }
16982 else
16983 {
16984 dictcnt++;
16985
16986 dictfiles[dictcnt - 1] = mask;
16987 }
16988
16989 if (dictcnt == 0)
16990 {
16991 log_error ("ERROR: Mask is too small");
16992
16993 return (-1);
16994 }
16995 }
16996 }
16997
16998 free (induction_dictionaries);
16999
17000 // induction_dictionaries_cnt = 0; // implied
17001
17002 if (attack_mode != ATTACK_MODE_BF)
17003 {
17004 if (keyspace == 0)
17005 {
17006 induction_dictionaries = scan_directory (induction_directory);
17007
17008 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17009 }
17010 }
17011
17012 if (induction_dictionaries_cnt)
17013 {
17014 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17015 }
17016
17017 /**
17018 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17019 */
17020 if (keyspace == 1)
17021 {
17022 if ((maskcnt > 1) || (dictcnt > 1))
17023 {
17024 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17025
17026 return (-1);
17027 }
17028 }
17029
17030 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17031 {
17032 char *subid = logfile_generate_subid ();
17033
17034 data.subid = subid;
17035
17036 logfile_sub_msg ("START");
17037
17038 data.devices_status = STATUS_INIT;
17039
17040 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17041 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17042 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17043
17044 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17045
17046 data.cpt_pos = 0;
17047
17048 data.cpt_start = time (NULL);
17049
17050 data.cpt_total = 0;
17051
17052 if (data.restore == 0)
17053 {
17054 rd->words_cur = skip;
17055
17056 skip = 0;
17057
17058 data.skip = 0;
17059 }
17060
17061 data.ms_paused = 0;
17062
17063 data.kernel_power_div = 0;
17064
17065 data.words_cur = rd->words_cur;
17066
17067 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17068 {
17069 hc_device_param_t *device_param = &data.devices_param[device_id];
17070
17071 if (device_param->skipped) continue;
17072
17073 device_param->speed_pos = 0;
17074
17075 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17076 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17077
17078 device_param->exec_pos = 0;
17079
17080 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17081
17082 device_param->outerloop_pos = 0;
17083 device_param->outerloop_left = 0;
17084 device_param->innerloop_pos = 0;
17085 device_param->innerloop_left = 0;
17086
17087 // some more resets:
17088
17089 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17090
17091 device_param->pws_cnt = 0;
17092
17093 device_param->words_off = 0;
17094 device_param->words_done = 0;
17095 }
17096
17097 // figure out some workload
17098
17099 if (attack_mode == ATTACK_MODE_STRAIGHT)
17100 {
17101 if (data.wordlist_mode == WL_MODE_FILE)
17102 {
17103 char *dictfile = NULL;
17104
17105 if (induction_dictionaries_cnt)
17106 {
17107 dictfile = induction_dictionaries[0];
17108 }
17109 else
17110 {
17111 dictfile = dictfiles[dictpos];
17112 }
17113
17114 data.dictfile = dictfile;
17115
17116 logfile_sub_string (dictfile);
17117
17118 for (uint i = 0; i < rp_files_cnt; i++)
17119 {
17120 logfile_sub_var_string ("rulefile", rp_files[i]);
17121 }
17122
17123 FILE *fd2 = fopen (dictfile, "rb");
17124
17125 if (fd2 == NULL)
17126 {
17127 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17128
17129 return (-1);
17130 }
17131
17132 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17133
17134 fclose (fd2);
17135
17136 if (data.words_cnt == 0)
17137 {
17138 if (data.devices_status == STATUS_CRACKED) break;
17139 if (data.devices_status == STATUS_ABORTED) break;
17140
17141 dictpos++;
17142
17143 continue;
17144 }
17145 }
17146 }
17147 else if (attack_mode == ATTACK_MODE_COMBI)
17148 {
17149 char *dictfile = data.dictfile;
17150 char *dictfile2 = data.dictfile2;
17151
17152 logfile_sub_string (dictfile);
17153 logfile_sub_string (dictfile2);
17154
17155 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17156 {
17157 FILE *fd2 = fopen (dictfile, "rb");
17158
17159 if (fd2 == NULL)
17160 {
17161 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17162
17163 return (-1);
17164 }
17165
17166 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17167
17168 fclose (fd2);
17169 }
17170 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17171 {
17172 FILE *fd2 = fopen (dictfile2, "rb");
17173
17174 if (fd2 == NULL)
17175 {
17176 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17177
17178 return (-1);
17179 }
17180
17181 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17182
17183 fclose (fd2);
17184 }
17185
17186 if (data.words_cnt == 0)
17187 {
17188 if (data.devices_status == STATUS_CRACKED) break;
17189 if (data.devices_status == STATUS_ABORTED) break;
17190
17191 dictpos++;
17192
17193 continue;
17194 }
17195 }
17196 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17197 {
17198 char *dictfile = NULL;
17199
17200 if (induction_dictionaries_cnt)
17201 {
17202 dictfile = induction_dictionaries[0];
17203 }
17204 else
17205 {
17206 dictfile = dictfiles[dictpos];
17207 }
17208
17209 data.dictfile = dictfile;
17210
17211 char *mask = data.mask;
17212
17213 logfile_sub_string (dictfile);
17214 logfile_sub_string (mask);
17215
17216 FILE *fd2 = fopen (dictfile, "rb");
17217
17218 if (fd2 == NULL)
17219 {
17220 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17221
17222 return (-1);
17223 }
17224
17225 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17226
17227 fclose (fd2);
17228
17229 if (data.words_cnt == 0)
17230 {
17231 if (data.devices_status == STATUS_CRACKED) break;
17232 if (data.devices_status == STATUS_ABORTED) break;
17233
17234 dictpos++;
17235
17236 continue;
17237 }
17238 }
17239 else if (attack_mode == ATTACK_MODE_BF)
17240 {
17241 local_free (css_buf);
17242 local_free (data.root_css_buf);
17243 local_free (data.markov_css_buf);
17244
17245 char *mask = dictfiles[dictpos];
17246
17247 logfile_sub_string (mask);
17248
17249 // base
17250
17251 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17252
17253 if (opts_type & OPTS_TYPE_PT_UNICODE)
17254 {
17255 uint css_cnt_unicode = css_cnt * 2;
17256
17257 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17258
17259 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17260 {
17261 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17262
17263 css_buf_unicode[j + 1].cs_buf[0] = 0;
17264 css_buf_unicode[j + 1].cs_len = 1;
17265 }
17266
17267 free (css_buf);
17268
17269 css_buf = css_buf_unicode;
17270 css_cnt = css_cnt_unicode;
17271 }
17272
17273 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17274
17275 uint mask_min = pw_min;
17276 uint mask_max = pw_max;
17277
17278 if (opts_type & OPTS_TYPE_PT_UNICODE)
17279 {
17280 mask_min *= 2;
17281 mask_max *= 2;
17282 }
17283
17284 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17285 {
17286 if (css_cnt < mask_min)
17287 {
17288 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17289 }
17290
17291 if (css_cnt > mask_max)
17292 {
17293 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17294 }
17295
17296 // skip to next mask
17297
17298 dictpos++;
17299
17300 rd->dictpos = dictpos;
17301
17302 logfile_sub_msg ("STOP");
17303
17304 continue;
17305 }
17306
17307 uint save_css_cnt = css_cnt;
17308
17309 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17310 {
17311 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17312 {
17313 uint salt_len = (uint) data.salts_buf[0].salt_len;
17314 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17315
17316 uint css_cnt_salt = css_cnt + salt_len;
17317
17318 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17319
17320 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17321
17322 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17323 {
17324 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17325 css_buf_salt[j].cs_len = 1;
17326 }
17327
17328 free (css_buf);
17329
17330 css_buf = css_buf_salt;
17331 css_cnt = css_cnt_salt;
17332 }
17333 }
17334
17335 data.mask = mask;
17336 data.css_cnt = css_cnt;
17337 data.css_buf = css_buf;
17338
17339 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17340
17341 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17342
17343 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17344
17345 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17346 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17347
17348 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17349
17350 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17351
17352 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17353 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17354
17355 data.root_css_buf = root_css_buf;
17356 data.markov_css_buf = markov_css_buf;
17357
17358 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17359
17360 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17361
17362 local_free (root_table_buf);
17363 local_free (markov_table_buf);
17364
17365 // copy + args
17366
17367 uint css_cnt_l = css_cnt;
17368 uint css_cnt_r;
17369
17370 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17371 {
17372 if (save_css_cnt < 6)
17373 {
17374 css_cnt_r = 1;
17375 }
17376 else if (save_css_cnt == 6)
17377 {
17378 css_cnt_r = 2;
17379 }
17380 else
17381 {
17382 if (opts_type & OPTS_TYPE_PT_UNICODE)
17383 {
17384 if (save_css_cnt == 8 || save_css_cnt == 10)
17385 {
17386 css_cnt_r = 2;
17387 }
17388 else
17389 {
17390 css_cnt_r = 4;
17391 }
17392 }
17393 else
17394 {
17395 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17396 {
17397 css_cnt_r = 3;
17398 }
17399 else
17400 {
17401 css_cnt_r = 4;
17402 }
17403 }
17404 }
17405 }
17406 else
17407 {
17408 css_cnt_r = 1;
17409
17410 /* unfinished code?
17411 int sum = css_buf[css_cnt_r - 1].cs_len;
17412
17413 for (uint i = 1; i < 4 && i < css_cnt; i++)
17414 {
17415 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17416
17417 css_cnt_r++;
17418
17419 sum *= css_buf[css_cnt_r - 1].cs_len;
17420 }
17421 */
17422 }
17423
17424 css_cnt_l -= css_cnt_r;
17425
17426 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17427
17428 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17429 {
17430 hc_device_param_t *device_param = &data.devices_param[device_id];
17431
17432 if (device_param->skipped) continue;
17433
17434 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17435 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17436 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17437
17438 device_param->kernel_params_mp_l_buf64[3] = 0;
17439 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17440 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17441 device_param->kernel_params_mp_l_buf32[6] = 0;
17442 device_param->kernel_params_mp_l_buf32[7] = 0;
17443 device_param->kernel_params_mp_l_buf32[8] = 0;
17444
17445 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17446 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17447 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17448 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17449
17450 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17451 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17452 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17453
17454 device_param->kernel_params_mp_r_buf64[3] = 0;
17455 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17456 device_param->kernel_params_mp_r_buf32[5] = 0;
17457 device_param->kernel_params_mp_r_buf32[6] = 0;
17458 device_param->kernel_params_mp_r_buf32[7] = 0;
17459
17460 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_l[i]);
17461 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_l[i]);
17462 for (uint i = 4; i < 9; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_l[i]);
17463
17464 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_r[i]);
17465 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_r[i]);
17466 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_r[i]);
17467
17468 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_root_css_buf, CL_TRUE, 0, device_param->size_root_css, root_css_buf, 0, NULL, NULL);
17469 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_markov_css_buf, CL_TRUE, 0, device_param->size_markov_css, markov_css_buf, 0, NULL, NULL);
17470 }
17471 }
17472
17473 u64 words_base = data.words_cnt;
17474
17475 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17476 {
17477 if (data.kernel_rules_cnt)
17478 {
17479 words_base /= data.kernel_rules_cnt;
17480 }
17481 }
17482 else if (data.attack_kern == ATTACK_KERN_COMBI)
17483 {
17484 if (data.combs_cnt)
17485 {
17486 words_base /= data.combs_cnt;
17487 }
17488 }
17489 else if (data.attack_kern == ATTACK_KERN_BF)
17490 {
17491 if (data.bfs_cnt)
17492 {
17493 words_base /= data.bfs_cnt;
17494 }
17495 }
17496
17497 data.words_base = words_base;
17498
17499 if (keyspace == 1)
17500 {
17501 log_info ("%llu", (unsigned long long int) words_base);
17502
17503 return (0);
17504 }
17505
17506 if (data.words_cur > data.words_base)
17507 {
17508 log_error ("ERROR: restore value greater keyspace");
17509
17510 return (-1);
17511 }
17512
17513 if (data.words_cur)
17514 {
17515 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17516 {
17517 for (uint i = 0; i < data.salts_cnt; i++)
17518 {
17519 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17520 }
17521 }
17522 else if (data.attack_kern == ATTACK_KERN_COMBI)
17523 {
17524 for (uint i = 0; i < data.salts_cnt; i++)
17525 {
17526 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17527 }
17528 }
17529 else if (data.attack_kern == ATTACK_KERN_BF)
17530 {
17531 for (uint i = 0; i < data.salts_cnt; i++)
17532 {
17533 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17534 }
17535 }
17536 }
17537
17538 /*
17539 * Update loopback file
17540 */
17541
17542 if (loopback == 1)
17543 {
17544 time_t now;
17545
17546 time (&now);
17547
17548 uint random_num = get_random_num (0, 9999);
17549
17550 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17551
17552 data.loopback_file = loopback_file;
17553 }
17554
17555 /*
17556 * Update dictionary statistic
17557 */
17558
17559 if (keyspace == 0)
17560 {
17561 dictstat_fp = fopen (dictstat, "wb");
17562
17563 if (dictstat_fp)
17564 {
17565 lock_file (dictstat_fp);
17566
17567 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17568
17569 fclose (dictstat_fp);
17570 }
17571 }
17572
17573 /**
17574 * create autotune threads
17575 */
17576
17577 data.devices_status = STATUS_AUTOTUNE;
17578
17579 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17580
17581 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17582 {
17583 hc_device_param_t *device_param = &devices_param[device_id];
17584
17585 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17586 }
17587
17588 hc_thread_wait (data.devices_cnt, c_threads);
17589
17590 /*
17591 * Inform user about possible slow speeds
17592 */
17593
17594 uint kernel_power_all = 0;
17595
17596 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17597 {
17598 hc_device_param_t *device_param = &devices_param[device_id];
17599
17600 kernel_power_all += device_param->kernel_power;
17601 }
17602
17603 data.kernel_power_all = kernel_power_all;
17604
17605 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17606 {
17607 if (data.words_base < kernel_power_all)
17608 {
17609 if (quiet == 0)
17610 {
17611 log_info ("ATTENTION!");
17612 log_info (" The wordlist or mask you are using is too small.");
17613 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17614 log_info (" The cracking speed will drop.");
17615 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17616 log_info ("");
17617 }
17618 }
17619 }
17620
17621 /**
17622 * create cracker threads
17623 */
17624
17625 data.devices_status = STATUS_RUNNING;
17626
17627 if (initial_restore_done == 0)
17628 {
17629 if (data.restore_disable == 0) cycle_restore ();
17630
17631 initial_restore_done = 1;
17632 }
17633
17634 hc_timer_set (&data.timer_running);
17635
17636 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17637 {
17638 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17639 {
17640 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17641 if (quiet == 0) fflush (stdout);
17642 }
17643 }
17644 else if (wordlist_mode == WL_MODE_STDIN)
17645 {
17646 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17647 if (data.quiet == 0) log_info ("");
17648 }
17649
17650 time_t runtime_start;
17651
17652 time (&runtime_start);
17653
17654 data.runtime_start = runtime_start;
17655
17656 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17657 {
17658 hc_device_param_t *device_param = &devices_param[device_id];
17659
17660 if (wordlist_mode == WL_MODE_STDIN)
17661 {
17662 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17663 }
17664 else
17665 {
17666 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17667 }
17668 }
17669
17670 hc_thread_wait (data.devices_cnt, c_threads);
17671
17672 local_free (c_threads);
17673
17674 data.restore = 0;
17675
17676 // finalize task
17677
17678 logfile_sub_var_uint ("status-after-work", data.devices_status);
17679
17680 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17681
17682 if (data.devices_status == STATUS_CRACKED) break;
17683 if (data.devices_status == STATUS_ABORTED) break;
17684
17685 if (data.devices_status == STATUS_BYPASS)
17686 {
17687 data.devices_status = STATUS_RUNNING;
17688 }
17689
17690 if (induction_dictionaries_cnt)
17691 {
17692 unlink (induction_dictionaries[0]);
17693 }
17694
17695 free (induction_dictionaries);
17696
17697 if (attack_mode != ATTACK_MODE_BF)
17698 {
17699 induction_dictionaries = scan_directory (induction_directory);
17700
17701 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17702 }
17703
17704 if (benchmark == 0)
17705 {
17706 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17707 {
17708 if (quiet == 0) clear_prompt ();
17709
17710 if (quiet == 0) log_info ("");
17711
17712 if (status == 1)
17713 {
17714 status_display ();
17715 }
17716 else
17717 {
17718 if (quiet == 0) status_display ();
17719 }
17720
17721 if (quiet == 0) log_info ("");
17722 }
17723 }
17724
17725 if (attack_mode == ATTACK_MODE_BF)
17726 {
17727 dictpos++;
17728
17729 rd->dictpos = dictpos;
17730 }
17731 else
17732 {
17733 if (induction_dictionaries_cnt)
17734 {
17735 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17736 }
17737 else
17738 {
17739 dictpos++;
17740
17741 rd->dictpos = dictpos;
17742 }
17743 }
17744
17745 time_t runtime_stop;
17746
17747 time (&runtime_stop);
17748
17749 data.runtime_stop = runtime_stop;
17750
17751 logfile_sub_uint (runtime_start);
17752 logfile_sub_uint (runtime_stop);
17753
17754 logfile_sub_msg ("STOP");
17755
17756 global_free (subid);
17757 }
17758
17759 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17760
17761 if (data.devices_status == STATUS_CRACKED) break;
17762 if (data.devices_status == STATUS_ABORTED) break;
17763 if (data.devices_status == STATUS_QUIT) break;
17764
17765 if (data.devices_status == STATUS_BYPASS)
17766 {
17767 data.devices_status = STATUS_RUNNING;
17768 }
17769 }
17770
17771 // 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
17772
17773 if (attack_mode == ATTACK_MODE_STRAIGHT)
17774 {
17775 if (data.wordlist_mode == WL_MODE_FILE)
17776 {
17777 if (data.dictfile == NULL)
17778 {
17779 if (dictfiles != NULL)
17780 {
17781 data.dictfile = dictfiles[0];
17782
17783 hc_timer_set (&data.timer_running);
17784 }
17785 }
17786 }
17787 }
17788 // NOTE: combi is okay because it is already set beforehand
17789 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17790 {
17791 if (data.dictfile == NULL)
17792 {
17793 if (dictfiles != NULL)
17794 {
17795 hc_timer_set (&data.timer_running);
17796
17797 data.dictfile = dictfiles[0];
17798 }
17799 }
17800 }
17801 else if (attack_mode == ATTACK_MODE_BF)
17802 {
17803 if (data.mask == NULL)
17804 {
17805 hc_timer_set (&data.timer_running);
17806
17807 data.mask = masks[0];
17808 }
17809 }
17810
17811 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17812 {
17813 data.devices_status = STATUS_EXHAUSTED;
17814 }
17815
17816 // if cracked / aborted remove last induction dictionary
17817
17818 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17819 {
17820 struct stat induct_stat;
17821
17822 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17823 {
17824 unlink (induction_dictionaries[file_pos]);
17825 }
17826 }
17827
17828 // wait for non-interactive threads
17829
17830 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17831 {
17832 hc_thread_wait (1, &ni_threads[thread_idx]);
17833 }
17834
17835 local_free (ni_threads);
17836
17837 // wait for interactive threads
17838
17839 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17840 {
17841 hc_thread_wait (1, &i_thread);
17842 }
17843
17844 // we dont need restore file anymore
17845 if (data.restore_disable == 0)
17846 {
17847 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17848 {
17849 unlink (eff_restore_file);
17850 unlink (new_restore_file);
17851 }
17852 else
17853 {
17854 cycle_restore ();
17855 }
17856 }
17857
17858 // finally save left hashes
17859
17860 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17861 {
17862 save_hash ();
17863 }
17864
17865 /**
17866 * Clean up
17867 */
17868
17869 if (benchmark == 1)
17870 {
17871 status_benchmark ();
17872
17873 if (machine_readable == 0)
17874 {
17875 log_info ("");
17876 }
17877 }
17878 else
17879 {
17880 if (quiet == 0) clear_prompt ();
17881
17882 if (quiet == 0) log_info ("");
17883
17884 if (status == 1)
17885 {
17886 status_display ();
17887 }
17888 else
17889 {
17890 if (quiet == 0) status_display ();
17891 }
17892
17893 if (quiet == 0) log_info ("");
17894 }
17895
17896 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17897 {
17898 hc_device_param_t *device_param = &data.devices_param[device_id];
17899
17900 if (device_param->skipped) continue;
17901
17902 local_free (device_param->combs_buf);
17903
17904 local_free (device_param->hooks_buf);
17905
17906 local_free (device_param->device_name);
17907
17908 local_free (device_param->device_name_chksum);
17909
17910 local_free (device_param->device_version);
17911
17912 local_free (device_param->driver_version);
17913
17914 if (device_param->pws_buf) myfree (device_param->pws_buf);
17915 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17916 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17917 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17918 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17919 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17920 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17921 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17922 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17923 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17924 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17925 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17926 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17927 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17928 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17929 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17930 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17931 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17932 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17933 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17934 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17935 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17936 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17937 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17938 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17939 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17940 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17941 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17942 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17943
17944 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17945 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17946 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17947 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17948 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17949 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17950 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17951 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17952 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17953 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17954 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17955
17956 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17957 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17958 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17959
17960 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17961 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17962 }
17963
17964 // reset default fan speed
17965
17966 #ifdef HAVE_HWMON
17967 if (gpu_temp_disable == 0)
17968 {
17969 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17970 {
17971 hc_thread_mutex_lock (mux_adl);
17972
17973 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17974 {
17975 hc_device_param_t *device_param = &data.devices_param[device_id];
17976
17977 if (device_param->skipped) continue;
17978
17979 if (data.hm_device[device_id].fan_set_supported == 1)
17980 {
17981 int fanspeed = temp_retain_fanspeed_value[device_id];
17982 int fanpolicy = temp_retain_fanpolicy_value[device_id];
17983
17984 if (fanpolicy == 1)
17985 {
17986 int rc = -1;
17987
17988 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17989 {
17990 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
17991 }
17992 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17993 {
17994
17995 }
17996
17997 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
17998 }
17999 }
18000 }
18001
18002 hc_thread_mutex_unlock (mux_adl);
18003 }
18004 }
18005
18006 // reset power tuning
18007
18008 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18009 {
18010 hc_thread_mutex_lock (mux_adl);
18011
18012 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18013 {
18014 hc_device_param_t *device_param = &data.devices_param[device_id];
18015
18016 if (device_param->skipped) continue;
18017
18018 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18019 {
18020 if (data.hm_device[device_id].od_version == 6)
18021 {
18022 // check powertune capabilities first, if not available then skip device
18023
18024 int powertune_supported = 0;
18025
18026 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18027 {
18028 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18029
18030 return (-1);
18031 }
18032
18033 if (powertune_supported != 0)
18034 {
18035 // powercontrol settings
18036
18037 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18038 {
18039 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18040
18041 return (-1);
18042 }
18043
18044 // clocks
18045
18046 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18047
18048 performance_state->iNumberOfPerformanceLevels = 2;
18049
18050 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18051 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18052 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18053 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18054
18055 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18056 {
18057 log_info ("ERROR: Failed to restore ADL performance state");
18058
18059 return (-1);
18060 }
18061
18062 local_free (performance_state);
18063 }
18064 }
18065 }
18066
18067 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18068 {
18069 unsigned int limit = nvml_power_limit[device_id];
18070
18071 if (limit > 0)
18072 {
18073 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18074 }
18075 }
18076 }
18077
18078 hc_thread_mutex_unlock (mux_adl);
18079 }
18080
18081 if (gpu_temp_disable == 0)
18082 {
18083 if (data.hm_nvml)
18084 {
18085 hm_NVML_nvmlShutdown (data.hm_nvml);
18086
18087 nvml_close (data.hm_nvml);
18088
18089 data.hm_nvml = NULL;
18090 }
18091
18092 if (data.hm_adl)
18093 {
18094 hm_ADL_Main_Control_Destroy (data.hm_adl);
18095
18096 adl_close (data.hm_adl);
18097
18098 data.hm_adl = NULL;
18099 }
18100 }
18101 #endif // HAVE_HWMON
18102
18103 // free memory
18104
18105 local_free (masks);
18106
18107 local_free (dictstat_base);
18108
18109 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18110 {
18111 pot_t *pot_ptr = &pot[pot_pos];
18112
18113 hash_t *hash = &pot_ptr->hash;
18114
18115 local_free (hash->digest);
18116
18117 if (isSalted)
18118 {
18119 local_free (hash->salt);
18120 }
18121 }
18122
18123 local_free (pot);
18124
18125 local_free (all_kernel_rules_cnt);
18126 local_free (all_kernel_rules_buf);
18127
18128 local_free (wl_data->buf);
18129 local_free (wl_data);
18130
18131 local_free (bitmap_s1_a);
18132 local_free (bitmap_s1_b);
18133 local_free (bitmap_s1_c);
18134 local_free (bitmap_s1_d);
18135 local_free (bitmap_s2_a);
18136 local_free (bitmap_s2_b);
18137 local_free (bitmap_s2_c);
18138 local_free (bitmap_s2_d);
18139
18140 #ifdef HAVE_HWMON
18141 local_free (temp_retain_fanspeed_value);
18142 local_free (od_clock_mem_status);
18143 local_free (od_power_control_status);
18144 local_free (nvml_power_limit);
18145 #endif
18146
18147 global_free (devices_param);
18148
18149 global_free (kernel_rules_buf);
18150
18151 global_free (root_css_buf);
18152 global_free (markov_css_buf);
18153
18154 global_free (digests_buf);
18155 global_free (digests_shown);
18156 global_free (digests_shown_tmp);
18157
18158 global_free (salts_buf);
18159 global_free (salts_shown);
18160
18161 global_free (esalts_buf);
18162
18163 global_free (words_progress_done);
18164 global_free (words_progress_rejected);
18165 global_free (words_progress_restored);
18166
18167 if (pot_fp) fclose (pot_fp);
18168
18169 if (data.devices_status == STATUS_QUIT) break;
18170 }
18171
18172 // destroy others mutex
18173
18174 hc_thread_mutex_delete (mux_dispatcher);
18175 hc_thread_mutex_delete (mux_counter);
18176 hc_thread_mutex_delete (mux_display);
18177 hc_thread_mutex_delete (mux_adl);
18178
18179 // free memory
18180
18181 local_free (eff_restore_file);
18182 local_free (new_restore_file);
18183
18184 local_free (rd);
18185
18186 // tuning db
18187
18188 tuning_db_destroy (tuning_db);
18189
18190 // loopback
18191
18192 local_free (loopback_file);
18193
18194 if (loopback == 1) unlink (loopback_file);
18195
18196 // induction directory
18197
18198 if (induction_dir == NULL)
18199 {
18200 if (attack_mode != ATTACK_MODE_BF)
18201 {
18202 if (rmdir (induction_directory) == -1)
18203 {
18204 if (errno == ENOENT)
18205 {
18206 // good, we can ignore
18207 }
18208 else if (errno == ENOTEMPTY)
18209 {
18210 // good, we can ignore
18211 }
18212 else
18213 {
18214 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18215
18216 return (-1);
18217 }
18218 }
18219
18220 local_free (induction_directory);
18221 }
18222 }
18223
18224 // outfile-check directory
18225
18226 if (outfile_check_dir == NULL)
18227 {
18228 if (rmdir (outfile_check_directory) == -1)
18229 {
18230 if (errno == ENOENT)
18231 {
18232 // good, we can ignore
18233 }
18234 else if (errno == ENOTEMPTY)
18235 {
18236 // good, we can ignore
18237 }
18238 else
18239 {
18240 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18241
18242 return (-1);
18243 }
18244 }
18245
18246 local_free (outfile_check_directory);
18247 }
18248
18249 time_t proc_stop;
18250
18251 time (&proc_stop);
18252
18253 logfile_top_uint (proc_start);
18254 logfile_top_uint (proc_stop);
18255
18256 logfile_top_msg ("STOP");
18257
18258 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18259 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18260
18261 if (data.ocl) ocl_close (data.ocl);
18262
18263 if (data.devices_status == STATUS_ABORTED) return 2;
18264 if (data.devices_status == STATUS_QUIT) return 2;
18265 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18266 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18267 if (data.devices_status == STATUS_CRACKED) return 0;
18268
18269 return -1;
18270 }
Hashcat additions to support pwdhash