projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Simple, but effective workaround to solve the 100% CPU burning loop bug in Nvidias...
[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 NVIDIA_100PERCENTCPU_WORKAROUND 100
154
155 #define global_free(attr) \
156 { \
157 myfree ((void *) data.attr); \
158 \
159 data.attr = NULL; \
160 }
161
162 #define local_free(attr) \
163 { \
164 myfree ((void *) attr); \
165 \
166 attr = NULL; \
167 }
168
169 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
170 #define HC_API_CALL __stdcall
171 #else
172 #define HC_API_CALL
173 #endif
174
175 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
176 {
177 900,
178 0,
179 5100,
180 100,
181 1400,
182 10800,
183 1700,
184 5000,
185 10100,
186 6000,
187 6100,
188 6900,
189 11700,
190 11800,
191 400,
192 8900,
193 11900,
194 12000,
195 10900,
196 12100,
197 23,
198 2500,
199 5300,
200 5400,
201 5500,
202 5600,
203 7300,
204 7500,
205 13100,
206 8300,
207 11100,
208 11200,
209 11400,
210 121,
211 2611,
212 2711,
213 2811,
214 8400,
215 11,
216 2612,
217 7900,
218 21,
219 11000,
220 124,
221 10000,
222 3711,
223 7600,
224 12,
225 131,
226 132,
227 1731,
228 200,
229 300,
230 3100,
231 112,
232 12300,
233 8000,
234 141,
235 1441,
236 1600,
237 12600,
238 1421,
239 101,
240 111,
241 1711,
242 3000,
243 1000,
244 1100,
245 2100,
246 12800,
247 1500,
248 12400,
249 500,
250 3200,
251 7400,
252 1800,
253 122,
254 1722,
255 7100,
256 6300,
257 6700,
258 6400,
259 6500,
260 2400,
261 2410,
262 5700,
263 9200,
264 9300,
265 22,
266 501,
267 5800,
268 8100,
269 8500,
270 7200,
271 9900,
272 7700,
273 7800,
274 10300,
275 8600,
276 8700,
277 9100,
278 133,
279 13500,
280 11600,
281 13600,
282 12500,
283 13000,
284 13200,
285 13300,
286 6211,
287 6221,
288 6231,
289 6241,
290 13711,
291 13721,
292 13731,
293 13741,
294 13751,
295 13761,
296 8800,
297 12900,
298 12200,
299 9700,
300 9710,
301 9800,
302 9810,
303 9400,
304 9500,
305 9600,
306 10400,
307 10410,
308 10500,
309 10600,
310 10700,
311 9000,
312 5200,
313 6800,
314 6600,
315 8200,
316 11300,
317 12700,
318 13400,
319 125
320 };
321
322 /**
323 * types
324 */
325
326 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
327
328 /**
329 * globals
330 */
331
332 static unsigned int full01 = 0x01010101;
333 static unsigned int full80 = 0x80808080;
334
335 int SUPPRESS_OUTPUT = 0;
336
337 hc_thread_mutex_t mux_adl;
338 hc_thread_mutex_t mux_counter;
339 hc_thread_mutex_t mux_dispatcher;
340 hc_thread_mutex_t mux_display;
341
342 hc_global_data_t data;
343
344 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
345
346 const char *USAGE_MINI[] =
347 {
348 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
349 "",
350 "Try --help for more help.",
351 NULL
352 };
353
354 const char *USAGE_BIG[] =
355 {
356 "%s, advanced password recovery",
357 "",
358 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
359 "",
360 "- [ Options ] -",
361 "",
362 " Options Short / Long | Type | Description | Example",
363 "===============================|======|======================================================|=======================",
364 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
365 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
366 " -V, --version | | Print version |",
367 " -h, --help | | Print help |",
368 " --quiet | | Suppress output |",
369 " --hex-charset | | Assume charset is given in hex |",
370 " --hex-salt | | Assume salt is given in hex |",
371 " --hex-wordlist | | Assume words in wordlist is given in hex |",
372 " --force | | Ignore warnings |",
373 " --status | | Enable automatic update of the status-screen |",
374 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
375 " --machine-readable | | Display the status view in a machine readable format |",
376 " --loopback | | Add new plains to induct directory |",
377 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
378 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
379 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
380 " --markov-classic | | Enables classic markov-chains, no per-position |",
381 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
382 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
383 " --session | Str | Define specific session name | --session=mysession",
384 " --restore | | Restore session from --session |",
385 " --restore-disable | | Do not write restore file |",
386 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
387 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
388 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
389 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
390 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
391 " --show | | Show cracked passwords only |",
392 " --left | | Show un-cracked passwords only |",
393 " --username | | Enable ignoring of usernames in hashfile |",
394 " --remove | | Enable remove of hash once it is cracked |",
395 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
396 " --potfile-disable | | Do not write potfile |",
397 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
398 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
399 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
400 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
401 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
402 " --logfile-disable | | Disable the logfile |",
403 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
404 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
405 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
406 " -b, --benchmark | | Run benchmark |",
407 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
408 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
409 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
410 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
411 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
412 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
413 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
414 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
415 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
416 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
417 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
418 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
419 #ifdef HAVE_HWMON
420 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
421 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
422 " --powertune-enable | | Enable power tuning, restores settings when finished |",
423 #endif
424 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
425 " -s, --skip | Num | Skip X words from the start | -s 1000000",
426 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
427 " --keyspace | | Show keyspace base:mod values and quit |",
428 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
429 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
430 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
431 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
432 " --generate-rules-func-min | Num | Force min X funcs per rule |",
433 " --generate-rules-func-max | Num | Force max X funcs per rule |",
434 " --generate-rules-seed | Num | Force RNG seed set to X |",
435 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
436 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
437 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
438 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
439 " -i, --increment | | Enable mask increment mode |",
440 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
441 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
442 "",
443 "- [ Hash modes ] -",
444 "",
445 " # | Name | Category",
446 " ======+==================================================+======================================",
447 " 900 | MD4 | Raw Hash",
448 " 0 | MD5 | Raw Hash",
449 " 5100 | Half MD5 | Raw Hash",
450 " 100 | SHA1 | Raw Hash",
451 " 10800 | SHA-384 | Raw Hash",
452 " 1400 | SHA-256 | Raw Hash",
453 " 1700 | SHA-512 | Raw Hash",
454 " 5000 | SHA-3(Keccak) | Raw Hash",
455 " 10100 | SipHash | Raw Hash",
456 " 6000 | RipeMD160 | Raw Hash",
457 " 6100 | Whirlpool | Raw Hash",
458 " 6900 | GOST R 34.11-94 | Raw Hash",
459 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
460 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
461 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
462 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
463 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
464 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
465 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
466 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
467 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
468 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
469 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
470 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
471 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
472 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
473 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
474 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
475 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
476 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
477 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
478 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
479 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
480 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
481 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
482 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
483 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
484 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
485 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
486 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
487 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
488 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
489 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
490 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
491 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
492 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
493 " 400 | phpass | Generic KDF",
494 " 8900 | scrypt | Generic KDF",
495 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
496 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
497 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
498 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
499 " 23 | Skype | Network protocols",
500 " 2500 | WPA/WPA2 | Network protocols",
501 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
502 " 5300 | IKE-PSK MD5 | Network protocols",
503 " 5400 | IKE-PSK SHA1 | Network protocols",
504 " 5500 | NetNTLMv1 | Network protocols",
505 " 5500 | NetNTLMv1 + ESS | Network protocols",
506 " 5600 | NetNTLMv2 | Network protocols",
507 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
508 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
509 " 8300 | DNSSEC (NSEC3) | Network protocols",
510 " 10200 | Cram MD5 | Network protocols",
511 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
512 " 11200 | MySQL CRAM (SHA1) | Network protocols",
513 " 11400 | SIP digest authentication (MD5) | Network protocols",
514 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
515 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
516 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
517 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
518 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
519 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
520 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
521 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
522 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
523 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
524 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
525 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
526 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
527 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
528 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
529 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
530 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
531 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
532 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
533 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
534 " 12 | PostgreSQL | Database Server",
535 " 131 | MSSQL(2000) | Database Server",
536 " 132 | MSSQL(2005) | Database Server",
537 " 1731 | MSSQL(2012) | Database Server",
538 " 1731 | MSSQL(2014) | Database Server",
539 " 200 | MySQL323 | Database Server",
540 " 300 | MySQL4.1/MySQL5 | Database Server",
541 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
542 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
543 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
544 " 8000 | Sybase ASE | Database Server",
545 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
546 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
547 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
548 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
549 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
550 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
551 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
552 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
553 " 11500 | CRC32 | Checksums",
554 " 3000 | LM | Operating-Systems",
555 " 1000 | NTLM | Operating-Systems",
556 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
557 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
558 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
559 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
560 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
561 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
562 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
563 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
564 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
565 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
566 " 1722 | OSX v10.7 | Operating-Systems",
567 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
568 " 6300 | AIX {smd5} | Operating-Systems",
569 " 6700 | AIX {ssha1} | Operating-Systems",
570 " 6400 | AIX {ssha256} | Operating-Systems",
571 " 6500 | AIX {ssha512} | Operating-Systems",
572 " 2400 | Cisco-PIX | Operating-Systems",
573 " 2410 | Cisco-ASA | Operating-Systems",
574 " 500 | Cisco-IOS $1$ | Operating-Systems",
575 " 5700 | Cisco-IOS $4$ | Operating-Systems",
576 " 9200 | Cisco-IOS $8$ | Operating-Systems",
577 " 9300 | Cisco-IOS $9$ | Operating-Systems",
578 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
579 " 501 | Juniper IVE | Operating-Systems",
580 " 5800 | Android PIN | Operating-Systems",
581 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
582 " 8100 | Citrix Netscaler | Operating-Systems",
583 " 8500 | RACF | Operating-Systems",
584 " 7200 | GRUB 2 | Operating-Systems",
585 " 9900 | Radmin2 | Operating-Systems",
586 " 125 | ArubaOS | Operating-Systems",
587 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
588 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
589 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
590 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
591 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
592 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
593 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
594 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
595 " 11600 | 7-Zip | Archives",
596 " 12500 | RAR3-hp | Archives",
597 " 13000 | RAR5 | Archives",
598 " 13200 | AxCrypt | Archives",
599 " 13300 | AxCrypt in memory SHA1 | Archives",
600 " 13600 | WinZip | Archives",
601 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
602 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
603 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
604 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
605 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
606 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
607 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
608 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
609 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
610 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
612 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
615 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
616 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
617 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
618 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
619 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
620 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
621 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
622 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
623 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
624 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
625 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
626 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
627 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
628 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
629 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
630 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
632 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
635 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
636 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
637 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
638 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
639 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
640 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
641 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
642 " 9400 | MS Office 2007 | Documents",
643 " 9500 | MS Office 2010 | Documents",
644 " 9600 | MS Office 2013 | Documents",
645 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
646 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
647 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
648 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
649 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
650 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
651 " 9000 | Password Safe v2 | Password Managers",
652 " 5200 | Password Safe v3 | Password Managers",
653 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
654 " 6600 | 1Password, agilekeychain | Password Managers",
655 " 8200 | 1Password, cloudkeychain | Password Managers",
656 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
657 " 12700 | Blockchain, My Wallet | Password Managers",
658 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
659 "",
660 "- [ Outfile Formats ] -",
661 "",
662 " # | Format",
663 " ===+========",
664 " 1 | hash[:salt]",
665 " 2 | plain",
666 " 3 | hash[:salt]:plain",
667 " 4 | hex_plain",
668 " 5 | hash[:salt]:hex_plain",
669 " 6 | plain:hex_plain",
670 " 7 | hash[:salt]:plain:hex_plain",
671 " 8 | crackpos",
672 " 9 | hash[:salt]:crack_pos",
673 " 10 | plain:crack_pos",
674 " 11 | hash[:salt]:plain:crack_pos",
675 " 12 | hex_plain:crack_pos",
676 " 13 | hash[:salt]:hex_plain:crack_pos",
677 " 14 | plain:hex_plain:crack_pos",
678 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
679 "",
680 "- [ Rule Debugging Modes ] -",
681 "",
682 " # | Format",
683 " ===+========",
684 " 1 | Finding-Rule",
685 " 2 | Original-Word",
686 " 3 | Original-Word:Finding-Rule",
687 " 4 | Original-Word:Finding-Rule:Processed-Word",
688 "",
689 "- [ Attack Modes ] -",
690 "",
691 " # | Mode",
692 " ===+======",
693 " 0 | Straight",
694 " 1 | Combination",
695 " 3 | Brute-force",
696 " 6 | Hybrid Wordlist + Mask",
697 " 7 | Hybrid Mask + Wordlist",
698 "",
699 "- [ Built-in Charsets ] -",
700 "",
701 " ? | Charset",
702 " ===+=========",
703 " l | abcdefghijklmnopqrstuvwxyz",
704 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
705 " d | 0123456789",
706 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
707 " a | ?l?u?d?s",
708 " b | 0x00 - 0xff",
709 "",
710 "- [ OpenCL Device Types ] -",
711 "",
712 " # | Device Type",
713 " ===+=============",
714 " 1 | CPU",
715 " 2 | GPU",
716 " 3 | FPGA, DSP, Co-Processor",
717 "",
718 "- [ Workload Profiles ] -",
719 "",
720 " # | Performance | Runtime | Power Consumption | Desktop Impact",
721 " ===+=============+=========+===================+=================",
722 " 1 | Low | 2 ms | Low | Minimal",
723 " 2 | Default | 12 ms | Economic | Noticeable",
724 " 3 | High | 96 ms | High | Unresponsive",
725 " 4 | Nightmare | 480 ms | Insane | Headless",
726 "",
727 "If you have no idea what just happened then visit the following pages:",
728 "",
729 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
730 "* https://hashcat.net/wiki/#frequently_asked_questions",
731 "",
732 NULL
733 };
734
735 /**
736 * hashcat specific functions
737 */
738
739 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
740 {
741 int exec_pos = (int) device_param->exec_pos - last_num_entries;
742
743 if (exec_pos < 0) exec_pos += EXEC_CACHE;
744
745 double exec_ms_sum = 0;
746
747 int exec_ms_cnt = 0;
748
749 for (int i = 0; i < last_num_entries; i++)
750 {
751 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
752
753 if (exec_ms)
754 {
755 exec_ms_sum += exec_ms;
756
757 exec_ms_cnt++;
758 }
759 }
760
761 if (exec_ms_cnt == 0) return 0;
762
763 return exec_ms_sum / exec_ms_cnt;
764 }
765
766 void status_display_machine_readable ()
767 {
768 FILE *out = stdout;
769
770 fprintf (out, "STATUS\t%u\t", data.devices_status);
771
772 /**
773 * speed new
774 */
775
776 fprintf (out, "SPEED\t");
777
778 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
779 {
780 hc_device_param_t *device_param = &data.devices_param[device_id];
781
782 if (device_param->skipped) continue;
783
784 u64 speed_cnt = 0;
785 double speed_ms = 0;
786
787 for (int i = 0; i < SPEED_CACHE; i++)
788 {
789 speed_cnt += device_param->speed_cnt[i];
790 speed_ms += device_param->speed_ms[i];
791 }
792
793 speed_cnt /= SPEED_CACHE;
794 speed_ms /= SPEED_CACHE;
795
796 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
797 }
798
799 /**
800 * exec time
801 */
802
803 fprintf (out, "EXEC_RUNTIME\t");
804
805 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
806 {
807 hc_device_param_t *device_param = &data.devices_param[device_id];
808
809 if (device_param->skipped) continue;
810
811 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
812
813 fprintf (out, "%f\t", exec_ms_avg);
814 }
815
816 /**
817 * words_cur
818 */
819
820 u64 words_cur = get_lowest_words_done ();
821
822 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
823
824 /**
825 * counter
826 */
827
828 u64 progress_total = data.words_cnt * data.salts_cnt;
829
830 u64 all_done = 0;
831 u64 all_rejected = 0;
832 u64 all_restored = 0;
833
834 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
835 {
836 all_done += data.words_progress_done[salt_pos];
837 all_rejected += data.words_progress_rejected[salt_pos];
838 all_restored += data.words_progress_restored[salt_pos];
839 }
840
841 u64 progress_cur = all_restored + all_done + all_rejected;
842 u64 progress_end = progress_total;
843
844 u64 progress_skip = 0;
845
846 if (data.skip)
847 {
848 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
849
850 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
851 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
852 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
853 }
854
855 if (data.limit)
856 {
857 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
858
859 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
860 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
861 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
862 }
863
864 u64 progress_cur_relative_skip = progress_cur - progress_skip;
865 u64 progress_end_relative_skip = progress_end - progress_skip;
866
867 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
868
869 /**
870 * cracks
871 */
872
873 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
874 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
875
876 /**
877 * temperature
878 */
879
880 #ifdef HAVE_HWMON
881 if (data.gpu_temp_disable == 0)
882 {
883 fprintf (out, "TEMP\t");
884
885 hc_thread_mutex_lock (mux_adl);
886
887 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
888 {
889 hc_device_param_t *device_param = &data.devices_param[device_id];
890
891 if (device_param->skipped) continue;
892
893 int temp = hm_get_temperature_with_device_id (device_id);
894
895 fprintf (out, "%d\t", temp);
896 }
897
898 hc_thread_mutex_unlock (mux_adl);
899 }
900 #endif // HAVE_HWMON
901
902 /**
903 * flush
904 */
905
906 #ifdef _WIN
907 fputc ('\r', out);
908 fputc ('\n', out);
909 #endif
910
911 #ifdef _POSIX
912 fputc ('\n', out);
913 #endif
914
915 fflush (out);
916 }
917
918 void status_display ()
919 {
920 if (data.devices_status == STATUS_INIT) return;
921 if (data.devices_status == STATUS_STARTING) return;
922 if (data.devices_status == STATUS_BYPASS) return;
923
924 if (data.machine_readable == 1)
925 {
926 status_display_machine_readable ();
927
928 return;
929 }
930
931 char tmp_buf[1000] = { 0 };
932
933 uint tmp_len = 0;
934
935 log_info ("Session.Name...: %s", data.session);
936
937 char *status_type = strstatus (data.devices_status);
938
939 uint hash_mode = data.hash_mode;
940
941 char *hash_type = strhashtype (hash_mode); // not a bug
942
943 log_info ("Status.........: %s", status_type);
944
945 /**
946 * show rules
947 */
948
949 if (data.rp_files_cnt)
950 {
951 uint i;
952
953 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
954 {
955 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
956 }
957
958 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
959
960 log_info ("Rules.Type.....: %s", tmp_buf);
961
962 tmp_len = 0;
963 }
964
965 if (data.rp_gen)
966 {
967 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
968
969 if (data.rp_gen_seed)
970 {
971 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
972 }
973 }
974
975 /**
976 * show input
977 */
978
979 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
980 {
981 if (data.wordlist_mode == WL_MODE_FILE)
982 {
983 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
984 }
985 else if (data.wordlist_mode == WL_MODE_STDIN)
986 {
987 log_info ("Input.Mode.....: Pipe");
988 }
989 }
990 else if (data.attack_mode == ATTACK_MODE_COMBI)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
993 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
994 }
995 else if (data.attack_mode == ATTACK_MODE_BF)
996 {
997 char *mask = data.mask;
998
999 if (mask != NULL)
1000 {
1001 uint mask_len = data.css_cnt;
1002
1003 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1004
1005 if (mask_len > 0)
1006 {
1007 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1008 {
1009 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1010 {
1011 mask_len -= data.salts_buf[0].salt_len;
1012 }
1013 }
1014
1015 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1016
1017 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1018 }
1019
1020 if (data.maskcnt > 1)
1021 {
1022 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1023
1024 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1025 }
1026
1027 log_info ("Input.Mode.....: %s", tmp_buf);
1028 }
1029
1030 tmp_len = 0;
1031 }
1032 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1033 {
1034 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1035 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1036 }
1037 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1038 {
1039 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1040 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1041 }
1042
1043 if (data.digests_cnt == 1)
1044 {
1045 if (data.hash_mode == 2500)
1046 {
1047 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1048
1049 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1050 (char *) data.salts_buf[0].salt_buf,
1051 wpa->orig_mac1[0],
1052 wpa->orig_mac1[1],
1053 wpa->orig_mac1[2],
1054 wpa->orig_mac1[3],
1055 wpa->orig_mac1[4],
1056 wpa->orig_mac1[5],
1057 wpa->orig_mac2[0],
1058 wpa->orig_mac2[1],
1059 wpa->orig_mac2[2],
1060 wpa->orig_mac2[3],
1061 wpa->orig_mac2[4],
1062 wpa->orig_mac2[5]);
1063 }
1064 else if (data.hash_mode == 5200)
1065 {
1066 log_info ("Hash.Target....: File (%s)", data.hashfile);
1067 }
1068 else if (data.hash_mode == 9000)
1069 {
1070 log_info ("Hash.Target....: File (%s)", data.hashfile);
1071 }
1072 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1073 {
1074 log_info ("Hash.Target....: File (%s)", data.hashfile);
1075 }
1076 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1077 {
1078 log_info ("Hash.Target....: File (%s)", data.hashfile);
1079 }
1080 else
1081 {
1082 char out_buf[HCBUFSIZ] = { 0 };
1083
1084 ascii_digest (out_buf, 0, 0);
1085
1086 // limit length
1087 if (strlen (out_buf) > 40)
1088 {
1089 out_buf[41] = '.';
1090 out_buf[42] = '.';
1091 out_buf[43] = '.';
1092 out_buf[44] = 0;
1093 }
1094
1095 log_info ("Hash.Target....: %s", out_buf);
1096 }
1097 }
1098 else
1099 {
1100 if (data.hash_mode == 3000)
1101 {
1102 char out_buf1[32] = { 0 };
1103 char out_buf2[32] = { 0 };
1104
1105 ascii_digest (out_buf1, 0, 0);
1106 ascii_digest (out_buf2, 0, 1);
1107
1108 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1109 }
1110 else
1111 {
1112 log_info ("Hash.Target....: File (%s)", data.hashfile);
1113 }
1114 }
1115
1116 log_info ("Hash.Type......: %s", hash_type);
1117
1118 /**
1119 * speed new
1120 */
1121
1122 u64 speed_cnt[DEVICES_MAX] = { 0 };
1123 double speed_ms[DEVICES_MAX] = { 0 };
1124
1125 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1126 {
1127 hc_device_param_t *device_param = &data.devices_param[device_id];
1128
1129 if (device_param->skipped) continue;
1130
1131 speed_cnt[device_id] = 0;
1132 speed_ms[device_id] = 0;
1133
1134 for (int i = 0; i < SPEED_CACHE; i++)
1135 {
1136 speed_cnt[device_id] += device_param->speed_cnt[i];
1137 speed_ms[device_id] += device_param->speed_ms[i];
1138 }
1139
1140 speed_cnt[device_id] /= SPEED_CACHE;
1141 speed_ms[device_id] /= SPEED_CACHE;
1142 }
1143
1144 double hashes_all_ms = 0;
1145
1146 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1147
1148 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1149 {
1150 hc_device_param_t *device_param = &data.devices_param[device_id];
1151
1152 if (device_param->skipped) continue;
1153
1154 hashes_dev_ms[device_id] = 0;
1155
1156 if (speed_ms[device_id])
1157 {
1158 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1159
1160 hashes_all_ms += hashes_dev_ms[device_id];
1161 }
1162 }
1163
1164 /**
1165 * exec time
1166 */
1167
1168 double exec_all_ms[DEVICES_MAX] = { 0 };
1169
1170 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1171 {
1172 hc_device_param_t *device_param = &data.devices_param[device_id];
1173
1174 if (device_param->skipped) continue;
1175
1176 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1177
1178 exec_all_ms[device_id] = exec_ms_avg;
1179 }
1180
1181 /**
1182 * timers
1183 */
1184
1185 double ms_running = 0;
1186
1187 hc_timer_get (data.timer_running, ms_running);
1188
1189 double ms_paused = data.ms_paused;
1190
1191 if (data.devices_status == STATUS_PAUSED)
1192 {
1193 double ms_paused_tmp = 0;
1194
1195 hc_timer_get (data.timer_paused, ms_paused_tmp);
1196
1197 ms_paused += ms_paused_tmp;
1198 }
1199
1200 #ifdef WIN
1201
1202 __time64_t sec_run = ms_running / 1000;
1203
1204 #else
1205
1206 time_t sec_run = ms_running / 1000;
1207
1208 #endif
1209
1210 if (sec_run)
1211 {
1212 char display_run[32] = { 0 };
1213
1214 struct tm tm_run;
1215
1216 struct tm *tmp = NULL;
1217
1218 #ifdef WIN
1219
1220 tmp = _gmtime64 (&sec_run);
1221
1222 #else
1223
1224 tmp = gmtime (&sec_run);
1225
1226 #endif
1227
1228 if (tmp != NULL)
1229 {
1230 memset (&tm_run, 0, sizeof (tm_run));
1231
1232 memcpy (&tm_run, tmp, sizeof (tm_run));
1233
1234 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1235
1236 char *start = ctime (&data.proc_start);
1237
1238 size_t start_len = strlen (start);
1239
1240 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1241 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1242
1243 log_info ("Time.Started...: %s (%s)", start, display_run);
1244 }
1245 }
1246 else
1247 {
1248 log_info ("Time.Started...: 0 secs");
1249 }
1250
1251 /**
1252 * counters
1253 */
1254
1255 u64 progress_total = data.words_cnt * data.salts_cnt;
1256
1257 u64 all_done = 0;
1258 u64 all_rejected = 0;
1259 u64 all_restored = 0;
1260
1261 u64 progress_noneed = 0;
1262
1263 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1264 {
1265 all_done += data.words_progress_done[salt_pos];
1266 all_rejected += data.words_progress_rejected[salt_pos];
1267 all_restored += data.words_progress_restored[salt_pos];
1268
1269 // Important for ETA only
1270
1271 if (data.salts_shown[salt_pos] == 1)
1272 {
1273 const u64 all = data.words_progress_done[salt_pos]
1274 + data.words_progress_rejected[salt_pos]
1275 + data.words_progress_restored[salt_pos];
1276
1277 const u64 left = data.words_cnt - all;
1278
1279 progress_noneed += left;
1280 }
1281 }
1282
1283 u64 progress_cur = all_restored + all_done + all_rejected;
1284 u64 progress_end = progress_total;
1285
1286 u64 progress_skip = 0;
1287
1288 if (data.skip)
1289 {
1290 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1291
1292 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1293 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1294 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1295 }
1296
1297 if (data.limit)
1298 {
1299 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1300
1301 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1302 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1303 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1304 }
1305
1306 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1307 u64 progress_end_relative_skip = progress_end - progress_skip;
1308
1309 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1310 {
1311 if (data.devices_status != STATUS_CRACKED)
1312 {
1313 #ifdef WIN
1314 __time64_t sec_etc = 0;
1315 #else
1316 time_t sec_etc = 0;
1317 #endif
1318
1319 if (hashes_all_ms)
1320 {
1321 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1322
1323 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1324
1325 sec_etc = ms_left / 1000;
1326 }
1327
1328 if (sec_etc == 0)
1329 {
1330 //log_info ("Time.Estimated.: 0 secs");
1331 }
1332 else if ((u64) sec_etc > ETC_MAX)
1333 {
1334 log_info ("Time.Estimated.: > 10 Years");
1335 }
1336 else
1337 {
1338 char display_etc[32] = { 0 };
1339
1340 struct tm tm_etc;
1341
1342 struct tm *tmp = NULL;
1343
1344 #ifdef WIN
1345
1346 tmp = _gmtime64 (&sec_etc);
1347
1348 #else
1349
1350 tmp = gmtime (&sec_etc);
1351
1352 #endif
1353
1354 if (tmp != NULL)
1355 {
1356 memset (&tm_etc, 0, sizeof (tm_etc));
1357
1358 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1359
1360 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1361
1362 time_t now;
1363
1364 time (&now);
1365
1366 now += sec_etc;
1367
1368 char *etc = ctime (&now);
1369
1370 size_t etc_len = strlen (etc);
1371
1372 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1373 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1374
1375 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1376 }
1377 }
1378 }
1379 }
1380
1381 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1382 {
1383 hc_device_param_t *device_param = &data.devices_param[device_id];
1384
1385 if (device_param->skipped) continue;
1386
1387 char display_dev_cur[16] = { 0 };
1388
1389 strncpy (display_dev_cur, "0.00", 4);
1390
1391 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1392
1393 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1394 }
1395
1396 char display_all_cur[16] = { 0 };
1397
1398 strncpy (display_all_cur, "0.00", 4);
1399
1400 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1401
1402 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1403
1404 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1405 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1406
1407 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);
1408
1409 // crack-per-time
1410
1411 if (data.digests_cnt > 100)
1412 {
1413 time_t now = time (NULL);
1414
1415 int cpt_cur_min = 0;
1416 int cpt_cur_hour = 0;
1417 int cpt_cur_day = 0;
1418
1419 for (int i = 0; i < CPT_BUF; i++)
1420 {
1421 const uint cracked = data.cpt_buf[i].cracked;
1422 const time_t timestamp = data.cpt_buf[i].timestamp;
1423
1424 if ((timestamp + 60) > now)
1425 {
1426 cpt_cur_min += cracked;
1427 }
1428
1429 if ((timestamp + 3600) > now)
1430 {
1431 cpt_cur_hour += cracked;
1432 }
1433
1434 if ((timestamp + 86400) > now)
1435 {
1436 cpt_cur_day += cracked;
1437 }
1438 }
1439
1440 double ms_real = ms_running - ms_paused;
1441
1442 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1443 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1444 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1445
1446 if ((data.cpt_start + 86400) < now)
1447 {
1448 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1449 cpt_cur_min,
1450 cpt_cur_hour,
1451 cpt_cur_day,
1452 cpt_avg_min,
1453 cpt_avg_hour,
1454 cpt_avg_day);
1455 }
1456 else if ((data.cpt_start + 3600) < now)
1457 {
1458 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1459 cpt_cur_min,
1460 cpt_cur_hour,
1461 cpt_avg_min,
1462 cpt_avg_hour,
1463 cpt_avg_day);
1464 }
1465 else if ((data.cpt_start + 60) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_avg_min,
1470 cpt_avg_hour,
1471 cpt_avg_day);
1472 }
1473 else
1474 {
1475 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1476 cpt_avg_min,
1477 cpt_avg_hour,
1478 cpt_avg_day);
1479 }
1480 }
1481
1482 // Restore point
1483
1484 u64 restore_point = get_lowest_words_done ();
1485
1486 u64 restore_total = data.words_base;
1487
1488 float percent_restore = 0;
1489
1490 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1491
1492 if (progress_end_relative_skip)
1493 {
1494 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1495 {
1496 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1497 float percent_rejected = 0.0;
1498
1499 if (progress_cur)
1500 {
1501 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1502 }
1503
1504 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);
1505 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1506
1507 if (data.restore_disable == 0)
1508 {
1509 if (percent_finished != 1)
1510 {
1511 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1512 }
1513 }
1514 }
1515 }
1516 else
1517 {
1518 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1519 {
1520 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1521 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1522
1523 if (data.restore_disable == 0)
1524 {
1525 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1526 }
1527 }
1528 else
1529 {
1530 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1531 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1532
1533 // --restore not allowed if stdin is used -- really? why?
1534
1535 //if (data.restore_disable == 0)
1536 //{
1537 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1538 //}
1539 }
1540 }
1541
1542 #ifdef HAVE_HWMON
1543
1544 if (data.devices_status == STATUS_EXHAUSTED) return;
1545 if (data.devices_status == STATUS_CRACKED) return;
1546 if (data.devices_status == STATUS_ABORTED) return;
1547 if (data.devices_status == STATUS_QUIT) return;
1548
1549 if (data.gpu_temp_disable == 0)
1550 {
1551 hc_thread_mutex_lock (mux_adl);
1552
1553 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1554 {
1555 hc_device_param_t *device_param = &data.devices_param[device_id];
1556
1557 if (device_param->skipped) continue;
1558
1559 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1560 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1561 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1562 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1563 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1564 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1565 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1566
1567 char output_buf[256] = { 0 };
1568
1569 int output_len = 0;
1570
1571 if (num_temperature >= 0)
1572 {
1573 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1574
1575 output_len = strlen (output_buf);
1576 }
1577
1578 if (num_fanspeed >= 0)
1579 {
1580 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1581
1582 output_len = strlen (output_buf);
1583 }
1584
1585 if (num_utilization >= 0)
1586 {
1587 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1588
1589 output_len = strlen (output_buf);
1590 }
1591
1592 if (num_corespeed >= 0)
1593 {
1594 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1595
1596 output_len = strlen (output_buf);
1597 }
1598
1599 if (num_memoryspeed >= 0)
1600 {
1601 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1602
1603 output_len = strlen (output_buf);
1604 }
1605
1606 if (num_buslanes >= 0)
1607 {
1608 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1609
1610 output_len = strlen (output_buf);
1611 }
1612
1613 if (num_throttle == 1)
1614 {
1615 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1616
1617 output_len = strlen (output_buf);
1618 }
1619
1620 if (output_len == 0)
1621 {
1622 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1623
1624 output_len = strlen (output_buf);
1625 }
1626
1627 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1628 }
1629
1630 hc_thread_mutex_unlock (mux_adl);
1631 }
1632
1633 #endif // HAVE_HWMON
1634 }
1635
1636 static void status_benchmark_automate ()
1637 {
1638 u64 speed_cnt[DEVICES_MAX] = { 0 };
1639 double speed_ms[DEVICES_MAX] = { 0 };
1640
1641 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1642 {
1643 hc_device_param_t *device_param = &data.devices_param[device_id];
1644
1645 if (device_param->skipped) continue;
1646
1647 speed_cnt[device_id] = device_param->speed_cnt[0];
1648 speed_ms[device_id] = device_param->speed_ms[0];
1649 }
1650
1651 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1652
1653 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1654 {
1655 hc_device_param_t *device_param = &data.devices_param[device_id];
1656
1657 if (device_param->skipped) continue;
1658
1659 hashes_dev_ms[device_id] = 0;
1660
1661 if (speed_ms[device_id])
1662 {
1663 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1664 }
1665 }
1666
1667 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1668 {
1669 hc_device_param_t *device_param = &data.devices_param[device_id];
1670
1671 if (device_param->skipped) continue;
1672
1673 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1674 }
1675 }
1676
1677 static void status_benchmark ()
1678 {
1679 if (data.devices_status == STATUS_INIT) return;
1680 if (data.devices_status == STATUS_STARTING) return;
1681 if (data.devices_status == STATUS_BYPASS) return;
1682
1683 if (data.machine_readable == 1)
1684 {
1685 status_benchmark_automate ();
1686
1687 return;
1688 }
1689
1690 u64 speed_cnt[DEVICES_MAX] = { 0 };
1691 double speed_ms[DEVICES_MAX] = { 0 };
1692
1693 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1694 {
1695 hc_device_param_t *device_param = &data.devices_param[device_id];
1696
1697 if (device_param->skipped) continue;
1698
1699 speed_cnt[device_id] = device_param->speed_cnt[0];
1700 speed_ms[device_id] = device_param->speed_ms[0];
1701 }
1702
1703 double hashes_all_ms = 0;
1704
1705 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1706
1707 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1708 {
1709 hc_device_param_t *device_param = &data.devices_param[device_id];
1710
1711 if (device_param->skipped) continue;
1712
1713 hashes_dev_ms[device_id] = 0;
1714
1715 if (speed_ms[device_id])
1716 {
1717 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1718
1719 hashes_all_ms += hashes_dev_ms[device_id];
1720 }
1721 }
1722
1723 /**
1724 * exec time
1725 */
1726
1727 double exec_all_ms[DEVICES_MAX] = { 0 };
1728
1729 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1730 {
1731 hc_device_param_t *device_param = &data.devices_param[device_id];
1732
1733 if (device_param->skipped) continue;
1734
1735 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1736
1737 exec_all_ms[device_id] = exec_ms_avg;
1738 }
1739
1740 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1741 {
1742 hc_device_param_t *device_param = &data.devices_param[device_id];
1743
1744 if (device_param->skipped) continue;
1745
1746 char display_dev_cur[16] = { 0 };
1747
1748 strncpy (display_dev_cur, "0.00", 4);
1749
1750 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1751
1752 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1753 }
1754
1755 char display_all_cur[16] = { 0 };
1756
1757 strncpy (display_all_cur, "0.00", 4);
1758
1759 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1760
1761 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1762 }
1763
1764 /**
1765 * hashcat -only- functions
1766 */
1767
1768 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1769 {
1770 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1771 {
1772 if (attack_kern == ATTACK_KERN_STRAIGHT)
1773 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1774 else if (attack_kern == ATTACK_KERN_COMBI)
1775 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1776 else if (attack_kern == ATTACK_KERN_BF)
1777 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1778 }
1779 else
1780 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1781 }
1782
1783 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)
1784 {
1785 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1786 {
1787 if (attack_kern == ATTACK_KERN_STRAIGHT)
1788 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1789 else if (attack_kern == ATTACK_KERN_COMBI)
1790 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1791 else if (attack_kern == ATTACK_KERN_BF)
1792 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1793 }
1794 else
1795 {
1796 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1797 }
1798 }
1799
1800 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1801 {
1802 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1803 {
1804 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1805 }
1806 else
1807 {
1808 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1809 }
1810 }
1811
1812 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)
1813 {
1814 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1815 {
1816 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1817 }
1818 else
1819 {
1820 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1821 }
1822 }
1823
1824 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1825 {
1826 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1827 }
1828
1829 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1830 {
1831 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1832 }
1833
1834 static uint convert_from_hex (char *line_buf, const uint line_len)
1835 {
1836 if (line_len & 1) return (line_len); // not in hex
1837
1838 if (data.hex_wordlist == 1)
1839 {
1840 uint i;
1841 uint j;
1842
1843 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1844 {
1845 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1846 }
1847
1848 memset (line_buf + i, 0, line_len - i);
1849
1850 return (i);
1851 }
1852 else if (line_len >= 6) // $HEX[] = 6
1853 {
1854 if (line_buf[0] != '$') return (line_len);
1855 if (line_buf[1] != 'H') return (line_len);
1856 if (line_buf[2] != 'E') return (line_len);
1857 if (line_buf[3] != 'X') return (line_len);
1858 if (line_buf[4] != '[') return (line_len);
1859 if (line_buf[line_len - 1] != ']') return (line_len);
1860
1861 uint i;
1862 uint j;
1863
1864 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1865 {
1866 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1867 }
1868
1869 memset (line_buf + i, 0, line_len - i);
1870
1871 return (i);
1872 }
1873
1874 return (line_len);
1875 }
1876
1877 static void clear_prompt ()
1878 {
1879 fputc ('\r', stdout);
1880
1881 for (size_t i = 0; i < strlen (PROMPT); i++)
1882 {
1883 fputc (' ', stdout);
1884 }
1885
1886 fputc ('\r', stdout);
1887
1888 fflush (stdout);
1889 }
1890
1891 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1892 {
1893 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);
1894 }
1895
1896 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1897 {
1898 char *outfile = data.outfile;
1899 uint quiet = data.quiet;
1900 FILE *pot_fp = data.pot_fp;
1901 uint loopback = data.loopback;
1902 uint debug_mode = data.debug_mode;
1903 char *debug_file = data.debug_file;
1904
1905 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1906 int debug_rule_len = 0; // -1 error
1907 uint debug_plain_len = 0;
1908
1909 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1910
1911 // hash
1912
1913 char out_buf[HCBUFSIZ] = { 0 };
1914
1915 const u32 salt_pos = plain->salt_pos;
1916 const u32 digest_pos = plain->digest_pos; // relative
1917 const u32 gidvid = plain->gidvid;
1918 const u32 il_pos = plain->il_pos;
1919
1920 ascii_digest (out_buf, salt_pos, digest_pos);
1921
1922 // plain
1923
1924 u64 crackpos = device_param->words_off;
1925
1926 uint plain_buf[16] = { 0 };
1927
1928 u8 *plain_ptr = (u8 *) plain_buf;
1929
1930 unsigned int plain_len = 0;
1931
1932 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1933 {
1934 pw_t pw;
1935
1936 gidd_to_pw_t (device_param, gidvid, &pw);
1937
1938 for (int i = 0; i < 16; i++)
1939 {
1940 plain_buf[i] = pw.i[i];
1941 }
1942
1943 plain_len = pw.pw_len;
1944
1945 const uint off = device_param->innerloop_pos + il_pos;
1946
1947 if (debug_mode > 0)
1948 {
1949 debug_rule_len = 0;
1950
1951 // save rule
1952 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1953 {
1954 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1955
1956 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1957 }
1958
1959 // save plain
1960 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1961 {
1962 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1963
1964 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1965
1966 debug_plain_len = plain_len;
1967 }
1968 }
1969
1970 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1971
1972 crackpos += gidvid;
1973 crackpos *= data.kernel_rules_cnt;
1974 crackpos += device_param->innerloop_pos + il_pos;
1975
1976 if (plain_len > data.pw_max) plain_len = data.pw_max;
1977 }
1978 else if (data.attack_mode == ATTACK_MODE_COMBI)
1979 {
1980 pw_t pw;
1981
1982 gidd_to_pw_t (device_param, gidvid, &pw);
1983
1984 for (int i = 0; i < 16; i++)
1985 {
1986 plain_buf[i] = pw.i[i];
1987 }
1988
1989 plain_len = pw.pw_len;
1990
1991 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1992 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1993
1994 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1995 {
1996 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1997 }
1998 else
1999 {
2000 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2001
2002 memcpy (plain_ptr, comb_buf, comb_len);
2003 }
2004
2005 plain_len += comb_len;
2006
2007 crackpos += gidvid;
2008 crackpos *= data.combs_cnt;
2009 crackpos += device_param->innerloop_pos + il_pos;
2010
2011 if (data.pw_max != PW_DICTMAX1)
2012 {
2013 if (plain_len > data.pw_max) plain_len = data.pw_max;
2014 }
2015 }
2016 else if (data.attack_mode == ATTACK_MODE_BF)
2017 {
2018 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2019 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2020
2021 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2022 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2023
2024 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2025 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2026
2027 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2028 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2029
2030 plain_len = data.css_cnt;
2031
2032 crackpos += gidvid;
2033 crackpos *= data.bfs_cnt;
2034 crackpos += device_param->innerloop_pos + il_pos;
2035 }
2036 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2037 {
2038 pw_t pw;
2039
2040 gidd_to_pw_t (device_param, gidvid, &pw);
2041
2042 for (int i = 0; i < 16; i++)
2043 {
2044 plain_buf[i] = pw.i[i];
2045 }
2046
2047 plain_len = pw.pw_len;
2048
2049 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2050
2051 uint start = 0;
2052 uint stop = device_param->kernel_params_mp_buf32[4];
2053
2054 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2055
2056 plain_len += start + stop;
2057
2058 crackpos += gidvid;
2059 crackpos *= data.combs_cnt;
2060 crackpos += device_param->innerloop_pos + il_pos;
2061
2062 if (data.pw_max != PW_DICTMAX1)
2063 {
2064 if (plain_len > data.pw_max) plain_len = data.pw_max;
2065 }
2066 }
2067 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2068 {
2069 pw_t pw;
2070
2071 gidd_to_pw_t (device_param, gidvid, &pw);
2072
2073 for (int i = 0; i < 16; i++)
2074 {
2075 plain_buf[i] = pw.i[i];
2076 }
2077
2078 plain_len = pw.pw_len;
2079
2080 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2081
2082 uint start = 0;
2083 uint stop = device_param->kernel_params_mp_buf32[4];
2084
2085 memmove (plain_ptr + stop, plain_ptr, plain_len);
2086
2087 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2088
2089 plain_len += start + stop;
2090
2091 crackpos += gidvid;
2092 crackpos *= data.combs_cnt;
2093 crackpos += device_param->innerloop_pos + il_pos;
2094
2095 if (data.pw_max != PW_DICTMAX1)
2096 {
2097 if (plain_len > data.pw_max) plain_len = data.pw_max;
2098 }
2099 }
2100
2101 if (data.attack_mode == ATTACK_MODE_BF)
2102 {
2103 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2104 {
2105 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2106 {
2107 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2108 {
2109 plain_len = plain_len - data.salts_buf[0].salt_len;
2110 }
2111 }
2112
2113 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2114 {
2115 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2116 {
2117 plain_ptr[j] = plain_ptr[i];
2118 }
2119
2120 plain_len = plain_len / 2;
2121 }
2122 }
2123 }
2124
2125 // if enabled, update also the potfile
2126
2127 if (pot_fp)
2128 {
2129 lock_file (pot_fp);
2130
2131 fprintf (pot_fp, "%s:", out_buf);
2132
2133 format_plain (pot_fp, plain_ptr, plain_len, 1);
2134
2135 fputc ('\n', pot_fp);
2136
2137 fflush (pot_fp);
2138
2139 unlock_file (pot_fp);
2140 }
2141
2142 // outfile
2143
2144 FILE *out_fp = NULL;
2145
2146 if (outfile != NULL)
2147 {
2148 if ((out_fp = fopen (outfile, "ab")) == NULL)
2149 {
2150 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2151
2152 out_fp = stdout;
2153 }
2154
2155 lock_file (out_fp);
2156 }
2157 else
2158 {
2159 out_fp = stdout;
2160
2161 if (quiet == 0) clear_prompt ();
2162 }
2163
2164 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2165
2166 if (outfile != NULL)
2167 {
2168 if (out_fp != stdout)
2169 {
2170 fclose (out_fp);
2171 }
2172 }
2173 else
2174 {
2175 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2176 {
2177 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2178 {
2179 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2180 if (quiet == 0) fflush (stdout);
2181 }
2182 }
2183 }
2184
2185 // loopback
2186
2187 if (loopback)
2188 {
2189 char *loopback_file = data.loopback_file;
2190
2191 FILE *fb_fp = NULL;
2192
2193 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2194 {
2195 lock_file (fb_fp);
2196
2197 format_plain (fb_fp, plain_ptr, plain_len, 1);
2198
2199 fputc ('\n', fb_fp);
2200
2201 fclose (fb_fp);
2202 }
2203 }
2204
2205 // (rule) debug mode
2206
2207 // the next check implies that:
2208 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2209 // - debug_mode > 0
2210
2211 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2212 {
2213 if (debug_rule_len < 0) debug_rule_len = 0;
2214
2215 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2216
2217 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2218
2219 if ((quiet == 0) && (debug_file == NULL))
2220 {
2221 fprintf (stdout, "%s", PROMPT);
2222
2223 fflush (stdout);
2224 }
2225 }
2226 }
2227
2228 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2229 {
2230 salt_t *salt_buf = &data.salts_buf[salt_pos];
2231
2232 u32 num_cracked;
2233
2234 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2235
2236 if (num_cracked)
2237 {
2238 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2239
2240 log_info_nn ("");
2241
2242 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2243
2244 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);
2245
2246 uint cpt_cracked = 0;
2247
2248 for (uint i = 0; i < num_cracked; i++)
2249 {
2250 const uint hash_pos = cracked[i].hash_pos;
2251
2252 if (data.digests_shown[hash_pos] == 1) continue;
2253
2254 hc_thread_mutex_lock (mux_display);
2255
2256 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2257 {
2258 data.digests_shown[hash_pos] = 1;
2259
2260 data.digests_done++;
2261
2262 cpt_cracked++;
2263
2264 salt_buf->digests_done++;
2265
2266 if (salt_buf->digests_done == salt_buf->digests_cnt)
2267 {
2268 data.salts_shown[salt_pos] = 1;
2269
2270 data.salts_done++;
2271 }
2272 }
2273
2274 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2275
2276 hc_thread_mutex_unlock (mux_display);
2277
2278 check_hash (device_param, &cracked[i]);
2279 }
2280
2281 myfree (cracked);
2282
2283 if (cpt_cracked > 0)
2284 {
2285 hc_thread_mutex_lock (mux_display);
2286
2287 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2288 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2289
2290 data.cpt_pos++;
2291
2292 data.cpt_total += cpt_cracked;
2293
2294 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2295
2296 hc_thread_mutex_unlock (mux_display);
2297 }
2298
2299 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2300 {
2301 // we need to reset cracked state on the device
2302 // otherwise host thinks again and again the hash was cracked
2303 // and returns invalid password each time
2304
2305 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2306
2307 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);
2308 }
2309
2310 num_cracked = 0;
2311
2312 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2313 }
2314 }
2315
2316 static void save_hash ()
2317 {
2318 char *hashfile = data.hashfile;
2319
2320 char new_hashfile[256] = { 0 };
2321 char old_hashfile[256] = { 0 };
2322
2323 snprintf (new_hashfile, 255, "%s.new", hashfile);
2324 snprintf (old_hashfile, 255, "%s.old", hashfile);
2325
2326 unlink (new_hashfile);
2327
2328 char separator = data.separator;
2329
2330 FILE *fp = fopen (new_hashfile, "wb");
2331
2332 if (fp == NULL)
2333 {
2334 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2335
2336 exit (-1);
2337 }
2338
2339 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2340 {
2341 if (data.salts_shown[salt_pos] == 1) continue;
2342
2343 salt_t *salt_buf = &data.salts_buf[salt_pos];
2344
2345 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2346 {
2347 uint idx = salt_buf->digests_offset + digest_pos;
2348
2349 if (data.digests_shown[idx] == 1) continue;
2350
2351 if (data.hash_mode != 2500)
2352 {
2353 char out_buf[HCBUFSIZ] = { 0 };
2354
2355 if (data.username == 1)
2356 {
2357 user_t *user = data.hash_info[idx]->user;
2358
2359 uint i;
2360
2361 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2362
2363 fputc (separator, fp);
2364 }
2365
2366 ascii_digest (out_buf, salt_pos, digest_pos);
2367
2368 fputs (out_buf, fp);
2369
2370 log_out (fp, "");
2371 }
2372 else
2373 {
2374 hccap_t hccap;
2375
2376 to_hccap_t (&hccap, salt_pos, digest_pos);
2377
2378 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2379 }
2380 }
2381 }
2382
2383 fflush (fp);
2384
2385 fclose (fp);
2386
2387 unlink (old_hashfile);
2388
2389 if (rename (hashfile, old_hashfile) != 0)
2390 {
2391 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2392
2393 exit (-1);
2394 }
2395
2396 unlink (hashfile);
2397
2398 if (rename (new_hashfile, hashfile) != 0)
2399 {
2400 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2401
2402 exit (-1);
2403 }
2404
2405 unlink (old_hashfile);
2406 }
2407
2408 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2409 {
2410 uint num_elements = num;
2411
2412 device_param->kernel_params_buf32[30] = data.combs_mode;
2413 device_param->kernel_params_buf32[31] = num;
2414
2415 uint kernel_threads = device_param->kernel_threads;
2416
2417 while (num_elements % kernel_threads) num_elements++;
2418
2419 cl_kernel kernel = NULL;
2420
2421 switch (kern_run)
2422 {
2423 case KERN_RUN_1: kernel = device_param->kernel1; break;
2424 case KERN_RUN_12: kernel = device_param->kernel12; break;
2425 case KERN_RUN_2: kernel = device_param->kernel2; break;
2426 case KERN_RUN_23: kernel = device_param->kernel23; break;
2427 case KERN_RUN_3: kernel = device_param->kernel3; break;
2428 }
2429
2430 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2431 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2432 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2433 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2434 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2435 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2436 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2437 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2438 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2439 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2440 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2441
2442 cl_event event;
2443
2444 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2445 {
2446 const size_t global_work_size[3] = { num_elements, 32, 1 };
2447 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2448
2449 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2450 }
2451 else
2452 {
2453 if (kern_run == KERN_RUN_2)
2454 {
2455 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2456 {
2457 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2458 }
2459 }
2460
2461 while (num_elements % kernel_threads) num_elements++;
2462
2463 const size_t global_work_size[3] = { num_elements, 1, 1 };
2464 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2465
2466 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2467 }
2468
2469 hc_clFlush (data.ocl, device_param->command_queue);
2470
2471 if (data.devices_status == STATUS_RUNNING)
2472 {
2473 usleep (device_param->exec_prev * 1000);
2474 }
2475
2476 hc_clWaitForEvents (data.ocl, 1, &event);
2477
2478 if (event_update)
2479 {
2480 cl_ulong time_start;
2481 cl_ulong time_end;
2482
2483 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2484 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2485
2486 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2487
2488 uint exec_pos = device_param->exec_pos;
2489
2490 device_param->exec_ms[exec_pos] = exec_time;
2491
2492 device_param->exec_prev = exec_time;
2493
2494 exec_pos++;
2495
2496 if (exec_pos == EXEC_CACHE)
2497 {
2498 exec_pos = 0;
2499 }
2500
2501 device_param->exec_pos = exec_pos;
2502 }
2503
2504 hc_clReleaseEvent (data.ocl, event);
2505
2506 hc_clFinish (data.ocl, device_param->command_queue);
2507 }
2508
2509 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2510 {
2511 uint num_elements = num;
2512
2513 switch (kern_run)
2514 {
2515 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2516 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2517 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2518 }
2519
2520 // causes problems with special threads like in bcrypt
2521 // const uint kernel_threads = device_param->kernel_threads;
2522
2523 uint kernel_threads = device_param->kernel_threads;
2524
2525 while (num_elements % kernel_threads) num_elements++;
2526
2527 cl_kernel kernel = NULL;
2528
2529 switch (kern_run)
2530 {
2531 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2532 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2533 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2534 }
2535
2536 switch (kern_run)
2537 {
2538 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2539 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2540 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2541 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2542 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2543 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2544 break;
2545 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2546 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2547 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2548 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2549 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2550 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2551 break;
2552 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2553 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2554 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2555 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2556 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2557 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2558 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2559 break;
2560 }
2561
2562 const size_t global_work_size[3] = { num_elements, 1, 1 };
2563 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2564
2565 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2566
2567 hc_clFlush (data.ocl, device_param->command_queue);
2568
2569 hc_clFinish (data.ocl, device_param->command_queue);
2570 }
2571
2572 static void run_kernel_tm (hc_device_param_t *device_param)
2573 {
2574 const uint num_elements = 1024; // fixed
2575
2576 uint kernel_threads = 32;
2577
2578 cl_kernel kernel = device_param->kernel_tm;
2579
2580 const size_t global_work_size[3] = { num_elements, 1, 1 };
2581 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2582
2583 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2584
2585 hc_clFlush (data.ocl, device_param->command_queue);
2586
2587 hc_clFinish (data.ocl, device_param->command_queue);
2588 }
2589
2590 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2591 {
2592 uint num_elements = num;
2593
2594 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2595 device_param->kernel_params_amp_buf32[6] = num_elements;
2596
2597 // causes problems with special threads like in bcrypt
2598 // const uint kernel_threads = device_param->kernel_threads;
2599
2600 uint kernel_threads = device_param->kernel_threads;
2601
2602 while (num_elements % kernel_threads) num_elements++;
2603
2604 cl_kernel kernel = device_param->kernel_amp;
2605
2606 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2607 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2608
2609 const size_t global_work_size[3] = { num_elements, 1, 1 };
2610 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2611
2612 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2613
2614 hc_clFlush (data.ocl, device_param->command_queue);
2615
2616 hc_clFinish (data.ocl, device_param->command_queue);
2617 }
2618
2619 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2620 {
2621 const u32 num16d = num / 16;
2622 const u32 num16m = num % 16;
2623
2624 if (num16d)
2625 {
2626 device_param->kernel_params_memset_buf32[1] = value;
2627 device_param->kernel_params_memset_buf32[2] = num16d;
2628
2629 uint kernel_threads = device_param->kernel_threads;
2630
2631 uint num_elements = num16d;
2632
2633 while (num_elements % kernel_threads) num_elements++;
2634
2635 cl_kernel kernel = device_param->kernel_memset;
2636
2637 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2638 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2639 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2640
2641 const size_t global_work_size[3] = { num_elements, 1, 1 };
2642 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2643
2644 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2645
2646 hc_clFlush (data.ocl, device_param->command_queue);
2647
2648 hc_clFinish (data.ocl, device_param->command_queue);
2649 }
2650
2651 if (num16m)
2652 {
2653 u32 tmp[4];
2654
2655 tmp[0] = value;
2656 tmp[1] = value;
2657 tmp[2] = value;
2658 tmp[3] = value;
2659
2660 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2661 }
2662 }
2663
2664 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2665 {
2666 run_kernel_memset (device_param, buf, 0, size);
2667
2668 /*
2669 int rc = -1;
2670
2671 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2672 {
2673 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2674
2675 const cl_uchar zero = 0;
2676
2677 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2678 }
2679
2680 if (rc != 0)
2681 {
2682 // NOTE: clEnqueueFillBuffer () always fails with -59
2683 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2684 // How's that possible, OpenCL 1.2 support is advertised??
2685 // We need to workaround...
2686
2687 #define FILLSZ 0x100000
2688
2689 char *tmp = (char *) mymalloc (FILLSZ);
2690
2691 for (size_t i = 0; i < size; i += FILLSZ)
2692 {
2693 const size_t left = size - i;
2694
2695 const size_t fillsz = MIN (FILLSZ, left);
2696
2697 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2698 }
2699
2700 myfree (tmp);
2701 }
2702 */
2703 }
2704
2705 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)
2706 {
2707 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2708 {
2709 if (attack_mode == ATTACK_MODE_BF)
2710 {
2711 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2712 {
2713 const uint size_tm = 32 * sizeof (bs_word_t);
2714
2715 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2716
2717 run_kernel_tm (device_param);
2718
2719 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);
2720 }
2721 }
2722
2723 if (highest_pw_len < 16)
2724 {
2725 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2726 }
2727 else if (highest_pw_len < 32)
2728 {
2729 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2730 }
2731 else
2732 {
2733 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2734 }
2735 }
2736 else
2737 {
2738 run_kernel_amp (device_param, pws_cnt);
2739
2740 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2741
2742 if (opts_type & OPTS_TYPE_HOOK12)
2743 {
2744 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2745 }
2746
2747 uint iter = salt_buf->salt_iter;
2748
2749 uint loop_step = device_param->kernel_loops;
2750
2751 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2752 {
2753 uint loop_left = iter - loop_pos;
2754
2755 loop_left = MIN (loop_left, loop_step);
2756
2757 device_param->kernel_params_buf32[25] = loop_pos;
2758 device_param->kernel_params_buf32[26] = loop_left;
2759
2760 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2761
2762 if (data.devices_status == STATUS_CRACKED) break;
2763 if (data.devices_status == STATUS_ABORTED) break;
2764 if (data.devices_status == STATUS_QUIT) break;
2765
2766 /**
2767 * speed
2768 */
2769
2770 const float iter_part = (float) (loop_pos + loop_left) / iter;
2771
2772 const u64 perf_sum_all = pws_cnt * iter_part;
2773
2774 double speed_ms;
2775
2776 hc_timer_get (device_param->timer_speed, speed_ms);
2777
2778 const u32 speed_pos = device_param->speed_pos;
2779
2780 device_param->speed_cnt[speed_pos] = perf_sum_all;
2781
2782 device_param->speed_ms[speed_pos] = speed_ms;
2783
2784 if (data.benchmark == 1)
2785 {
2786 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2787 }
2788 }
2789
2790 if (opts_type & OPTS_TYPE_HOOK23)
2791 {
2792 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2793
2794 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);
2795
2796 // do something with data
2797
2798 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);
2799 }
2800
2801 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2802 }
2803 }
2804
2805 static int run_rule_engine (const int rule_len, const char *rule_buf)
2806 {
2807 if (rule_len == 0)
2808 {
2809 return 0;
2810 }
2811 else if (rule_len == 1)
2812 {
2813 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2814 }
2815
2816 return 1;
2817 }
2818
2819 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2820 {
2821 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2822 {
2823 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);
2824 }
2825 else if (data.attack_kern == ATTACK_KERN_COMBI)
2826 {
2827 if (data.attack_mode == ATTACK_MODE_COMBI)
2828 {
2829 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2830 {
2831 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2832 {
2833 for (u32 i = 0; i < pws_cnt; i++)
2834 {
2835 const u32 pw_len = device_param->pws_buf[i].pw_len;
2836
2837 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2838
2839 ptr[pw_len] = 0x01;
2840 }
2841 }
2842 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2843 {
2844 for (u32 i = 0; i < pws_cnt; i++)
2845 {
2846 const u32 pw_len = device_param->pws_buf[i].pw_len;
2847
2848 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2849
2850 ptr[pw_len] = 0x80;
2851 }
2852 }
2853 }
2854 }
2855 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
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 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);
2882 }
2883 else if (data.attack_kern == ATTACK_KERN_BF)
2884 {
2885 const u64 off = device_param->words_off;
2886
2887 device_param->kernel_params_mp_l_buf64[3] = off;
2888
2889 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2890 }
2891 }
2892
2893 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2894 {
2895 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2896
2897 device_param->kernel_params_buf32[25] = 0;
2898 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2899 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2900
2901 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2902 {
2903 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true);
2904 }
2905 else
2906 {
2907 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true);
2908 }
2909
2910 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2911
2912 return exec_ms_prev;
2913 }
2914
2915 static void autotune (hc_device_param_t *device_param)
2916 {
2917 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2918
2919 const u32 kernel_accel_min = device_param->kernel_accel_min;
2920 const u32 kernel_accel_max = device_param->kernel_accel_max;
2921
2922 const u32 kernel_loops_min = device_param->kernel_loops_min;
2923 const u32 kernel_loops_max = device_param->kernel_loops_max;
2924
2925 u32 kernel_accel = kernel_accel_min;
2926 u32 kernel_loops = kernel_loops_min;
2927
2928 // in this case the user specified a fixed -u and -n on the commandline
2929 // no way to tune anything
2930 // but we need to run a few caching rounds
2931
2932 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2933 {
2934 try_run (device_param, kernel_accel, kernel_loops);
2935 try_run (device_param, kernel_accel, kernel_loops);
2936 try_run (device_param, kernel_accel, kernel_loops);
2937 try_run (device_param, kernel_accel, kernel_loops);
2938
2939 device_param->kernel_accel = kernel_accel;
2940 device_param->kernel_loops = kernel_loops;
2941
2942 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2943
2944 device_param->kernel_power = kernel_power;
2945
2946 return;
2947 }
2948
2949 // from here it's clear we are allowed to autotune
2950 // so let's init some fake words
2951
2952 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2953
2954 if (data.attack_kern == ATTACK_KERN_BF)
2955 {
2956 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2957 }
2958 else
2959 {
2960 for (u32 i = 0; i < kernel_power_max; i++)
2961 {
2962 device_param->pws_buf[i].i[0] = i;
2963 device_param->pws_buf[i].i[1] = 0x01234567;
2964 device_param->pws_buf[i].pw_len = 7 + (i & 7);
2965 }
2966
2967 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);
2968 }
2969
2970 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2971 {
2972 if (data.kernel_rules_cnt > 1)
2973 {
2974 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);
2975 }
2976 }
2977 else
2978 {
2979 run_kernel_amp (device_param, kernel_power_max);
2980 }
2981
2982 #define VERIFIER_CNT 1
2983
2984 // first find out highest kernel-loops that stays below target_ms
2985
2986 if (kernel_loops_min < kernel_loops_max)
2987 {
2988 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2989 {
2990 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2991
2992 for (int i = 0; i < VERIFIER_CNT; i++)
2993 {
2994 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2995
2996 exec_ms = MIN (exec_ms, exec_ms_v);
2997 }
2998
2999 if (exec_ms < target_ms) break;
3000 }
3001 }
3002
3003 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3004
3005 #define STEPS_CNT 10
3006
3007 if (kernel_accel_min < kernel_accel_max)
3008 {
3009 for (int i = 0; i < STEPS_CNT; i++)
3010 {
3011 const u32 kernel_accel_try = 1 << i;
3012
3013 if (kernel_accel_try < kernel_accel_min) continue;
3014 if (kernel_accel_try > kernel_accel_max) break;
3015
3016 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3017
3018 for (int i = 0; i < VERIFIER_CNT; i++)
3019 {
3020 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3021
3022 exec_ms = MIN (exec_ms, exec_ms_v);
3023 }
3024
3025 if (exec_ms > target_ms) break;
3026
3027 kernel_accel = kernel_accel_try;
3028 }
3029 }
3030
3031 // at this point we want to know the actual runtime for the following reason:
3032 // we need a reference for the balancing loop following up, and this
3033 // the balancing loop can have an effect that the creates a new opportunity, for example:
3034 // if the target is 95 ms and the current runtime is 48ms the above loop
3035 // stopped the execution because the previous exec_ms was > 95ms
3036 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3037 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3038
3039 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3040
3041 for (int i = 0; i < VERIFIER_CNT; i++)
3042 {
3043 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3044
3045 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3046 }
3047
3048 u32 diff = kernel_loops - kernel_accel;
3049
3050 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3051 {
3052 u32 kernel_accel_orig = kernel_accel;
3053 u32 kernel_loops_orig = kernel_loops;
3054
3055 for (u32 f = 1; f < 1024; f++)
3056 {
3057 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3058 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3059
3060 if (kernel_accel_try > kernel_accel_max) break;
3061 if (kernel_loops_try < kernel_loops_min) break;
3062
3063 u32 diff_new = kernel_loops_try - kernel_accel_try;
3064
3065 if (diff_new > diff) break;
3066
3067 diff_new = diff;
3068
3069 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3070
3071 for (int i = 0; i < VERIFIER_CNT; i++)
3072 {
3073 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3074
3075 exec_ms = MIN (exec_ms, exec_ms_v);
3076 }
3077
3078 if (exec_ms < exec_ms_pre_final)
3079 {
3080 exec_ms_pre_final = exec_ms;
3081
3082 kernel_accel = kernel_accel_try;
3083 kernel_loops = kernel_loops_try;
3084 }
3085 }
3086 }
3087
3088 const double exec_left = target_ms / exec_ms_pre_final;
3089
3090 const double accel_left = kernel_accel_max / kernel_accel;
3091
3092 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3093
3094 if (exec_accel_min >= 1.0)
3095 {
3096 // this is safe to not overflow kernel_accel_max because of accel_left
3097
3098 kernel_accel = (double) kernel_accel * exec_accel_min;
3099 }
3100
3101 // reset them fake words
3102
3103 /*
3104 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3105
3106 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);
3107 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);
3108 */
3109
3110 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3111
3112 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3113 {
3114 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3115 }
3116
3117 // reset timer
3118
3119 device_param->exec_pos = 0;
3120
3121 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3122
3123 // store
3124
3125 device_param->kernel_accel = kernel_accel;
3126 device_param->kernel_loops = kernel_loops;
3127
3128 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3129
3130 device_param->kernel_power = kernel_power;
3131
3132 #ifdef DEBUG
3133
3134 if (data.quiet == 0)
3135 {
3136 clear_prompt ();
3137
3138 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3139 "Device #%u: autotuned kernel-loops to %u\n",
3140 device_param->device_id + 1, kernel_accel,
3141 device_param->device_id + 1, kernel_loops);
3142
3143 fprintf (stdout, "%s", PROMPT);
3144
3145 fflush (stdout);
3146 }
3147
3148 #endif
3149 }
3150
3151 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3152 {
3153 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3154
3155 // init speed timer
3156
3157 uint speed_pos = device_param->speed_pos;
3158
3159 #ifdef _POSIX
3160 if (device_param->timer_speed.tv_sec == 0)
3161 {
3162 hc_timer_set (&device_param->timer_speed);
3163 }
3164 #endif
3165
3166 #ifdef _WIN
3167 if (device_param->timer_speed.QuadPart == 0)
3168 {
3169 hc_timer_set (&device_param->timer_speed);
3170 }
3171 #endif
3172
3173 // find higest password length, this is for optimization stuff
3174
3175 uint highest_pw_len = 0;
3176
3177 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3178 {
3179 }
3180 else if (data.attack_kern == ATTACK_KERN_COMBI)
3181 {
3182 }
3183 else if (data.attack_kern == ATTACK_KERN_BF)
3184 {
3185 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3186 + device_param->kernel_params_mp_l_buf32[5];
3187 }
3188
3189 // iteration type
3190
3191 uint innerloop_step = 0;
3192 uint innerloop_cnt = 0;
3193
3194 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3195 else innerloop_step = 1;
3196
3197 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3198 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3199 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3200
3201 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3202
3203 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3204 {
3205 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3206
3207 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3208
3209 if (data.devices_status == STATUS_CRACKED) break;
3210 if (data.devices_status == STATUS_ABORTED) break;
3211 if (data.devices_status == STATUS_QUIT) break;
3212 if (data.devices_status == STATUS_BYPASS) break;
3213
3214 salt_t *salt_buf = &data.salts_buf[salt_pos];
3215
3216 device_param->kernel_params_buf32[24] = salt_pos;
3217 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3218 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3219
3220 FILE *combs_fp = device_param->combs_fp;
3221
3222 if (data.attack_mode == ATTACK_MODE_COMBI)
3223 {
3224 rewind (combs_fp);
3225 }
3226
3227 // innerloops
3228
3229 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
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 uint innerloop_left = innerloop_cnt - innerloop_pos;
3241
3242 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3243
3244 device_param->innerloop_pos = innerloop_pos;
3245 device_param->innerloop_left = innerloop_left;
3246
3247 device_param->kernel_params_buf32[27] = innerloop_left;
3248
3249 // i think we can get rid of this
3250 if (innerloop_left == 0)
3251 {
3252 puts ("bug, how should this happen????\n");
3253
3254 continue;
3255 }
3256
3257 if (data.salts_shown[salt_pos] == 1)
3258 {
3259 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3260
3261 continue;
3262 }
3263
3264 // initialize amplifiers
3265
3266 if (data.attack_mode == ATTACK_MODE_COMBI)
3267 {
3268 uint i = 0;
3269
3270 while (i < innerloop_left)
3271 {
3272 if (feof (combs_fp)) break;
3273
3274 int line_len = fgetl (combs_fp, line_buf);
3275
3276 if (line_len >= PW_MAX1) continue;
3277
3278 line_len = convert_from_hex (line_buf, line_len);
3279
3280 char *line_buf_new = line_buf;
3281
3282 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3283 {
3284 char rule_buf_out[BLOCK_SIZE] = { 0 };
3285
3286 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3287
3288 if (rule_len_out < 0)
3289 {
3290 data.words_progress_rejected[salt_pos] += pws_cnt;
3291
3292 continue;
3293 }
3294
3295 line_len = rule_len_out;
3296
3297 line_buf_new = rule_buf_out;
3298 }
3299
3300 line_len = MIN (line_len, PW_DICTMAX);
3301
3302 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3303
3304 memcpy (ptr, line_buf_new, line_len);
3305
3306 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3307
3308 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3309 {
3310 uppercase (ptr, line_len);
3311 }
3312
3313 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3314 {
3315 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3316 {
3317 ptr[line_len] = 0x80;
3318 }
3319
3320 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3321 {
3322 ptr[line_len] = 0x01;
3323 }
3324 }
3325
3326 device_param->combs_buf[i].pw_len = line_len;
3327
3328 i++;
3329 }
3330
3331 for (uint j = i; j < innerloop_left; j++)
3332 {
3333 device_param->combs_buf[j].i[0] = 0;
3334 device_param->combs_buf[j].i[1] = 0;
3335 device_param->combs_buf[j].i[2] = 0;
3336 device_param->combs_buf[j].i[3] = 0;
3337 device_param->combs_buf[j].i[4] = 0;
3338 device_param->combs_buf[j].i[5] = 0;
3339 device_param->combs_buf[j].i[6] = 0;
3340 device_param->combs_buf[j].i[7] = 0;
3341
3342 device_param->combs_buf[j].pw_len = 0;
3343 }
3344
3345 innerloop_left = i;
3346 }
3347 else if (data.attack_mode == ATTACK_MODE_BF)
3348 {
3349 u64 off = innerloop_pos;
3350
3351 device_param->kernel_params_mp_r_buf64[3] = off;
3352
3353 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3354 }
3355 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3356 {
3357 u64 off = innerloop_pos;
3358
3359 device_param->kernel_params_mp_buf64[3] = off;
3360
3361 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3362 }
3363 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3364 {
3365 u64 off = innerloop_pos;
3366
3367 device_param->kernel_params_mp_buf64[3] = off;
3368
3369 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3370 }
3371
3372 // copy amplifiers
3373
3374 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3375 {
3376 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);
3377 }
3378 else if (data.attack_mode == ATTACK_MODE_COMBI)
3379 {
3380 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);
3381 }
3382 else if (data.attack_mode == ATTACK_MODE_BF)
3383 {
3384 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);
3385 }
3386 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3387 {
3388 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);
3389 }
3390 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3391 {
3392 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);
3393 }
3394
3395 if (data.benchmark == 1)
3396 {
3397 hc_timer_set (&device_param->timer_speed);
3398 }
3399
3400 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3401
3402 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3403
3404 if (data.devices_status == STATUS_CRACKED) break;
3405 if (data.devices_status == STATUS_ABORTED) break;
3406 if (data.devices_status == STATUS_QUIT) break;
3407
3408 /**
3409 * result
3410 */
3411
3412 if (data.benchmark == 0)
3413 {
3414 check_cracked (device_param, salt_pos);
3415 }
3416
3417 /**
3418 * progress
3419 */
3420
3421 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3422
3423 hc_thread_mutex_lock (mux_counter);
3424
3425 data.words_progress_done[salt_pos] += perf_sum_all;
3426
3427 hc_thread_mutex_unlock (mux_counter);
3428
3429 /**
3430 * speed
3431 */
3432
3433 double speed_ms;
3434
3435 hc_timer_get (device_param->timer_speed, speed_ms);
3436
3437 hc_timer_set (&device_param->timer_speed);
3438
3439 // current speed
3440
3441 //hc_thread_mutex_lock (mux_display);
3442
3443 device_param->speed_cnt[speed_pos] = perf_sum_all;
3444
3445 device_param->speed_ms[speed_pos] = speed_ms;
3446
3447 //hc_thread_mutex_unlock (mux_display);
3448
3449 speed_pos++;
3450
3451 if (speed_pos == SPEED_CACHE)
3452 {
3453 speed_pos = 0;
3454 }
3455
3456 /**
3457 * benchmark
3458 */
3459
3460 if (data.benchmark == 1) break;
3461 }
3462 }
3463
3464 device_param->speed_pos = speed_pos;
3465
3466 myfree (line_buf);
3467 }
3468
3469 static void load_segment (wl_data_t *wl_data, FILE *fd)
3470 {
3471 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3472
3473 wl_data->pos = 0;
3474
3475 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3476
3477 wl_data->buf[wl_data->cnt] = 0;
3478
3479 if (wl_data->cnt == 0) return;
3480
3481 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3482
3483 while (!feof (fd))
3484 {
3485 if (wl_data->cnt == wl_data->avail)
3486 {
3487 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3488
3489 wl_data->avail += wl_data->incr;
3490 }
3491
3492 const int c = fgetc (fd);
3493
3494 if (c == EOF) break;
3495
3496 wl_data->buf[wl_data->cnt] = (char) c;
3497
3498 wl_data->cnt++;
3499
3500 if (c == '\n') break;
3501 }
3502
3503 // ensure stream ends with a newline
3504
3505 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3506 {
3507 wl_data->cnt++;
3508
3509 wl_data->buf[wl_data->cnt - 1] = '\n';
3510 }
3511
3512 return;
3513 }
3514
3515 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3516 {
3517 char *ptr = buf;
3518
3519 for (u32 i = 0; i < sz; i++, ptr++)
3520 {
3521 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3522
3523 if (i == 7)
3524 {
3525 *off = i;
3526 *len = i;
3527
3528 return;
3529 }
3530
3531 if (*ptr != '\n') continue;
3532
3533 *off = i + 1;
3534
3535 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3536
3537 *len = i;
3538
3539 return;
3540 }
3541
3542 *off = sz;
3543 *len = sz;
3544 }
3545
3546 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3547 {
3548 char *ptr = buf;
3549
3550 for (u32 i = 0; i < sz; i++, ptr++)
3551 {
3552 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
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_std (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 != '\n') continue;
3576
3577 *off = i + 1;
3578
3579 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3580
3581 *len = i;
3582
3583 return;
3584 }
3585
3586 *off = sz;
3587 *len = sz;
3588 }
3589
3590 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3591 {
3592 while (wl_data->pos < wl_data->cnt)
3593 {
3594 uint off;
3595 uint len;
3596
3597 char *ptr = wl_data->buf + wl_data->pos;
3598
3599 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3600
3601 wl_data->pos += off;
3602
3603 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3604 {
3605 char rule_buf_out[BLOCK_SIZE] = { 0 };
3606
3607 int rule_len_out = -1;
3608
3609 if (len < BLOCK_SIZE)
3610 {
3611 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3612 }
3613
3614 if (rule_len_out < 0)
3615 {
3616 continue;
3617 }
3618
3619 if (rule_len_out > PW_MAX)
3620 {
3621 continue;
3622 }
3623 }
3624 else
3625 {
3626 if (len > PW_MAX)
3627 {
3628 continue;
3629 }
3630 }
3631
3632 *out_buf = ptr;
3633 *out_len = len;
3634
3635 return;
3636 }
3637
3638 if (feof (fd))
3639 {
3640 fprintf (stderr, "BUG feof()!!\n");
3641
3642 return;
3643 }
3644
3645 load_segment (wl_data, fd);
3646
3647 get_next_word (wl_data, fd, out_buf, out_len);
3648 }
3649
3650 #ifdef _POSIX
3651 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3652 #endif
3653
3654 #ifdef _WIN
3655 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3656 #endif
3657 {
3658 hc_signal (NULL);
3659
3660 dictstat_t d;
3661
3662 d.cnt = 0;
3663
3664 #ifdef _POSIX
3665 fstat (fileno (fd), &d.stat);
3666 #endif
3667
3668 #ifdef _WIN
3669 _fstat64 (fileno (fd), &d.stat);
3670 #endif
3671
3672 d.stat.st_mode = 0;
3673 d.stat.st_nlink = 0;
3674 d.stat.st_uid = 0;
3675 d.stat.st_gid = 0;
3676 d.stat.st_rdev = 0;
3677 d.stat.st_atime = 0;
3678
3679 #ifdef _POSIX
3680 d.stat.st_blksize = 0;
3681 d.stat.st_blocks = 0;
3682 #endif
3683
3684 if (d.stat.st_size == 0) return 0;
3685
3686 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3687
3688 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3689 {
3690 if (d_cache)
3691 {
3692 u64 cnt = d_cache->cnt;
3693
3694 u64 keyspace = cnt;
3695
3696 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3697 {
3698 keyspace *= data.kernel_rules_cnt;
3699 }
3700 else if (data.attack_kern == ATTACK_KERN_COMBI)
3701 {
3702 keyspace *= data.combs_cnt;
3703 }
3704
3705 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);
3706 if (data.quiet == 0) log_info ("");
3707
3708 hc_signal (sigHandler_default);
3709
3710 return (keyspace);
3711 }
3712 }
3713
3714 time_t now = 0;
3715 time_t prev = 0;
3716
3717 u64 comp = 0;
3718 u64 cnt = 0;
3719 u64 cnt2 = 0;
3720
3721 while (!feof (fd))
3722 {
3723 load_segment (wl_data, fd);
3724
3725 comp += wl_data->cnt;
3726
3727 u32 i = 0;
3728
3729 while (i < wl_data->cnt)
3730 {
3731 u32 len;
3732 u32 off;
3733
3734 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3735
3736 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3737 {
3738 char rule_buf_out[BLOCK_SIZE] = { 0 };
3739
3740 int rule_len_out = -1;
3741
3742 if (len < BLOCK_SIZE)
3743 {
3744 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3745 }
3746
3747 if (rule_len_out < 0)
3748 {
3749 len = PW_MAX1;
3750 }
3751 else
3752 {
3753 len = rule_len_out;
3754 }
3755 }
3756
3757 if (len < PW_MAX1)
3758 {
3759 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3760 {
3761 cnt += data.kernel_rules_cnt;
3762 }
3763 else if (data.attack_kern == ATTACK_KERN_COMBI)
3764 {
3765 cnt += data.combs_cnt;
3766 }
3767
3768 d.cnt++;
3769 }
3770
3771 i += off;
3772
3773 cnt2++;
3774 }
3775
3776 time (&now);
3777
3778 if ((now - prev) == 0) continue;
3779
3780 float percent = (float) comp / (float) d.stat.st_size;
3781
3782 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);
3783
3784 time (&prev);
3785 }
3786
3787 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);
3788 if (data.quiet == 0) log_info ("");
3789
3790 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3791
3792 hc_signal (sigHandler_default);
3793
3794 return (cnt);
3795 }
3796
3797 static void *thread_monitor (void *p)
3798 {
3799 uint runtime_check = 0;
3800 uint remove_check = 0;
3801 uint status_check = 0;
3802 uint restore_check = 0;
3803
3804 uint restore_left = data.restore_timer;
3805 uint remove_left = data.remove_timer;
3806 uint status_left = data.status_timer;
3807
3808 #ifdef HAVE_HWMON
3809 uint hwmon_check = 0;
3810
3811 int slowdown_warnings = 0;
3812
3813 // these variables are mainly used for fan control
3814
3815 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3816
3817 // temperature controller "loopback" values
3818
3819 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3820 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3821
3822 int temp_threshold = 1; // degrees celcius
3823
3824 int fan_speed_min = 15; // in percentage
3825 int fan_speed_max = 100;
3826
3827 time_t last_temp_check_time;
3828 #endif // HAVE_HWMON
3829
3830 uint sleep_time = 1;
3831
3832 if (data.runtime)
3833 {
3834 runtime_check = 1;
3835 }
3836
3837 if (data.restore_timer)
3838 {
3839 restore_check = 1;
3840 }
3841
3842 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3843 {
3844 remove_check = 1;
3845 }
3846
3847 if (data.status == 1)
3848 {
3849 status_check = 1;
3850 }
3851
3852 #ifdef HAVE_HWMON
3853 if (data.gpu_temp_disable == 0)
3854 {
3855 time (&last_temp_check_time);
3856
3857 hwmon_check = 1;
3858 }
3859 #endif
3860
3861 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3862 {
3863 #ifdef HAVE_HWMON
3864 if (hwmon_check == 0)
3865 #endif
3866 return (p);
3867 }
3868
3869 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3870 {
3871 hc_sleep (sleep_time);
3872
3873 if (data.devices_status != STATUS_RUNNING) continue;
3874
3875 #ifdef HAVE_HWMON
3876
3877 if (hwmon_check == 1)
3878 {
3879 hc_thread_mutex_lock (mux_adl);
3880
3881 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3882 {
3883 hc_device_param_t *device_param = &data.devices_param[device_id];
3884
3885 if (device_param->skipped) continue;
3886
3887 if (device_param->device_vendor_id == VENDOR_ID_NV)
3888 {
3889 if (data.hm_nvapi)
3890 {
3891 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
3892 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
3893
3894 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
3895 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
3896
3897 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
3898
3899 perfPolicies_status.info_value = perfPolicies_info.info_value;
3900
3901 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
3902
3903 if (perfPolicies_status.throttle & 2)
3904 {
3905 if (slowdown_warnings < 3)
3906 {
3907 if (data.quiet == 0) clear_prompt ();
3908
3909 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
3910
3911 if (slowdown_warnings == 2)
3912 {
3913 log_info ("");
3914 }
3915
3916 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3917 if (data.quiet == 0) fflush (stdout);
3918
3919 slowdown_warnings++;
3920 }
3921 }
3922 else
3923 {
3924 slowdown_warnings = 0;
3925 }
3926 }
3927 }
3928 }
3929
3930 hc_thread_mutex_unlock (mux_adl);
3931 }
3932
3933 if (hwmon_check == 1)
3934 {
3935 hc_thread_mutex_lock (mux_adl);
3936
3937 time_t temp_check_time;
3938
3939 time (&temp_check_time);
3940
3941 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3942
3943 if (Ta == 0) Ta = 1;
3944
3945 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3946 {
3947 hc_device_param_t *device_param = &data.devices_param[device_id];
3948
3949 if (device_param->skipped) continue;
3950
3951 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3952
3953 const int temperature = hm_get_temperature_with_device_id (device_id);
3954
3955 if (temperature > (int) data.gpu_temp_abort)
3956 {
3957 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3958
3959 if (data.devices_status != STATUS_QUIT) myabort ();
3960
3961 break;
3962 }
3963
3964 const int gpu_temp_retain = data.gpu_temp_retain;
3965
3966 if (gpu_temp_retain)
3967 {
3968 if (data.hm_device[device_id].fan_set_supported == 1)
3969 {
3970 int temp_cur = temperature;
3971
3972 int temp_diff_new = gpu_temp_retain - temp_cur;
3973
3974 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3975
3976 // calculate Ta value (time difference in seconds between the last check and this check)
3977
3978 last_temp_check_time = temp_check_time;
3979
3980 float Kp = 1.8;
3981 float Ki = 0.005;
3982 float Kd = 6;
3983
3984 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3985
3986 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);
3987
3988 if (abs (fan_diff_required) >= temp_threshold)
3989 {
3990 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3991
3992 int fan_speed_level = fan_speed_cur;
3993
3994 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3995
3996 int fan_speed_new = fan_speed_level - fan_diff_required;
3997
3998 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3999 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4000
4001 if (fan_speed_new != fan_speed_cur)
4002 {
4003 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4004 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4005
4006 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4007 {
4008 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4009 {
4010 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4011 }
4012 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4013 {
4014
4015 }
4016
4017 fan_speed_chgd[device_id] = 1;
4018 }
4019
4020 temp_diff_old[device_id] = temp_diff_new;
4021 }
4022 }
4023 }
4024 }
4025 }
4026
4027 hc_thread_mutex_unlock (mux_adl);
4028 }
4029 #endif // HAVE_HWMON
4030
4031 if (restore_check == 1)
4032 {
4033 restore_left--;
4034
4035 if (restore_left == 0)
4036 {
4037 if (data.restore_disable == 0) cycle_restore ();
4038
4039 restore_left = data.restore_timer;
4040 }
4041 }
4042
4043 if ((runtime_check == 1) && (data.runtime_start > 0))
4044 {
4045 time_t runtime_cur;
4046
4047 time (&runtime_cur);
4048
4049 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4050
4051 if (runtime_left <= 0)
4052 {
4053 if (data.benchmark == 0)
4054 {
4055 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4056 }
4057
4058 if (data.devices_status != STATUS_QUIT) myabort ();
4059 }
4060 }
4061
4062 if (remove_check == 1)
4063 {
4064 remove_left--;
4065
4066 if (remove_left == 0)
4067 {
4068 if (data.digests_saved != data.digests_done)
4069 {
4070 data.digests_saved = data.digests_done;
4071
4072 save_hash ();
4073 }
4074
4075 remove_left = data.remove_timer;
4076 }
4077 }
4078
4079 if (status_check == 1)
4080 {
4081 status_left--;
4082
4083 if (status_left == 0)
4084 {
4085 //hc_thread_mutex_lock (mux_display);
4086
4087 if (data.quiet == 0) clear_prompt ();
4088
4089 if (data.quiet == 0) log_info ("");
4090
4091 status_display ();
4092
4093 if (data.quiet == 0) log_info ("");
4094
4095 //hc_thread_mutex_unlock (mux_display);
4096
4097 status_left = data.status_timer;
4098 }
4099 }
4100 }
4101
4102 #ifdef HAVE_HWMON
4103 myfree (fan_speed_chgd);
4104
4105 myfree (temp_diff_old);
4106 myfree (temp_diff_sum);
4107 #endif
4108
4109 p = NULL;
4110
4111 return (p);
4112 }
4113
4114 static void *thread_outfile_remove (void *p)
4115 {
4116 // some hash-dependent constants
4117 char *outfile_dir = data.outfile_check_directory;
4118 uint dgst_size = data.dgst_size;
4119 uint isSalted = data.isSalted;
4120 uint esalt_size = data.esalt_size;
4121 uint hash_mode = data.hash_mode;
4122
4123 uint outfile_check_timer = data.outfile_check_timer;
4124
4125 char separator = data.separator;
4126
4127 // some hash-dependent functions
4128 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4129 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4130
4131 // buffers
4132 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4133
4134 hash_buf.digest = mymalloc (dgst_size);
4135
4136 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4137
4138 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4139
4140 uint digest_buf[64] = { 0 };
4141
4142 outfile_data_t *out_info = NULL;
4143
4144 char **out_files = NULL;
4145
4146 time_t folder_mtime = 0;
4147
4148 int out_cnt = 0;
4149
4150 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4151
4152 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4153 {
4154 hc_sleep (1);
4155
4156 if (data.devices_status != STATUS_RUNNING) continue;
4157
4158 check_left--;
4159
4160 if (check_left == 0)
4161 {
4162 struct stat outfile_check_stat;
4163
4164 if (stat (outfile_dir, &outfile_check_stat) == 0)
4165 {
4166 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4167
4168 if (is_dir == 1)
4169 {
4170 if (outfile_check_stat.st_mtime > folder_mtime)
4171 {
4172 char **out_files_new = scan_directory (outfile_dir);
4173
4174 int out_cnt_new = count_dictionaries (out_files_new);
4175
4176 outfile_data_t *out_info_new = NULL;
4177
4178 if (out_cnt_new > 0)
4179 {
4180 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4181
4182 for (int i = 0; i < out_cnt_new; i++)
4183 {
4184 out_info_new[i].file_name = out_files_new[i];
4185
4186 // check if there are files that we have seen/checked before (and not changed)
4187
4188 for (int j = 0; j < out_cnt; j++)
4189 {
4190 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4191 {
4192 struct stat outfile_stat;
4193
4194 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4195 {
4196 if (outfile_stat.st_ctime == out_info[j].ctime)
4197 {
4198 out_info_new[i].ctime = out_info[j].ctime;
4199 out_info_new[i].seek = out_info[j].seek;
4200 }
4201 }
4202 }
4203 }
4204 }
4205 }
4206
4207 local_free (out_info);
4208 local_free (out_files);
4209
4210 out_files = out_files_new;
4211 out_cnt = out_cnt_new;
4212 out_info = out_info_new;
4213
4214 folder_mtime = outfile_check_stat.st_mtime;
4215 }
4216
4217 for (int j = 0; j < out_cnt; j++)
4218 {
4219 FILE *fp = fopen (out_info[j].file_name, "rb");
4220
4221 if (fp != NULL)
4222 {
4223 //hc_thread_mutex_lock (mux_display);
4224
4225 #ifdef _POSIX
4226 struct stat outfile_stat;
4227
4228 fstat (fileno (fp), &outfile_stat);
4229 #endif
4230
4231 #ifdef _WIN
4232 struct stat64 outfile_stat;
4233
4234 _fstat64 (fileno (fp), &outfile_stat);
4235 #endif
4236
4237 if (outfile_stat.st_ctime > out_info[j].ctime)
4238 {
4239 out_info[j].ctime = outfile_stat.st_ctime;
4240 out_info[j].seek = 0;
4241 }
4242
4243 fseek (fp, out_info[j].seek, SEEK_SET);
4244
4245 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4246
4247 while (!feof (fp))
4248 {
4249 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4250
4251 if (ptr == NULL) break;
4252
4253 int line_len = strlen (line_buf);
4254
4255 if (line_len <= 0) continue;
4256
4257 int iter = MAX_CUT_TRIES;
4258
4259 for (uint i = line_len - 1; i && iter; i--, line_len--)
4260 {
4261 if (line_buf[i] != separator) continue;
4262
4263 int parser_status = PARSER_OK;
4264
4265 if ((hash_mode != 2500) && (hash_mode != 6800))
4266 {
4267 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4268 }
4269
4270 uint found = 0;
4271
4272 if (parser_status == PARSER_OK)
4273 {
4274 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4275 {
4276 if (data.salts_shown[salt_pos] == 1) continue;
4277
4278 salt_t *salt_buf = &data.salts_buf[salt_pos];
4279
4280 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4281 {
4282 uint idx = salt_buf->digests_offset + digest_pos;
4283
4284 if (data.digests_shown[idx] == 1) continue;
4285
4286 uint cracked = 0;
4287
4288 if (hash_mode == 6800)
4289 {
4290 if (i == salt_buf->salt_len)
4291 {
4292 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4293 }
4294 }
4295 else if (hash_mode == 2500)
4296 {
4297 // BSSID : MAC1 : MAC2 (:plain)
4298 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4299 {
4300 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4301
4302 if (!cracked) continue;
4303
4304 // now compare MAC1 and MAC2 too, since we have this additional info
4305 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4306 char *mac2_pos = mac1_pos + 12 + 1;
4307
4308 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4309 wpa_t *wpa = &wpas[salt_pos];
4310
4311 // compare hex string(s) vs binary MAC address(es)
4312
4313 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4314 {
4315 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4316 {
4317 cracked = 0;
4318
4319 break;
4320 }
4321 }
4322
4323 // early skip ;)
4324 if (!cracked) continue;
4325
4326 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4327 {
4328 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4329 {
4330 cracked = 0;
4331
4332 break;
4333 }
4334 }
4335 }
4336 }
4337 else
4338 {
4339 char *digests_buf_ptr = (char *) data.digests_buf;
4340
4341 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4342
4343 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4344 }
4345
4346 if (cracked == 1)
4347 {
4348 found = 1;
4349
4350 data.digests_shown[idx] = 1;
4351
4352 data.digests_done++;
4353
4354 salt_buf->digests_done++;
4355
4356 if (salt_buf->digests_done == salt_buf->digests_cnt)
4357 {
4358 data.salts_shown[salt_pos] = 1;
4359
4360 data.salts_done++;
4361
4362 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4363 }
4364 }
4365 }
4366
4367 if (data.devices_status == STATUS_CRACKED) break;
4368 }
4369 }
4370
4371 if (found) break;
4372
4373 if (data.devices_status == STATUS_CRACKED) break;
4374
4375 iter--;
4376 }
4377
4378 if (data.devices_status == STATUS_CRACKED) break;
4379 }
4380
4381 myfree (line_buf);
4382
4383 out_info[j].seek = ftell (fp);
4384
4385 //hc_thread_mutex_unlock (mux_display);
4386
4387 fclose (fp);
4388 }
4389 }
4390 }
4391 }
4392
4393 check_left = outfile_check_timer;
4394 }
4395 }
4396
4397 if (esalt_size) local_free (hash_buf.esalt);
4398
4399 if (isSalted) local_free (hash_buf.salt);
4400
4401 local_free (hash_buf.digest);
4402
4403 local_free (out_info);
4404
4405 local_free (out_files);
4406
4407 p = NULL;
4408
4409 return (p);
4410 }
4411
4412 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4413 {
4414 //if (device_param->pws_cnt < device_param->kernel_power)
4415 //{
4416 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4417
4418 u8 *ptr = (u8 *) pw->i;
4419
4420 memcpy (ptr, pw_buf, pw_len);
4421
4422 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4423
4424 pw->pw_len = pw_len;
4425
4426 device_param->pws_cnt++;
4427 //}
4428 //else
4429 //{
4430 // fprintf (stderr, "BUG pw_add()!!\n");
4431 //
4432 // return;
4433 //}
4434 }
4435
4436 static void set_kernel_power_final (const u64 kernel_power_final)
4437 {
4438 if (data.quiet == 0)
4439 {
4440 clear_prompt ();
4441
4442 //log_info ("");
4443
4444 log_info ("INFO: approaching final keyspace, workload adjusted");
4445 log_info ("");
4446
4447 fprintf (stdout, "%s", PROMPT);
4448
4449 fflush (stdout);
4450 }
4451
4452 data.kernel_power_final = kernel_power_final;
4453 }
4454
4455 static u32 get_power (hc_device_param_t *device_param)
4456 {
4457 const u64 kernel_power_final = data.kernel_power_final;
4458
4459 if (kernel_power_final)
4460 {
4461 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4462
4463 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4464
4465 // work should be at least the hardware power available without any accelerator
4466
4467 const u64 work = MAX (words_left_device, device_param->hardware_power);
4468
4469 return work;
4470 }
4471
4472 return device_param->kernel_power;
4473 }
4474
4475 static uint get_work (hc_device_param_t *device_param, const u64 max)
4476 {
4477 hc_thread_mutex_lock (mux_dispatcher);
4478
4479 const u64 words_cur = data.words_cur;
4480 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4481
4482 device_param->words_off = words_cur;
4483
4484 const u64 kernel_power_all = data.kernel_power_all;
4485
4486 const u64 words_left = words_base - words_cur;
4487
4488 if (words_left < kernel_power_all)
4489 {
4490 if (data.kernel_power_final == 0)
4491 {
4492 set_kernel_power_final (words_left);
4493 }
4494 }
4495
4496 const u32 kernel_power = get_power (device_param);
4497
4498 uint work = MIN (words_left, kernel_power);
4499
4500 work = MIN (work, max);
4501
4502 data.words_cur += work;
4503
4504 hc_thread_mutex_unlock (mux_dispatcher);
4505
4506 return work;
4507 }
4508
4509 static void *thread_autotune (void *p)
4510 {
4511 hc_device_param_t *device_param = (hc_device_param_t *) p;
4512
4513 if (device_param->skipped) return NULL;
4514
4515 autotune (device_param);
4516
4517 return NULL;
4518 }
4519
4520 static void *thread_calc_stdin (void *p)
4521 {
4522 hc_device_param_t *device_param = (hc_device_param_t *) p;
4523
4524 if (device_param->skipped) return NULL;
4525
4526 char *buf = (char *) mymalloc (HCBUFSIZ);
4527
4528 const uint attack_kern = data.attack_kern;
4529
4530 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4531 {
4532 hc_thread_mutex_lock (mux_dispatcher);
4533
4534 if (feof (stdin) != 0)
4535 {
4536 hc_thread_mutex_unlock (mux_dispatcher);
4537
4538 break;
4539 }
4540
4541 uint words_cur = 0;
4542
4543 while (words_cur < device_param->kernel_power)
4544 {
4545 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4546
4547 if (line_buf == NULL) break;
4548
4549 uint line_len = in_superchop (line_buf);
4550
4551 line_len = convert_from_hex (line_buf, line_len);
4552
4553 // post-process rule engine
4554
4555 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4556 {
4557 char rule_buf_out[BLOCK_SIZE] = { 0 };
4558
4559 int rule_len_out = -1;
4560
4561 if (line_len < BLOCK_SIZE)
4562 {
4563 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4564 }
4565
4566 if (rule_len_out < 0) continue;
4567
4568 line_buf = rule_buf_out;
4569 line_len = rule_len_out;
4570 }
4571
4572 if (line_len > PW_MAX)
4573 {
4574 continue;
4575 }
4576
4577 // hmm that's always the case, or?
4578
4579 if (attack_kern == ATTACK_KERN_STRAIGHT)
4580 {
4581 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4582 {
4583 hc_thread_mutex_lock (mux_counter);
4584
4585 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4586 {
4587 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4588 }
4589
4590 hc_thread_mutex_unlock (mux_counter);
4591
4592 continue;
4593 }
4594 }
4595
4596 pw_add (device_param, (u8 *) line_buf, line_len);
4597
4598 words_cur++;
4599
4600 if (data.devices_status == STATUS_CRACKED) break;
4601 if (data.devices_status == STATUS_ABORTED) break;
4602 if (data.devices_status == STATUS_QUIT) break;
4603 if (data.devices_status == STATUS_BYPASS) break;
4604 }
4605
4606 hc_thread_mutex_unlock (mux_dispatcher);
4607
4608 if (data.devices_status == STATUS_CRACKED) break;
4609 if (data.devices_status == STATUS_ABORTED) break;
4610 if (data.devices_status == STATUS_QUIT) break;
4611 if (data.devices_status == STATUS_BYPASS) break;
4612
4613 // flush
4614
4615 const uint pws_cnt = device_param->pws_cnt;
4616
4617 if (pws_cnt)
4618 {
4619 run_copy (device_param, pws_cnt);
4620
4621 run_cracker (device_param, pws_cnt);
4622
4623 device_param->pws_cnt = 0;
4624
4625 /*
4626 still required?
4627 if (attack_kern == ATTACK_KERN_STRAIGHT)
4628 {
4629 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4630 }
4631 else if (attack_kern == ATTACK_KERN_COMBI)
4632 {
4633 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4634 }
4635 */
4636 }
4637 }
4638
4639 device_param->kernel_accel = 0;
4640 device_param->kernel_loops = 0;
4641
4642 myfree (buf);
4643
4644 return NULL;
4645 }
4646
4647 static void *thread_calc (void *p)
4648 {
4649 hc_device_param_t *device_param = (hc_device_param_t *) p;
4650
4651 if (device_param->skipped) return NULL;
4652
4653 const uint attack_mode = data.attack_mode;
4654 const uint attack_kern = data.attack_kern;
4655
4656 if (attack_mode == ATTACK_MODE_BF)
4657 {
4658 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4659 {
4660 const uint work = get_work (device_param, -1);
4661
4662 if (work == 0) break;
4663
4664 const u64 words_off = device_param->words_off;
4665 const u64 words_fin = words_off + work;
4666
4667 const uint pws_cnt = work;
4668
4669 device_param->pws_cnt = pws_cnt;
4670
4671 if (pws_cnt)
4672 {
4673 run_copy (device_param, pws_cnt);
4674
4675 run_cracker (device_param, pws_cnt);
4676
4677 device_param->pws_cnt = 0;
4678
4679 /*
4680 still required?
4681 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4682 */
4683 }
4684
4685 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4686
4687 if (data.devices_status == STATUS_CRACKED) break;
4688 if (data.devices_status == STATUS_ABORTED) break;
4689 if (data.devices_status == STATUS_QUIT) break;
4690 if (data.devices_status == STATUS_BYPASS) break;
4691
4692 if (data.benchmark == 1) break;
4693
4694 device_param->words_done = words_fin;
4695 }
4696 }
4697 else
4698 {
4699 const uint segment_size = data.segment_size;
4700
4701 char *dictfile = data.dictfile;
4702
4703 if (attack_mode == ATTACK_MODE_COMBI)
4704 {
4705 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4706 {
4707 dictfile = data.dictfile2;
4708 }
4709 }
4710
4711 FILE *fd = fopen (dictfile, "rb");
4712
4713 if (fd == NULL)
4714 {
4715 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4716
4717 return NULL;
4718 }
4719
4720 if (attack_mode == ATTACK_MODE_COMBI)
4721 {
4722 const uint combs_mode = data.combs_mode;
4723
4724 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4725 {
4726 const char *dictfilec = data.dictfile2;
4727
4728 FILE *combs_fp = fopen (dictfilec, "rb");
4729
4730 if (combs_fp == NULL)
4731 {
4732 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4733
4734 fclose (fd);
4735
4736 return NULL;
4737 }
4738
4739 device_param->combs_fp = combs_fp;
4740 }
4741 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4742 {
4743 const char *dictfilec = data.dictfile;
4744
4745 FILE *combs_fp = fopen (dictfilec, "rb");
4746
4747 if (combs_fp == NULL)
4748 {
4749 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4750
4751 fclose (fd);
4752
4753 return NULL;
4754 }
4755
4756 device_param->combs_fp = combs_fp;
4757 }
4758 }
4759
4760 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4761
4762 wl_data->buf = (char *) mymalloc (segment_size);
4763 wl_data->avail = segment_size;
4764 wl_data->incr = segment_size;
4765 wl_data->cnt = 0;
4766 wl_data->pos = 0;
4767
4768 u64 words_cur = 0;
4769
4770 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4771 {
4772 u64 words_off = 0;
4773 u64 words_fin = 0;
4774
4775 u64 max = -1;
4776
4777 while (max)
4778 {
4779 const uint work = get_work (device_param, max);
4780
4781 if (work == 0) break;
4782
4783 max = 0;
4784
4785 words_off = device_param->words_off;
4786 words_fin = words_off + work;
4787
4788 char *line_buf;
4789 uint line_len;
4790
4791 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4792
4793 for ( ; words_cur < words_fin; words_cur++)
4794 {
4795 get_next_word (wl_data, fd, &line_buf, &line_len);
4796
4797 line_len = convert_from_hex (line_buf, line_len);
4798
4799 // post-process rule engine
4800
4801 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4802 {
4803 char rule_buf_out[BLOCK_SIZE] = { 0 };
4804
4805 int rule_len_out = -1;
4806
4807 if (line_len < BLOCK_SIZE)
4808 {
4809 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4810 }
4811
4812 if (rule_len_out < 0) continue;
4813
4814 line_buf = rule_buf_out;
4815 line_len = rule_len_out;
4816 }
4817
4818 if (attack_kern == ATTACK_KERN_STRAIGHT)
4819 {
4820 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4821 {
4822 max++;
4823
4824 hc_thread_mutex_lock (mux_counter);
4825
4826 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4827 {
4828 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4829 }
4830
4831 hc_thread_mutex_unlock (mux_counter);
4832
4833 continue;
4834 }
4835 }
4836 else if (attack_kern == ATTACK_KERN_COMBI)
4837 {
4838 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4839 // since we still need to combine the plains
4840
4841 if (line_len > data.pw_max)
4842 {
4843 max++;
4844
4845 hc_thread_mutex_lock (mux_counter);
4846
4847 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4848 {
4849 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4850 }
4851
4852 hc_thread_mutex_unlock (mux_counter);
4853
4854 continue;
4855 }
4856 }
4857
4858 pw_add (device_param, (u8 *) line_buf, line_len);
4859
4860 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4861
4862 if (data.devices_status == STATUS_CRACKED) break;
4863 if (data.devices_status == STATUS_ABORTED) break;
4864 if (data.devices_status == STATUS_QUIT) break;
4865 if (data.devices_status == STATUS_BYPASS) break;
4866 }
4867
4868 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4869
4870 if (data.devices_status == STATUS_CRACKED) break;
4871 if (data.devices_status == STATUS_ABORTED) break;
4872 if (data.devices_status == STATUS_QUIT) break;
4873 if (data.devices_status == STATUS_BYPASS) break;
4874 }
4875
4876 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4877
4878 if (data.devices_status == STATUS_CRACKED) break;
4879 if (data.devices_status == STATUS_ABORTED) break;
4880 if (data.devices_status == STATUS_QUIT) break;
4881 if (data.devices_status == STATUS_BYPASS) break;
4882
4883 //
4884 // flush
4885 //
4886
4887 const uint pws_cnt = device_param->pws_cnt;
4888
4889 if (pws_cnt)
4890 {
4891 run_copy (device_param, pws_cnt);
4892
4893 run_cracker (device_param, pws_cnt);
4894
4895 device_param->pws_cnt = 0;
4896
4897 /*
4898 still required?
4899 if (attack_kern == ATTACK_KERN_STRAIGHT)
4900 {
4901 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4902 }
4903 else if (attack_kern == ATTACK_KERN_COMBI)
4904 {
4905 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4906 }
4907 */
4908 }
4909
4910 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4911
4912 if (data.devices_status == STATUS_CRACKED) break;
4913 if (data.devices_status == STATUS_ABORTED) break;
4914 if (data.devices_status == STATUS_QUIT) break;
4915 if (data.devices_status == STATUS_BYPASS) break;
4916
4917 if (words_fin == 0) break;
4918
4919 device_param->words_done = words_fin;
4920 }
4921
4922 if (attack_mode == ATTACK_MODE_COMBI)
4923 {
4924 fclose (device_param->combs_fp);
4925 }
4926
4927 free (wl_data->buf);
4928 free (wl_data);
4929
4930 fclose (fd);
4931 }
4932
4933 device_param->kernel_accel = 0;
4934 device_param->kernel_loops = 0;
4935
4936 return NULL;
4937 }
4938
4939 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4940 {
4941 if (!device_param)
4942 {
4943 log_error ("ERROR: %s : Invalid argument", __func__);
4944
4945 exit (-1);
4946 }
4947
4948 salt_t *salt_buf = &data.salts_buf[salt_pos];
4949
4950 device_param->kernel_params_buf32[24] = salt_pos;
4951 device_param->kernel_params_buf32[27] = 1;
4952 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4953 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4954 device_param->kernel_params_buf32[30] = 0;
4955 device_param->kernel_params_buf32[31] = 1;
4956
4957 char *dictfile_old = data.dictfile;
4958
4959 const char *weak_hash_check = "weak-hash-check";
4960
4961 data.dictfile = (char *) weak_hash_check;
4962
4963 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4964
4965 data.kernel_rules_buf[0].cmds[0] = 0;
4966
4967 /**
4968 * run the kernel
4969 */
4970
4971 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4972 {
4973 run_kernel (KERN_RUN_1, device_param, 1, false);
4974 }
4975 else
4976 {
4977 run_kernel (KERN_RUN_1, device_param, 1, false);
4978
4979 uint loop_step = 16;
4980
4981 const uint iter = salt_buf->salt_iter;
4982
4983 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4984 {
4985 uint loop_left = iter - loop_pos;
4986
4987 loop_left = MIN (loop_left, loop_step);
4988
4989 device_param->kernel_params_buf32[25] = loop_pos;
4990 device_param->kernel_params_buf32[26] = loop_left;
4991
4992 run_kernel (KERN_RUN_2, device_param, 1, false);
4993 }
4994
4995 run_kernel (KERN_RUN_3, device_param, 1, false);
4996 }
4997
4998 /**
4999 * result
5000 */
5001
5002 check_cracked (device_param, salt_pos);
5003
5004 /**
5005 * cleanup
5006 */
5007
5008 device_param->kernel_params_buf32[24] = 0;
5009 device_param->kernel_params_buf32[25] = 0;
5010 device_param->kernel_params_buf32[26] = 0;
5011 device_param->kernel_params_buf32[27] = 0;
5012 device_param->kernel_params_buf32[28] = 0;
5013 device_param->kernel_params_buf32[29] = 0;
5014 device_param->kernel_params_buf32[30] = 0;
5015 device_param->kernel_params_buf32[31] = 0;
5016
5017 data.dictfile = dictfile_old;
5018
5019 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5020 }
5021
5022 // hlfmt hashcat
5023
5024 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5025 {
5026 if (data.username == 0)
5027 {
5028 *hashbuf_pos = line_buf;
5029 *hashbuf_len = line_len;
5030 }
5031 else
5032 {
5033 char *pos = line_buf;
5034 int len = line_len;
5035
5036 for (int i = 0; i < line_len; i++, pos++, len--)
5037 {
5038 if (line_buf[i] == data.separator)
5039 {
5040 pos++;
5041
5042 len--;
5043
5044 break;
5045 }
5046 }
5047
5048 *hashbuf_pos = pos;
5049 *hashbuf_len = len;
5050 }
5051 }
5052
5053 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5054 {
5055 char *pos = NULL;
5056 int len = 0;
5057
5058 int sep_cnt = 0;
5059
5060 for (int i = 0; i < line_len; i++)
5061 {
5062 if (line_buf[i] == data.separator)
5063 {
5064 sep_cnt++;
5065
5066 continue;
5067 }
5068
5069 if (sep_cnt == 0)
5070 {
5071 if (pos == NULL) pos = line_buf + i;
5072
5073 len++;
5074 }
5075 }
5076
5077 *userbuf_pos = pos;
5078 *userbuf_len = len;
5079 }
5080
5081 // hlfmt pwdump
5082
5083 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5084 {
5085 int sep_cnt = 0;
5086
5087 int sep2_len = 0;
5088 int sep3_len = 0;
5089
5090 for (int i = 0; i < line_len; i++)
5091 {
5092 if (line_buf[i] == ':')
5093 {
5094 sep_cnt++;
5095
5096 continue;
5097 }
5098
5099 if (sep_cnt == 2) sep2_len++;
5100 if (sep_cnt == 3) sep3_len++;
5101 }
5102
5103 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5104
5105 return 0;
5106 }
5107
5108 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5109 {
5110 char *pos = NULL;
5111 int len = 0;
5112
5113 int sep_cnt = 0;
5114
5115 for (int i = 0; i < line_len; i++)
5116 {
5117 if (line_buf[i] == ':')
5118 {
5119 sep_cnt++;
5120
5121 continue;
5122 }
5123
5124 if (data.hash_mode == 1000)
5125 {
5126 if (sep_cnt == 3)
5127 {
5128 if (pos == NULL) pos = line_buf + i;
5129
5130 len++;
5131 }
5132 }
5133 else if (data.hash_mode == 3000)
5134 {
5135 if (sep_cnt == 2)
5136 {
5137 if (pos == NULL) pos = line_buf + i;
5138
5139 len++;
5140 }
5141 }
5142 }
5143
5144 *hashbuf_pos = pos;
5145 *hashbuf_len = len;
5146 }
5147
5148 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5149 {
5150 char *pos = NULL;
5151 int len = 0;
5152
5153 int sep_cnt = 0;
5154
5155 for (int i = 0; i < line_len; i++)
5156 {
5157 if (line_buf[i] == ':')
5158 {
5159 sep_cnt++;
5160
5161 continue;
5162 }
5163
5164 if (sep_cnt == 0)
5165 {
5166 if (pos == NULL) pos = line_buf + i;
5167
5168 len++;
5169 }
5170 }
5171
5172 *userbuf_pos = pos;
5173 *userbuf_len = len;
5174 }
5175
5176 // hlfmt passwd
5177
5178 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5179 {
5180 int sep_cnt = 0;
5181
5182 char sep5_first = 0;
5183 char sep6_first = 0;
5184
5185 for (int i = 0; i < line_len; i++)
5186 {
5187 if (line_buf[i] == ':')
5188 {
5189 sep_cnt++;
5190
5191 continue;
5192 }
5193
5194 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5195 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5196 }
5197
5198 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5199
5200 return 0;
5201 }
5202
5203 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5204 {
5205 char *pos = NULL;
5206 int len = 0;
5207
5208 int sep_cnt = 0;
5209
5210 for (int i = 0; i < line_len; i++)
5211 {
5212 if (line_buf[i] == ':')
5213 {
5214 sep_cnt++;
5215
5216 continue;
5217 }
5218
5219 if (sep_cnt == 1)
5220 {
5221 if (pos == NULL) pos = line_buf + i;
5222
5223 len++;
5224 }
5225 }
5226
5227 *hashbuf_pos = pos;
5228 *hashbuf_len = len;
5229 }
5230
5231 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5232 {
5233 char *pos = NULL;
5234 int len = 0;
5235
5236 int sep_cnt = 0;
5237
5238 for (int i = 0; i < line_len; i++)
5239 {
5240 if (line_buf[i] == ':')
5241 {
5242 sep_cnt++;
5243
5244 continue;
5245 }
5246
5247 if (sep_cnt == 0)
5248 {
5249 if (pos == NULL) pos = line_buf + i;
5250
5251 len++;
5252 }
5253 }
5254
5255 *userbuf_pos = pos;
5256 *userbuf_len = len;
5257 }
5258
5259 // hlfmt shadow
5260
5261 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5262 {
5263 int sep_cnt = 0;
5264
5265 for (int i = 0; i < line_len; i++)
5266 {
5267 if (line_buf[i] == ':') sep_cnt++;
5268 }
5269
5270 if (sep_cnt == 8) return 1;
5271
5272 return 0;
5273 }
5274
5275 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5276 {
5277 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5278 }
5279
5280 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5281 {
5282 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5283 }
5284
5285 // hlfmt main
5286
5287 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5288 {
5289 switch (hashfile_format)
5290 {
5291 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5292 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5293 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5294 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5295 }
5296 }
5297
5298 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5299 {
5300 switch (hashfile_format)
5301 {
5302 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5303 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5304 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5305 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5306 }
5307 }
5308
5309 char *strhlfmt (const uint hashfile_format)
5310 {
5311 switch (hashfile_format)
5312 {
5313 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5314 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5315 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5316 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5317 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5318 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5319 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5320 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5321 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5322 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5323 }
5324
5325 return ((char *) "Unknown");
5326 }
5327
5328 static uint hlfmt_detect (FILE *fp, uint max_check)
5329 {
5330 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5331
5332 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5333 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5334
5335 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5336
5337 uint num_check = 0;
5338
5339 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5340
5341 while (!feof (fp))
5342 {
5343 int line_len = fgetl (fp, line_buf);
5344
5345 if (line_len == 0) continue;
5346
5347 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5348 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5349 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5350
5351 if (num_check == max_check) break;
5352
5353 num_check++;
5354 }
5355
5356 myfree (line_buf);
5357
5358 uint hashlist_format = HLFMT_HASHCAT;
5359
5360 for (int i = 1; i < HLFMTS_CNT; i++)
5361 {
5362 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5363
5364 hashlist_format = i;
5365 }
5366
5367 free (formats_cnt);
5368
5369 return hashlist_format;
5370 }
5371
5372 /**
5373 * some further helper function
5374 */
5375
5376 // wrapper around mymalloc for ADL
5377
5378 #if defined(HAVE_HWMON)
5379 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5380 {
5381 return mymalloc (iSize);
5382 }
5383 #endif
5384
5385 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)
5386 {
5387 u64 collisions = 0;
5388
5389 const uint dgst_pos0 = data.dgst_pos0;
5390 const uint dgst_pos1 = data.dgst_pos1;
5391 const uint dgst_pos2 = data.dgst_pos2;
5392 const uint dgst_pos3 = data.dgst_pos3;
5393
5394 memset (bitmap_a, 0, bitmap_size);
5395 memset (bitmap_b, 0, bitmap_size);
5396 memset (bitmap_c, 0, bitmap_size);
5397 memset (bitmap_d, 0, bitmap_size);
5398
5399 for (uint i = 0; i < digests_cnt; i++)
5400 {
5401 uint *digest_ptr = (uint *) digests_buf_ptr;
5402
5403 digests_buf_ptr += dgst_size;
5404
5405 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5406 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5407 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5408 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5409
5410 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5411 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5412 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5413 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5414
5415 if (bitmap_a[idx0] & val0) collisions++;
5416 if (bitmap_b[idx1] & val1) collisions++;
5417 if (bitmap_c[idx2] & val2) collisions++;
5418 if (bitmap_d[idx3] & val3) collisions++;
5419
5420 bitmap_a[idx0] |= val0;
5421 bitmap_b[idx1] |= val1;
5422 bitmap_c[idx2] |= val2;
5423 bitmap_d[idx3] |= val3;
5424
5425 if (collisions >= collisions_max) return 0x7fffffff;
5426 }
5427
5428 return collisions;
5429 }
5430
5431 /**
5432 * main
5433 */
5434
5435 #ifdef WIN
5436 void SetConsoleWindowSize (const int x)
5437 {
5438 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5439
5440 if (h == INVALID_HANDLE_VALUE) return;
5441
5442 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5443
5444 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5445
5446 SMALL_RECT *sr = &bufferInfo.srWindow;
5447
5448 sr->Right = MAX (sr->Right, x - 1);
5449
5450 COORD co;
5451
5452 co.X = sr->Right + 1;
5453 co.Y = 9999;
5454
5455 if (!SetConsoleScreenBufferSize (h, co)) return;
5456
5457 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5458 }
5459 #endif
5460
5461 int main (int argc, char **argv)
5462 {
5463 #ifdef WIN
5464 SetConsoleWindowSize (132);
5465 #endif
5466
5467 /**
5468 * To help users a bit
5469 */
5470
5471 char *compute = getenv ("COMPUTE");
5472
5473 if (compute)
5474 {
5475 static char display[100];
5476
5477 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5478
5479 putenv (display);
5480 }
5481 else
5482 {
5483 if (getenv ("DISPLAY") == NULL)
5484 putenv ((char *) "DISPLAY=:0");
5485 }
5486
5487 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5488 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5489
5490 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5491 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5492
5493 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5494 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5495
5496 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5497 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5498
5499 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5500 putenv ((char *) "POCL_KERNEL_CACHE=0");
5501
5502 umask (077);
5503
5504 /**
5505 * Real init
5506 */
5507
5508 memset (&data, 0, sizeof (hc_global_data_t));
5509
5510 time_t proc_start;
5511
5512 time (&proc_start);
5513
5514 data.proc_start = proc_start;
5515
5516 int myargc = argc;
5517 char **myargv = argv;
5518
5519 hc_thread_mutex_init (mux_dispatcher);
5520 hc_thread_mutex_init (mux_counter);
5521 hc_thread_mutex_init (mux_display);
5522 hc_thread_mutex_init (mux_adl);
5523
5524 /**
5525 * commandline parameters
5526 */
5527
5528 uint usage = USAGE;
5529 uint version = VERSION;
5530 uint quiet = QUIET;
5531 uint benchmark = BENCHMARK;
5532 uint show = SHOW;
5533 uint left = LEFT;
5534 uint username = USERNAME;
5535 uint remove = REMOVE;
5536 uint remove_timer = REMOVE_TIMER;
5537 u64 skip = SKIP;
5538 u64 limit = LIMIT;
5539 uint keyspace = KEYSPACE;
5540 uint potfile_disable = POTFILE_DISABLE;
5541 char *potfile_path = NULL;
5542 uint debug_mode = DEBUG_MODE;
5543 char *debug_file = NULL;
5544 char *induction_dir = NULL;
5545 char *outfile_check_dir = NULL;
5546 uint force = FORCE;
5547 uint runtime = RUNTIME;
5548 uint hash_mode = HASH_MODE;
5549 uint attack_mode = ATTACK_MODE;
5550 uint markov_disable = MARKOV_DISABLE;
5551 uint markov_classic = MARKOV_CLASSIC;
5552 uint markov_threshold = MARKOV_THRESHOLD;
5553 char *markov_hcstat = NULL;
5554 char *outfile = NULL;
5555 uint outfile_format = OUTFILE_FORMAT;
5556 uint outfile_autohex = OUTFILE_AUTOHEX;
5557 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5558 uint restore = RESTORE;
5559 uint restore_timer = RESTORE_TIMER;
5560 uint restore_disable = RESTORE_DISABLE;
5561 uint status = STATUS;
5562 uint status_timer = STATUS_TIMER;
5563 uint machine_readable = MACHINE_READABLE;
5564 uint loopback = LOOPBACK;
5565 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5566 char *session = NULL;
5567 uint hex_charset = HEX_CHARSET;
5568 uint hex_salt = HEX_SALT;
5569 uint hex_wordlist = HEX_WORDLIST;
5570 uint rp_gen = RP_GEN;
5571 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5572 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5573 uint rp_gen_seed = RP_GEN_SEED;
5574 char *rule_buf_l = (char *) RULE_BUF_L;
5575 char *rule_buf_r = (char *) RULE_BUF_R;
5576 uint increment = INCREMENT;
5577 uint increment_min = INCREMENT_MIN;
5578 uint increment_max = INCREMENT_MAX;
5579 char *cpu_affinity = NULL;
5580 OCL_PTR *ocl = NULL;
5581 char *opencl_devices = NULL;
5582 char *opencl_platforms = NULL;
5583 char *opencl_device_types = NULL;
5584 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5585 char *truecrypt_keyfiles = NULL;
5586 char *veracrypt_keyfiles = NULL;
5587 uint veracrypt_pim = 0;
5588 uint workload_profile = WORKLOAD_PROFILE;
5589 uint kernel_accel = KERNEL_ACCEL;
5590 uint kernel_loops = KERNEL_LOOPS;
5591 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5592 #ifdef HAVE_HWMON
5593 uint gpu_temp_abort = GPU_TEMP_ABORT;
5594 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5595 uint powertune_enable = POWERTUNE_ENABLE;
5596 #endif
5597 uint logfile_disable = LOGFILE_DISABLE;
5598 uint segment_size = SEGMENT_SIZE;
5599 uint scrypt_tmto = SCRYPT_TMTO;
5600 char separator = SEPARATOR;
5601 uint bitmap_min = BITMAP_MIN;
5602 uint bitmap_max = BITMAP_MAX;
5603 char *custom_charset_1 = NULL;
5604 char *custom_charset_2 = NULL;
5605 char *custom_charset_3 = NULL;
5606 char *custom_charset_4 = NULL;
5607
5608 #define IDX_HELP 'h'
5609 #define IDX_VERSION 'V'
5610 #define IDX_VERSION_LOWER 'v'
5611 #define IDX_QUIET 0xff02
5612 #define IDX_SHOW 0xff03
5613 #define IDX_LEFT 0xff04
5614 #define IDX_REMOVE 0xff05
5615 #define IDX_REMOVE_TIMER 0xff37
5616 #define IDX_SKIP 's'
5617 #define IDX_LIMIT 'l'
5618 #define IDX_KEYSPACE 0xff35
5619 #define IDX_POTFILE_DISABLE 0xff06
5620 #define IDX_POTFILE_PATH 0xffe0
5621 #define IDX_DEBUG_MODE 0xff43
5622 #define IDX_DEBUG_FILE 0xff44
5623 #define IDX_INDUCTION_DIR 0xff46
5624 #define IDX_OUTFILE_CHECK_DIR 0xff47
5625 #define IDX_USERNAME 0xff07
5626 #define IDX_FORCE 0xff08
5627 #define IDX_RUNTIME 0xff09
5628 #define IDX_BENCHMARK 'b'
5629 #define IDX_HASH_MODE 'm'
5630 #define IDX_ATTACK_MODE 'a'
5631 #define IDX_RP_FILE 'r'
5632 #define IDX_RP_GEN 'g'
5633 #define IDX_RP_GEN_FUNC_MIN 0xff10
5634 #define IDX_RP_GEN_FUNC_MAX 0xff11
5635 #define IDX_RP_GEN_SEED 0xff34
5636 #define IDX_RULE_BUF_L 'j'
5637 #define IDX_RULE_BUF_R 'k'
5638 #define IDX_INCREMENT 'i'
5639 #define IDX_INCREMENT_MIN 0xff12
5640 #define IDX_INCREMENT_MAX 0xff13
5641 #define IDX_OUTFILE 'o'
5642 #define IDX_OUTFILE_FORMAT 0xff14
5643 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5644 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5645 #define IDX_RESTORE 0xff15
5646 #define IDX_RESTORE_DISABLE 0xff27
5647 #define IDX_STATUS 0xff17
5648 #define IDX_STATUS_TIMER 0xff18
5649 #define IDX_MACHINE_READABLE 0xff50
5650 #define IDX_LOOPBACK 0xff38
5651 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5652 #define IDX_SESSION 0xff19
5653 #define IDX_HEX_CHARSET 0xff20
5654 #define IDX_HEX_SALT 0xff21
5655 #define IDX_HEX_WORDLIST 0xff40
5656 #define IDX_MARKOV_DISABLE 0xff22
5657 #define IDX_MARKOV_CLASSIC 0xff23
5658 #define IDX_MARKOV_THRESHOLD 't'
5659 #define IDX_MARKOV_HCSTAT 0xff24
5660 #define IDX_CPU_AFFINITY 0xff25
5661 #define IDX_OPENCL_DEVICES 'd'
5662 #define IDX_OPENCL_PLATFORMS 0xff72
5663 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5664 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5665 #define IDX_WORKLOAD_PROFILE 'w'
5666 #define IDX_KERNEL_ACCEL 'n'
5667 #define IDX_KERNEL_LOOPS 'u'
5668 #define IDX_GPU_TEMP_DISABLE 0xff29
5669 #define IDX_GPU_TEMP_ABORT 0xff30
5670 #define IDX_GPU_TEMP_RETAIN 0xff31
5671 #define IDX_POWERTUNE_ENABLE 0xff41
5672 #define IDX_LOGFILE_DISABLE 0xff51
5673 #define IDX_TRUECRYPT_KEYFILES 0xff52
5674 #define IDX_VERACRYPT_KEYFILES 0xff53
5675 #define IDX_VERACRYPT_PIM 0xff54
5676 #define IDX_SCRYPT_TMTO 0xff61
5677 #define IDX_SEGMENT_SIZE 'c'
5678 #define IDX_SEPARATOR 'p'
5679 #define IDX_BITMAP_MIN 0xff70
5680 #define IDX_BITMAP_MAX 0xff71
5681 #define IDX_CUSTOM_CHARSET_1 '1'
5682 #define IDX_CUSTOM_CHARSET_2 '2'
5683 #define IDX_CUSTOM_CHARSET_3 '3'
5684 #define IDX_CUSTOM_CHARSET_4 '4'
5685
5686 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5687
5688 struct option long_options[] =
5689 {
5690 {"help", no_argument, 0, IDX_HELP},
5691 {"version", no_argument, 0, IDX_VERSION},
5692 {"quiet", no_argument, 0, IDX_QUIET},
5693 {"show", no_argument, 0, IDX_SHOW},
5694 {"left", no_argument, 0, IDX_LEFT},
5695 {"username", no_argument, 0, IDX_USERNAME},
5696 {"remove", no_argument, 0, IDX_REMOVE},
5697 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5698 {"skip", required_argument, 0, IDX_SKIP},
5699 {"limit", required_argument, 0, IDX_LIMIT},
5700 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5701 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5702 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5703 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5704 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5705 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5706 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5707 {"force", no_argument, 0, IDX_FORCE},
5708 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5709 {"restore", no_argument, 0, IDX_RESTORE},
5710 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5711 {"status", no_argument, 0, IDX_STATUS},
5712 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5713 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5714 {"loopback", no_argument, 0, IDX_LOOPBACK},
5715 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5716 {"session", required_argument, 0, IDX_SESSION},
5717 {"runtime", required_argument, 0, IDX_RUNTIME},
5718 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5719 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5720 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5721 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5722 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5723 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5724 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5725 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5726 {"rules-file", required_argument, 0, IDX_RP_FILE},
5727 {"outfile", required_argument, 0, IDX_OUTFILE},
5728 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5729 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5730 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5731 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5732 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5733 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5734 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5735 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5736 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5737 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5738 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5739 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5740 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5741 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5742 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5743 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5744 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5745 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5746 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5747 #ifdef HAVE_HWMON
5748 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5749 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5750 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5751 #endif // HAVE_HWMON
5752 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5753 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5754 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5755 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5756 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5757 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5758 {"seperator", required_argument, 0, IDX_SEPARATOR},
5759 {"separator", required_argument, 0, IDX_SEPARATOR},
5760 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5761 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5762 {"increment", no_argument, 0, IDX_INCREMENT},
5763 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5764 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5765 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5766 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5767 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5768 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5769 {0, 0, 0, 0}
5770 };
5771
5772 uint rp_files_cnt = 0;
5773
5774 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5775
5776 int option_index = 0;
5777 int c = -1;
5778
5779 optind = 1;
5780 optopt = 0;
5781
5782 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5783 {
5784 switch (c)
5785 {
5786 case IDX_HELP: usage = 1; break;
5787 case IDX_VERSION:
5788 case IDX_VERSION_LOWER: version = 1; break;
5789 case IDX_RESTORE: restore = 1; break;
5790 case IDX_SESSION: session = optarg; break;
5791 case IDX_SHOW: show = 1; break;
5792 case IDX_LEFT: left = 1; break;
5793 case '?': return (-1);
5794 }
5795 }
5796
5797 if (optopt != 0)
5798 {
5799 log_error ("ERROR: Invalid argument specified");
5800
5801 return (-1);
5802 }
5803
5804 /**
5805 * exit functions
5806 */
5807
5808 if (version)
5809 {
5810 log_info ("%s", VERSION_TAG);
5811
5812 return (0);
5813 }
5814
5815 if (usage)
5816 {
5817 usage_big_print (PROGNAME);
5818
5819 return (0);
5820 }
5821
5822 /**
5823 * session needs to be set, always!
5824 */
5825
5826 if (session == NULL) session = (char *) PROGNAME;
5827
5828 /**
5829 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5830 */
5831
5832 char *exec_path = get_exec_path ();
5833
5834 #ifdef LINUX
5835
5836 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5837 char *resolved_exec_path = realpath (exec_path, NULL);
5838
5839 char *install_dir = get_install_dir (resolved_exec_path);
5840 char *profile_dir = NULL;
5841 char *session_dir = NULL;
5842 char *shared_dir = NULL;
5843
5844 if (strcmp (install_dir, resolved_install_folder) == 0)
5845 {
5846 struct passwd *pw = getpwuid (getuid ());
5847
5848 const char *homedir = pw->pw_dir;
5849
5850 profile_dir = get_profile_dir (homedir);
5851 session_dir = get_session_dir (profile_dir);
5852 shared_dir = strdup (SHARED_FOLDER);
5853
5854 mkdir (profile_dir, 0700);
5855 mkdir (session_dir, 0700);
5856 }
5857 else
5858 {
5859 profile_dir = install_dir;
5860 session_dir = install_dir;
5861 shared_dir = install_dir;
5862 }
5863
5864 myfree (resolved_install_folder);
5865 myfree (resolved_exec_path);
5866
5867 #else
5868
5869 char *install_dir = get_install_dir (exec_path);
5870 char *profile_dir = install_dir;
5871 char *session_dir = install_dir;
5872 char *shared_dir = install_dir;
5873
5874 #endif
5875
5876 data.install_dir = install_dir;
5877 data.profile_dir = profile_dir;
5878 data.session_dir = session_dir;
5879 data.shared_dir = shared_dir;
5880
5881 myfree (exec_path);
5882
5883 /**
5884 * kernel cache, we need to make sure folder exist
5885 */
5886
5887 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5888
5889 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5890
5891 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5892
5893 mkdir (kernels_folder, 0700);
5894
5895 myfree (kernels_folder);
5896
5897 /**
5898 * session
5899 */
5900
5901 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5902
5903 data.session = session;
5904
5905 char *eff_restore_file = (char *) mymalloc (session_size);
5906 char *new_restore_file = (char *) mymalloc (session_size);
5907
5908 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5909 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5910
5911 data.eff_restore_file = eff_restore_file;
5912 data.new_restore_file = new_restore_file;
5913
5914 if (((show == 1) || (left == 1)) && (restore == 1))
5915 {
5916 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5917 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5918
5919 return (-1);
5920 }
5921
5922 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5923 if ((show == 1) || (left == 1))
5924 {
5925 restore_disable = 1;
5926
5927 restore = 0;
5928 }
5929
5930 data.restore_disable = restore_disable;
5931
5932 restore_data_t *rd = init_restore (argc, argv);
5933
5934 data.rd = rd;
5935
5936 /**
5937 * restore file
5938 */
5939
5940 if (restore == 1)
5941 {
5942 read_restore (eff_restore_file, rd);
5943
5944 if (rd->version_bin < RESTORE_MIN)
5945 {
5946 log_error ("ERROR: Incompatible restore-file version");
5947
5948 return (-1);
5949 }
5950
5951 myargc = rd->argc;
5952 myargv = rd->argv;
5953
5954 #ifdef _POSIX
5955 rd->pid = getpid ();
5956 #elif _WIN
5957 rd->pid = GetCurrentProcessId ();
5958 #endif
5959 }
5960
5961 uint hash_mode_chgd = 0;
5962 uint runtime_chgd = 0;
5963 uint kernel_loops_chgd = 0;
5964 uint kernel_accel_chgd = 0;
5965 uint attack_mode_chgd = 0;
5966 uint outfile_format_chgd = 0;
5967 uint rp_gen_seed_chgd = 0;
5968 uint remove_timer_chgd = 0;
5969 uint increment_min_chgd = 0;
5970 uint increment_max_chgd = 0;
5971 uint workload_profile_chgd = 0;
5972 uint opencl_vector_width_chgd = 0;
5973
5974 optind = 1;
5975 optopt = 0;
5976 option_index = 0;
5977
5978 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5979 {
5980 switch (c)
5981 {
5982 //case IDX_HELP: usage = 1; break;
5983 //case IDX_VERSION: version = 1; break;
5984 //case IDX_RESTORE: restore = 1; break;
5985 case IDX_QUIET: quiet = 1; break;
5986 //case IDX_SHOW: show = 1; break;
5987 case IDX_SHOW: break;
5988 //case IDX_LEFT: left = 1; break;
5989 case IDX_LEFT: break;
5990 case IDX_USERNAME: username = 1; break;
5991 case IDX_REMOVE: remove = 1; break;
5992 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5993 remove_timer_chgd = 1; break;
5994 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5995 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5996 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5997 case IDX_DEBUG_FILE: debug_file = optarg; break;
5998 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5999 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6000 case IDX_FORCE: force = 1; break;
6001 case IDX_SKIP: skip = atoll (optarg); break;
6002 case IDX_LIMIT: limit = atoll (optarg); break;
6003 case IDX_KEYSPACE: keyspace = 1; break;
6004 case IDX_BENCHMARK: benchmark = 1; break;
6005 case IDX_RESTORE: break;
6006 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6007 case IDX_STATUS: status = 1; break;
6008 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6009 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6010 case IDX_LOOPBACK: loopback = 1; break;
6011 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6012 //case IDX_SESSION: session = optarg; break;
6013 case IDX_SESSION: break;
6014 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6015 hash_mode_chgd = 1; break;
6016 case IDX_RUNTIME: runtime = atoi (optarg);
6017 runtime_chgd = 1; break;
6018 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6019 attack_mode_chgd = 1; break;
6020 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6021 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6022 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6023 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6024 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6025 rp_gen_seed_chgd = 1; break;
6026 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6027 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6028 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6029 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6030 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6031 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6032 case IDX_OUTFILE: outfile = optarg; break;
6033 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6034 outfile_format_chgd = 1; break;
6035 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6036 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6037 case IDX_HEX_CHARSET: hex_charset = 1; break;
6038 case IDX_HEX_SALT: hex_salt = 1; break;
6039 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6040 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6041 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6042 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6043 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6044 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6045 opencl_vector_width_chgd = 1; break;
6046 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6047 workload_profile_chgd = 1; break;
6048 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6049 kernel_accel_chgd = 1; break;
6050 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6051 kernel_loops_chgd = 1; break;
6052 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6053 #ifdef HAVE_HWMON
6054 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6055 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6056 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6057 #endif // HAVE_HWMON
6058 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6059 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6060 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6061 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6062 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6063 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6064 case IDX_SEPARATOR: separator = optarg[0]; break;
6065 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6066 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6067 case IDX_INCREMENT: increment = 1; break;
6068 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6069 increment_min_chgd = 1; break;
6070 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6071 increment_max_chgd = 1; break;
6072 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6073 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6074 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6075 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6076
6077 default:
6078 log_error ("ERROR: Invalid argument specified");
6079 return (-1);
6080 }
6081 }
6082
6083 if (optopt != 0)
6084 {
6085 log_error ("ERROR: Invalid argument specified");
6086
6087 return (-1);
6088 }
6089
6090 /**
6091 * Inform user things getting started,
6092 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6093 * - we do not need to check algorithm_pos
6094 */
6095
6096 if (quiet == 0)
6097 {
6098 if (benchmark == 1)
6099 {
6100 if (machine_readable == 0)
6101 {
6102 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6103 log_info ("");
6104 log_info ("Note: Reported benchmark cracking speed = real cracking speed");
6105 log_info ("To verify, run hashcat like this: only_one_hash.txt -a 3 -w 3 ?b?b?b?b?b?b?b");
6106 log_info ("");
6107 }
6108 else
6109 {
6110 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6111 }
6112 }
6113 else if (restore == 1)
6114 {
6115 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6116 log_info ("");
6117 }
6118 else
6119 {
6120 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6121 log_info ("");
6122 }
6123 }
6124
6125 /**
6126 * sanity check
6127 */
6128
6129 if (attack_mode > 7)
6130 {
6131 log_error ("ERROR: Invalid attack-mode specified");
6132
6133 return (-1);
6134 }
6135
6136 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6137 {
6138 log_error ("ERROR: Invalid runtime specified");
6139
6140 return (-1);
6141 }
6142
6143 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6144 {
6145 log_error ("ERROR: Invalid hash-type specified");
6146
6147 return (-1);
6148 }
6149
6150 // renamed hash modes
6151
6152 if (hash_mode_chgd)
6153 {
6154 int n = -1;
6155
6156 switch (hash_mode)
6157 {
6158 case 123: n = 124;
6159 break;
6160 }
6161
6162 if (n >= 0)
6163 {
6164 log_error ("Old -m specified, use -m %d instead", n);
6165
6166 return (-1);
6167 }
6168 }
6169
6170 if (username == 1)
6171 {
6172 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6173 {
6174 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6175
6176 return (-1);
6177 }
6178 }
6179
6180 if (outfile_format > 16)
6181 {
6182 log_error ("ERROR: Invalid outfile-format specified");
6183
6184 return (-1);
6185 }
6186
6187 if (left == 1)
6188 {
6189 if (outfile_format_chgd == 1)
6190 {
6191 if (outfile_format > 1)
6192 {
6193 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6194
6195 return (-1);
6196 }
6197 }
6198 else
6199 {
6200 outfile_format = OUTFILE_FMT_HASH;
6201 }
6202 }
6203
6204 if (show == 1)
6205 {
6206 if (outfile_format_chgd == 1)
6207 {
6208 if ((outfile_format > 7) && (outfile_format < 16))
6209 {
6210 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6211
6212 return (-1);
6213 }
6214 }
6215 }
6216
6217 if (increment_min < INCREMENT_MIN)
6218 {
6219 log_error ("ERROR: Invalid increment-min specified");
6220
6221 return (-1);
6222 }
6223
6224 if (increment_max > INCREMENT_MAX)
6225 {
6226 log_error ("ERROR: Invalid increment-max specified");
6227
6228 return (-1);
6229 }
6230
6231 if (increment_min > increment_max)
6232 {
6233 log_error ("ERROR: Invalid increment-min specified");
6234
6235 return (-1);
6236 }
6237
6238 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6239 {
6240 log_error ("ERROR: increment is not allowed in attack-mode 0");
6241
6242 return (-1);
6243 }
6244
6245 if ((increment == 0) && (increment_min_chgd == 1))
6246 {
6247 log_error ("ERROR: increment-min is only supported together with increment switch");
6248
6249 return (-1);
6250 }
6251
6252 if ((increment == 0) && (increment_max_chgd == 1))
6253 {
6254 log_error ("ERROR: increment-max is only supported together with increment switch");
6255
6256 return (-1);
6257 }
6258
6259 if (rp_files_cnt && rp_gen)
6260 {
6261 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6262
6263 return (-1);
6264 }
6265
6266 if (rp_files_cnt || rp_gen)
6267 {
6268 if (attack_mode != ATTACK_MODE_STRAIGHT)
6269 {
6270 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6271
6272 return (-1);
6273 }
6274 }
6275
6276 if (rp_gen_func_min > rp_gen_func_max)
6277 {
6278 log_error ("ERROR: Invalid rp-gen-func-min specified");
6279
6280 return (-1);
6281 }
6282
6283 if (kernel_accel_chgd == 1)
6284 {
6285 if (force == 0)
6286 {
6287 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6288 log_info ("Please consider using the option -w instead");
6289 log_info ("You can use --force to override this but do not post error reports if you do so");
6290 log_info ("");
6291
6292 return (-1);
6293 }
6294
6295 if (kernel_accel < 1)
6296 {
6297 log_error ("ERROR: Invalid kernel-accel specified");
6298
6299 return (-1);
6300 }
6301
6302 if (kernel_accel > 1024)
6303 {
6304 log_error ("ERROR: Invalid kernel-accel specified");
6305
6306 return (-1);
6307 }
6308 }
6309
6310 if (kernel_loops_chgd == 1)
6311 {
6312 if (force == 0)
6313 {
6314 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6315 log_info ("Please consider using the option -w instead");
6316 log_info ("You can use --force to override this but do not post error reports if you do so");
6317 log_info ("");
6318
6319 return (-1);
6320 }
6321
6322 if (kernel_loops < 1)
6323 {
6324 log_error ("ERROR: Invalid kernel-loops specified");
6325
6326 return (-1);
6327 }
6328
6329 if (kernel_loops > 1024)
6330 {
6331 log_error ("ERROR: Invalid kernel-loops specified");
6332
6333 return (-1);
6334 }
6335 }
6336
6337 if ((workload_profile < 1) || (workload_profile > 4))
6338 {
6339 log_error ("ERROR: workload-profile %i not available", workload_profile);
6340
6341 return (-1);
6342 }
6343
6344 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6345 {
6346 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6347
6348 return (-1);
6349 }
6350
6351 if (show == 1 || left == 1)
6352 {
6353 attack_mode = ATTACK_MODE_NONE;
6354
6355 if (remove == 1)
6356 {
6357 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6358
6359 return (-1);
6360 }
6361
6362 if (potfile_disable == 1)
6363 {
6364 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6365
6366 return (-1);
6367 }
6368 }
6369
6370 uint attack_kern = ATTACK_KERN_NONE;
6371
6372 switch (attack_mode)
6373 {
6374 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6375 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6376 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6377 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6378 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6379 }
6380
6381 if (benchmark == 0)
6382 {
6383 if (keyspace == 1)
6384 {
6385 int num_additional_params = 1;
6386
6387 if (attack_kern == ATTACK_KERN_COMBI)
6388 {
6389 num_additional_params = 2;
6390 }
6391
6392 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6393
6394 if (keyspace_wordlist_specified == 0) optind--;
6395 }
6396
6397 if (attack_kern == ATTACK_KERN_NONE)
6398 {
6399 if ((optind + 1) != myargc)
6400 {
6401 usage_mini_print (myargv[0]);
6402
6403 return (-1);
6404 }
6405 }
6406 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6407 {
6408 if ((optind + 1) > myargc)
6409 {
6410 usage_mini_print (myargv[0]);
6411
6412 return (-1);
6413 }
6414 }
6415 else if (attack_kern == ATTACK_KERN_COMBI)
6416 {
6417 if ((optind + 3) != myargc)
6418 {
6419 usage_mini_print (myargv[0]);
6420
6421 return (-1);
6422 }
6423 }
6424 else if (attack_kern == ATTACK_KERN_BF)
6425 {
6426 if ((optind + 1) > myargc)
6427 {
6428 usage_mini_print (myargv[0]);
6429
6430 return (-1);
6431 }
6432 }
6433 else
6434 {
6435 usage_mini_print (myargv[0]);
6436
6437 return (-1);
6438 }
6439 }
6440 else
6441 {
6442 if (myargv[optind] != 0)
6443 {
6444 log_error ("ERROR: Invalid argument for benchmark mode specified");
6445
6446 return (-1);
6447 }
6448
6449 if (attack_mode_chgd == 1)
6450 {
6451 if (attack_mode != ATTACK_MODE_BF)
6452 {
6453 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6454
6455 return (-1);
6456 }
6457 }
6458 }
6459
6460 if (skip != 0 && limit != 0)
6461 {
6462 limit += skip;
6463 }
6464
6465 if (keyspace == 1)
6466 {
6467 if (show == 1)
6468 {
6469 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6470
6471 return (-1);
6472 }
6473 else if (left == 1)
6474 {
6475 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6476
6477 return (-1);
6478 }
6479
6480 potfile_disable = 1;
6481
6482 restore_disable = 1;
6483
6484 restore = 0;
6485
6486 weak_hash_threshold = 0;
6487
6488 quiet = 1;
6489 }
6490
6491 if (remove_timer_chgd == 1)
6492 {
6493 if (remove == 0)
6494 {
6495 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6496
6497 return (-1);
6498 }
6499
6500 if (remove_timer < 1)
6501 {
6502 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6503
6504 return (-1);
6505 }
6506 }
6507
6508 if (loopback == 1)
6509 {
6510 if (attack_mode == ATTACK_MODE_STRAIGHT)
6511 {
6512 if ((rp_files_cnt == 0) && (rp_gen == 0))
6513 {
6514 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6515
6516 return (-1);
6517 }
6518 }
6519 else
6520 {
6521 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6522
6523 return (-1);
6524 }
6525 }
6526
6527 if (debug_mode > 0)
6528 {
6529 if (attack_mode != ATTACK_MODE_STRAIGHT)
6530 {
6531 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6532
6533 return (-1);
6534 }
6535
6536 if ((rp_files_cnt == 0) && (rp_gen == 0))
6537 {
6538 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6539
6540 return (-1);
6541 }
6542 }
6543
6544 if (debug_mode > 4)
6545 {
6546 log_error ("ERROR: Invalid debug-mode specified");
6547
6548 return (-1);
6549 }
6550
6551 if (debug_file != NULL)
6552 {
6553 if (debug_mode < 1)
6554 {
6555 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6556
6557 return (-1);
6558 }
6559 }
6560
6561 if (induction_dir != NULL)
6562 {
6563 if (attack_mode == ATTACK_MODE_BF)
6564 {
6565 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6566
6567 return (-1);
6568 }
6569 }
6570
6571 if (attack_mode != ATTACK_MODE_STRAIGHT)
6572 {
6573 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6574 {
6575 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6576
6577 return (-1);
6578 }
6579
6580 weak_hash_threshold = 0;
6581 }
6582
6583 /**
6584 * induction directory
6585 */
6586
6587 char *induction_directory = NULL;
6588
6589 if (attack_mode != ATTACK_MODE_BF)
6590 {
6591 if (induction_dir == NULL)
6592 {
6593 induction_directory = (char *) mymalloc (session_size);
6594
6595 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6596
6597 // create induction folder if it does not already exist
6598
6599 if (keyspace == 0)
6600 {
6601 if (rmdir (induction_directory) == -1)
6602 {
6603 if (errno == ENOENT)
6604 {
6605 // good, we can ignore
6606 }
6607 else if (errno == ENOTEMPTY)
6608 {
6609 char *induction_directory_mv = (char *) mymalloc (session_size);
6610
6611 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6612
6613 if (rename (induction_directory, induction_directory_mv) != 0)
6614 {
6615 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6616
6617 return (-1);
6618 }
6619 }
6620 else
6621 {
6622 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6623
6624 return (-1);
6625 }
6626 }
6627
6628 if (mkdir (induction_directory, 0700) == -1)
6629 {
6630 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6631
6632 return (-1);
6633 }
6634 }
6635 }
6636 else
6637 {
6638 induction_directory = induction_dir;
6639 }
6640 }
6641
6642 data.induction_directory = induction_directory;
6643
6644 /**
6645 * loopback
6646 */
6647
6648 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6649
6650 char *loopback_file = (char *) mymalloc (loopback_size);
6651
6652 /**
6653 * tuning db
6654 */
6655
6656 char tuning_db_file[256] = { 0 };
6657
6658 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6659
6660 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6661
6662 /**
6663 * outfile-check directory
6664 */
6665
6666 char *outfile_check_directory = NULL;
6667
6668 if (outfile_check_dir == NULL)
6669 {
6670 outfile_check_directory = (char *) mymalloc (session_size);
6671
6672 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6673 }
6674 else
6675 {
6676 outfile_check_directory = outfile_check_dir;
6677 }
6678
6679 data.outfile_check_directory = outfile_check_directory;
6680
6681 if (keyspace == 0)
6682 {
6683 struct stat outfile_check_stat;
6684
6685 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6686 {
6687 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6688
6689 if (is_dir == 0)
6690 {
6691 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6692
6693 return (-1);
6694 }
6695 }
6696 else if (outfile_check_dir == NULL)
6697 {
6698 if (mkdir (outfile_check_directory, 0700) == -1)
6699 {
6700 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6701
6702 return (-1);
6703 }
6704 }
6705 }
6706
6707 /**
6708 * special other stuff
6709 */
6710
6711 if (hash_mode == 9710)
6712 {
6713 outfile_format = 5;
6714 outfile_format_chgd = 1;
6715 }
6716
6717 if (hash_mode == 9810)
6718 {
6719 outfile_format = 5;
6720 outfile_format_chgd = 1;
6721 }
6722
6723 if (hash_mode == 10410)
6724 {
6725 outfile_format = 5;
6726 outfile_format_chgd = 1;
6727 }
6728
6729 /**
6730 * store stuff
6731 */
6732
6733 data.hash_mode = hash_mode;
6734 data.restore = restore;
6735 data.restore_timer = restore_timer;
6736 data.restore_disable = restore_disable;
6737 data.status = status;
6738 data.status_timer = status_timer;
6739 data.machine_readable = machine_readable;
6740 data.loopback = loopback;
6741 data.runtime = runtime;
6742 data.remove = remove;
6743 data.remove_timer = remove_timer;
6744 data.debug_mode = debug_mode;
6745 data.debug_file = debug_file;
6746 data.username = username;
6747 data.quiet = quiet;
6748 data.outfile = outfile;
6749 data.outfile_format = outfile_format;
6750 data.outfile_autohex = outfile_autohex;
6751 data.hex_charset = hex_charset;
6752 data.hex_salt = hex_salt;
6753 data.hex_wordlist = hex_wordlist;
6754 data.separator = separator;
6755 data.rp_files = rp_files;
6756 data.rp_files_cnt = rp_files_cnt;
6757 data.rp_gen = rp_gen;
6758 data.rp_gen_seed = rp_gen_seed;
6759 data.force = force;
6760 data.benchmark = benchmark;
6761 data.skip = skip;
6762 data.limit = limit;
6763 #ifdef HAVE_HWMON
6764 data.powertune_enable = powertune_enable;
6765 #endif
6766 data.logfile_disable = logfile_disable;
6767 data.truecrypt_keyfiles = truecrypt_keyfiles;
6768 data.veracrypt_keyfiles = veracrypt_keyfiles;
6769 data.veracrypt_pim = veracrypt_pim;
6770 data.scrypt_tmto = scrypt_tmto;
6771 data.workload_profile = workload_profile;
6772
6773 /**
6774 * cpu affinity
6775 */
6776
6777 if (cpu_affinity)
6778 {
6779 set_cpu_affinity (cpu_affinity);
6780 }
6781
6782 if (rp_gen_seed_chgd == 0)
6783 {
6784 srand (proc_start);
6785 }
6786 else
6787 {
6788 srand (rp_gen_seed);
6789 }
6790
6791 /**
6792 * logfile init
6793 */
6794
6795 if (logfile_disable == 0)
6796 {
6797 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6798
6799 char *logfile = (char *) mymalloc (logfile_size);
6800
6801 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6802
6803 data.logfile = logfile;
6804
6805 char *topid = logfile_generate_topid ();
6806
6807 data.topid = topid;
6808 }
6809
6810 // logfile_append() checks for logfile_disable internally to make it easier from here
6811
6812 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6813 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6814 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6815 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6816 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6817 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6818 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6819 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6820 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6821 #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));
6822
6823 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6824 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6825 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6826 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6827 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6828 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6829 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6830 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6831
6832 logfile_top_msg ("START");
6833
6834 logfile_top_uint (attack_mode);
6835 logfile_top_uint (attack_kern);
6836 logfile_top_uint (benchmark);
6837 logfile_top_uint (bitmap_min);
6838 logfile_top_uint (bitmap_max);
6839 logfile_top_uint (debug_mode);
6840 logfile_top_uint (force);
6841 logfile_top_uint (kernel_accel);
6842 logfile_top_uint (kernel_loops);
6843 logfile_top_uint (gpu_temp_disable);
6844 #ifdef HAVE_HWMON
6845 logfile_top_uint (gpu_temp_abort);
6846 logfile_top_uint (gpu_temp_retain);
6847 #endif
6848 logfile_top_uint (hash_mode);
6849 logfile_top_uint (hex_charset);
6850 logfile_top_uint (hex_salt);
6851 logfile_top_uint (hex_wordlist);
6852 logfile_top_uint (increment);
6853 logfile_top_uint (increment_max);
6854 logfile_top_uint (increment_min);
6855 logfile_top_uint (keyspace);
6856 logfile_top_uint (left);
6857 logfile_top_uint (logfile_disable);
6858 logfile_top_uint (loopback);
6859 logfile_top_uint (markov_classic);
6860 logfile_top_uint (markov_disable);
6861 logfile_top_uint (markov_threshold);
6862 logfile_top_uint (outfile_autohex);
6863 logfile_top_uint (outfile_check_timer);
6864 logfile_top_uint (outfile_format);
6865 logfile_top_uint (potfile_disable);
6866 logfile_top_string (potfile_path);
6867 #if defined(HAVE_HWMON)
6868 logfile_top_uint (powertune_enable);
6869 #endif
6870 logfile_top_uint (scrypt_tmto);
6871 logfile_top_uint (quiet);
6872 logfile_top_uint (remove);
6873 logfile_top_uint (remove_timer);
6874 logfile_top_uint (restore);
6875 logfile_top_uint (restore_disable);
6876 logfile_top_uint (restore_timer);
6877 logfile_top_uint (rp_gen);
6878 logfile_top_uint (rp_gen_func_max);
6879 logfile_top_uint (rp_gen_func_min);
6880 logfile_top_uint (rp_gen_seed);
6881 logfile_top_uint (runtime);
6882 logfile_top_uint (segment_size);
6883 logfile_top_uint (show);
6884 logfile_top_uint (status);
6885 logfile_top_uint (machine_readable);
6886 logfile_top_uint (status_timer);
6887 logfile_top_uint (usage);
6888 logfile_top_uint (username);
6889 logfile_top_uint (version);
6890 logfile_top_uint (weak_hash_threshold);
6891 logfile_top_uint (workload_profile);
6892 logfile_top_uint64 (limit);
6893 logfile_top_uint64 (skip);
6894 logfile_top_char (separator);
6895 logfile_top_string (cpu_affinity);
6896 logfile_top_string (custom_charset_1);
6897 logfile_top_string (custom_charset_2);
6898 logfile_top_string (custom_charset_3);
6899 logfile_top_string (custom_charset_4);
6900 logfile_top_string (debug_file);
6901 logfile_top_string (opencl_devices);
6902 logfile_top_string (opencl_platforms);
6903 logfile_top_string (opencl_device_types);
6904 logfile_top_uint (opencl_vector_width);
6905 logfile_top_string (induction_dir);
6906 logfile_top_string (markov_hcstat);
6907 logfile_top_string (outfile);
6908 logfile_top_string (outfile_check_dir);
6909 logfile_top_string (rule_buf_l);
6910 logfile_top_string (rule_buf_r);
6911 logfile_top_string (session);
6912 logfile_top_string (truecrypt_keyfiles);
6913 logfile_top_string (veracrypt_keyfiles);
6914 logfile_top_uint (veracrypt_pim);
6915
6916 /**
6917 * Init OpenCL library loader
6918 */
6919
6920 if (keyspace == 0)
6921 {
6922 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6923
6924 ocl_init (ocl);
6925
6926 data.ocl = ocl;
6927 }
6928
6929 /**
6930 * OpenCL platform selection
6931 */
6932
6933 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6934
6935 /**
6936 * OpenCL device selection
6937 */
6938
6939 u32 devices_filter = setup_devices_filter (opencl_devices);
6940
6941 /**
6942 * OpenCL device type selection
6943 */
6944
6945 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6946
6947 /**
6948 * benchmark
6949 */
6950
6951 if (benchmark == 1)
6952 {
6953 /**
6954 * disable useless stuff for benchmark
6955 */
6956
6957 status_timer = 0;
6958 restore_timer = 0;
6959 restore_disable = 1;
6960 potfile_disable = 1;
6961 weak_hash_threshold = 0;
6962 gpu_temp_disable = 1;
6963
6964 #ifdef HAVE_HWMON
6965 if (powertune_enable == 1)
6966 {
6967 gpu_temp_disable = 0;
6968 }
6969 #endif
6970
6971 data.status_timer = status_timer;
6972 data.restore_timer = restore_timer;
6973 data.restore_disable = restore_disable;
6974
6975 /**
6976 * force attack mode to be bruteforce
6977 */
6978
6979 attack_mode = ATTACK_MODE_BF;
6980 attack_kern = ATTACK_KERN_BF;
6981
6982 if (workload_profile_chgd == 0)
6983 {
6984 workload_profile = 3;
6985
6986 data.workload_profile = workload_profile;
6987 }
6988 }
6989
6990 /**
6991 * config
6992 */
6993
6994 uint hash_type = 0;
6995 uint salt_type = 0;
6996 uint attack_exec = 0;
6997 uint opts_type = 0;
6998 uint kern_type = 0;
6999 uint dgst_size = 0;
7000 uint esalt_size = 0;
7001 uint opti_type = 0;
7002 uint dgst_pos0 = -1;
7003 uint dgst_pos1 = -1;
7004 uint dgst_pos2 = -1;
7005 uint dgst_pos3 = -1;
7006
7007 int (*parse_func) (char *, uint, hash_t *);
7008 int (*sort_by_digest) (const void *, const void *);
7009
7010 uint algorithm_pos = 0;
7011 uint algorithm_max = 1;
7012
7013 uint *algorithms = default_benchmark_algorithms;
7014
7015 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7016
7017 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7018 {
7019 /*
7020 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7021 * the following algos are skipped entirely
7022 */
7023
7024 if (algorithm_pos > 0)
7025 {
7026 local_free (rd);
7027
7028 rd = init_restore (argc, argv);
7029
7030 data.rd = rd;
7031 }
7032
7033 /**
7034 * update hash_mode in case of multihash benchmark
7035 */
7036
7037 if (benchmark == 1)
7038 {
7039 if (hash_mode_chgd == 0)
7040 {
7041 hash_mode = algorithms[algorithm_pos];
7042
7043 data.hash_mode = hash_mode;
7044 }
7045
7046 quiet = 1;
7047
7048 data.quiet = quiet;
7049 }
7050
7051 switch (hash_mode)
7052 {
7053 case 0: hash_type = HASH_TYPE_MD5;
7054 salt_type = SALT_TYPE_NONE;
7055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7056 opts_type = OPTS_TYPE_PT_GENERATE_LE
7057 | OPTS_TYPE_PT_ADD80
7058 | OPTS_TYPE_PT_ADDBITS14;
7059 kern_type = KERN_TYPE_MD5;
7060 dgst_size = DGST_SIZE_4_4;
7061 parse_func = md5_parse_hash;
7062 sort_by_digest = sort_by_digest_4_4;
7063 opti_type = OPTI_TYPE_ZERO_BYTE
7064 | OPTI_TYPE_PRECOMPUTE_INIT
7065 | OPTI_TYPE_PRECOMPUTE_MERKLE
7066 | OPTI_TYPE_MEET_IN_MIDDLE
7067 | OPTI_TYPE_EARLY_SKIP
7068 | OPTI_TYPE_NOT_ITERATED
7069 | OPTI_TYPE_NOT_SALTED
7070 | OPTI_TYPE_RAW_HASH;
7071 dgst_pos0 = 0;
7072 dgst_pos1 = 3;
7073 dgst_pos2 = 2;
7074 dgst_pos3 = 1;
7075 break;
7076
7077 case 10: hash_type = HASH_TYPE_MD5;
7078 salt_type = SALT_TYPE_INTERN;
7079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7080 opts_type = OPTS_TYPE_PT_GENERATE_LE
7081 | OPTS_TYPE_ST_ADD80
7082 | OPTS_TYPE_ST_ADDBITS14;
7083 kern_type = KERN_TYPE_MD5_PWSLT;
7084 dgst_size = DGST_SIZE_4_4;
7085 parse_func = md5s_parse_hash;
7086 sort_by_digest = sort_by_digest_4_4;
7087 opti_type = OPTI_TYPE_ZERO_BYTE
7088 | OPTI_TYPE_PRECOMPUTE_INIT
7089 | OPTI_TYPE_PRECOMPUTE_MERKLE
7090 | OPTI_TYPE_MEET_IN_MIDDLE
7091 | OPTI_TYPE_EARLY_SKIP
7092 | OPTI_TYPE_NOT_ITERATED
7093 | OPTI_TYPE_APPENDED_SALT
7094 | OPTI_TYPE_RAW_HASH;
7095 dgst_pos0 = 0;
7096 dgst_pos1 = 3;
7097 dgst_pos2 = 2;
7098 dgst_pos3 = 1;
7099 break;
7100
7101 case 11: hash_type = HASH_TYPE_MD5;
7102 salt_type = SALT_TYPE_INTERN;
7103 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7104 opts_type = OPTS_TYPE_PT_GENERATE_LE
7105 | OPTS_TYPE_ST_ADD80
7106 | OPTS_TYPE_ST_ADDBITS14;
7107 kern_type = KERN_TYPE_MD5_PWSLT;
7108 dgst_size = DGST_SIZE_4_4;
7109 parse_func = joomla_parse_hash;
7110 sort_by_digest = sort_by_digest_4_4;
7111 opti_type = OPTI_TYPE_ZERO_BYTE
7112 | OPTI_TYPE_PRECOMPUTE_INIT
7113 | OPTI_TYPE_PRECOMPUTE_MERKLE
7114 | OPTI_TYPE_MEET_IN_MIDDLE
7115 | OPTI_TYPE_EARLY_SKIP
7116 | OPTI_TYPE_NOT_ITERATED
7117 | OPTI_TYPE_APPENDED_SALT
7118 | OPTI_TYPE_RAW_HASH;
7119 dgst_pos0 = 0;
7120 dgst_pos1 = 3;
7121 dgst_pos2 = 2;
7122 dgst_pos3 = 1;
7123 break;
7124
7125 case 12: hash_type = HASH_TYPE_MD5;
7126 salt_type = SALT_TYPE_INTERN;
7127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7128 opts_type = OPTS_TYPE_PT_GENERATE_LE
7129 | OPTS_TYPE_ST_ADD80
7130 | OPTS_TYPE_ST_ADDBITS14;
7131 kern_type = KERN_TYPE_MD5_PWSLT;
7132 dgst_size = DGST_SIZE_4_4;
7133 parse_func = postgresql_parse_hash;
7134 sort_by_digest = sort_by_digest_4_4;
7135 opti_type = OPTI_TYPE_ZERO_BYTE
7136 | OPTI_TYPE_PRECOMPUTE_INIT
7137 | OPTI_TYPE_PRECOMPUTE_MERKLE
7138 | OPTI_TYPE_MEET_IN_MIDDLE
7139 | OPTI_TYPE_EARLY_SKIP
7140 | OPTI_TYPE_NOT_ITERATED
7141 | OPTI_TYPE_APPENDED_SALT
7142 | OPTI_TYPE_RAW_HASH;
7143 dgst_pos0 = 0;
7144 dgst_pos1 = 3;
7145 dgst_pos2 = 2;
7146 dgst_pos3 = 1;
7147 break;
7148
7149 case 20: hash_type = HASH_TYPE_MD5;
7150 salt_type = SALT_TYPE_INTERN;
7151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7152 opts_type = OPTS_TYPE_PT_GENERATE_LE
7153 | OPTS_TYPE_PT_ADD80
7154 | OPTS_TYPE_PT_ADDBITS14;
7155 kern_type = KERN_TYPE_MD5_SLTPW;
7156 dgst_size = DGST_SIZE_4_4;
7157 parse_func = md5s_parse_hash;
7158 sort_by_digest = sort_by_digest_4_4;
7159 opti_type = OPTI_TYPE_ZERO_BYTE
7160 | OPTI_TYPE_PRECOMPUTE_INIT
7161 | OPTI_TYPE_PRECOMPUTE_MERKLE
7162 | OPTI_TYPE_EARLY_SKIP
7163 | OPTI_TYPE_NOT_ITERATED
7164 | OPTI_TYPE_PREPENDED_SALT
7165 | OPTI_TYPE_RAW_HASH;
7166 dgst_pos0 = 0;
7167 dgst_pos1 = 3;
7168 dgst_pos2 = 2;
7169 dgst_pos3 = 1;
7170 break;
7171
7172 case 21: hash_type = HASH_TYPE_MD5;
7173 salt_type = SALT_TYPE_INTERN;
7174 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7175 opts_type = OPTS_TYPE_PT_GENERATE_LE
7176 | OPTS_TYPE_PT_ADD80
7177 | OPTS_TYPE_PT_ADDBITS14;
7178 kern_type = KERN_TYPE_MD5_SLTPW;
7179 dgst_size = DGST_SIZE_4_4;
7180 parse_func = osc_parse_hash;
7181 sort_by_digest = sort_by_digest_4_4;
7182 opti_type = OPTI_TYPE_ZERO_BYTE
7183 | OPTI_TYPE_PRECOMPUTE_INIT
7184 | OPTI_TYPE_PRECOMPUTE_MERKLE
7185 | OPTI_TYPE_EARLY_SKIP
7186 | OPTI_TYPE_NOT_ITERATED
7187 | OPTI_TYPE_PREPENDED_SALT
7188 | OPTI_TYPE_RAW_HASH;
7189 dgst_pos0 = 0;
7190 dgst_pos1 = 3;
7191 dgst_pos2 = 2;
7192 dgst_pos3 = 1;
7193 break;
7194
7195 case 22: hash_type = HASH_TYPE_MD5;
7196 salt_type = SALT_TYPE_EMBEDDED;
7197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7198 opts_type = OPTS_TYPE_PT_GENERATE_LE
7199 | OPTS_TYPE_PT_ADD80
7200 | OPTS_TYPE_PT_ADDBITS14;
7201 kern_type = KERN_TYPE_MD5_SLTPW;
7202 dgst_size = DGST_SIZE_4_4;
7203 parse_func = netscreen_parse_hash;
7204 sort_by_digest = sort_by_digest_4_4;
7205 opti_type = OPTI_TYPE_ZERO_BYTE
7206 | OPTI_TYPE_PRECOMPUTE_INIT
7207 | OPTI_TYPE_PRECOMPUTE_MERKLE
7208 | OPTI_TYPE_EARLY_SKIP
7209 | OPTI_TYPE_NOT_ITERATED
7210 | OPTI_TYPE_PREPENDED_SALT
7211 | OPTI_TYPE_RAW_HASH;
7212 dgst_pos0 = 0;
7213 dgst_pos1 = 3;
7214 dgst_pos2 = 2;
7215 dgst_pos3 = 1;
7216 break;
7217
7218 case 23: hash_type = HASH_TYPE_MD5;
7219 salt_type = SALT_TYPE_EMBEDDED;
7220 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7221 opts_type = OPTS_TYPE_PT_GENERATE_LE
7222 | OPTS_TYPE_PT_ADD80
7223 | OPTS_TYPE_PT_ADDBITS14;
7224 kern_type = KERN_TYPE_MD5_SLTPW;
7225 dgst_size = DGST_SIZE_4_4;
7226 parse_func = skype_parse_hash;
7227 sort_by_digest = sort_by_digest_4_4;
7228 opti_type = OPTI_TYPE_ZERO_BYTE
7229 | OPTI_TYPE_PRECOMPUTE_INIT
7230 | OPTI_TYPE_PRECOMPUTE_MERKLE
7231 | OPTI_TYPE_EARLY_SKIP
7232 | OPTI_TYPE_NOT_ITERATED
7233 | OPTI_TYPE_PREPENDED_SALT
7234 | OPTI_TYPE_RAW_HASH;
7235 dgst_pos0 = 0;
7236 dgst_pos1 = 3;
7237 dgst_pos2 = 2;
7238 dgst_pos3 = 1;
7239 break;
7240
7241 case 30: hash_type = HASH_TYPE_MD5;
7242 salt_type = SALT_TYPE_INTERN;
7243 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7244 opts_type = OPTS_TYPE_PT_GENERATE_LE
7245 | OPTS_TYPE_PT_UNICODE
7246 | OPTS_TYPE_ST_ADD80
7247 | OPTS_TYPE_ST_ADDBITS14;
7248 kern_type = KERN_TYPE_MD5_PWUSLT;
7249 dgst_size = DGST_SIZE_4_4;
7250 parse_func = md5s_parse_hash;
7251 sort_by_digest = sort_by_digest_4_4;
7252 opti_type = OPTI_TYPE_ZERO_BYTE
7253 | OPTI_TYPE_PRECOMPUTE_INIT
7254 | OPTI_TYPE_PRECOMPUTE_MERKLE
7255 | OPTI_TYPE_MEET_IN_MIDDLE
7256 | OPTI_TYPE_EARLY_SKIP
7257 | OPTI_TYPE_NOT_ITERATED
7258 | OPTI_TYPE_APPENDED_SALT
7259 | OPTI_TYPE_RAW_HASH;
7260 dgst_pos0 = 0;
7261 dgst_pos1 = 3;
7262 dgst_pos2 = 2;
7263 dgst_pos3 = 1;
7264 break;
7265
7266 case 40: hash_type = HASH_TYPE_MD5;
7267 salt_type = SALT_TYPE_INTERN;
7268 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7269 opts_type = OPTS_TYPE_PT_GENERATE_LE
7270 | OPTS_TYPE_PT_ADD80
7271 | OPTS_TYPE_PT_ADDBITS14
7272 | OPTS_TYPE_PT_UNICODE;
7273 kern_type = KERN_TYPE_MD5_SLTPWU;
7274 dgst_size = DGST_SIZE_4_4;
7275 parse_func = md5s_parse_hash;
7276 sort_by_digest = sort_by_digest_4_4;
7277 opti_type = OPTI_TYPE_ZERO_BYTE
7278 | OPTI_TYPE_PRECOMPUTE_INIT
7279 | OPTI_TYPE_PRECOMPUTE_MERKLE
7280 | OPTI_TYPE_EARLY_SKIP
7281 | OPTI_TYPE_NOT_ITERATED
7282 | OPTI_TYPE_PREPENDED_SALT
7283 | OPTI_TYPE_RAW_HASH;
7284 dgst_pos0 = 0;
7285 dgst_pos1 = 3;
7286 dgst_pos2 = 2;
7287 dgst_pos3 = 1;
7288 break;
7289
7290 case 50: hash_type = HASH_TYPE_MD5;
7291 salt_type = SALT_TYPE_INTERN;
7292 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7293 opts_type = OPTS_TYPE_PT_GENERATE_LE
7294 | OPTS_TYPE_ST_ADD80
7295 | OPTS_TYPE_ST_ADDBITS14;
7296 kern_type = KERN_TYPE_HMACMD5_PW;
7297 dgst_size = DGST_SIZE_4_4;
7298 parse_func = hmacmd5_parse_hash;
7299 sort_by_digest = sort_by_digest_4_4;
7300 opti_type = OPTI_TYPE_ZERO_BYTE
7301 | OPTI_TYPE_NOT_ITERATED;
7302 dgst_pos0 = 0;
7303 dgst_pos1 = 3;
7304 dgst_pos2 = 2;
7305 dgst_pos3 = 1;
7306 break;
7307
7308 case 60: hash_type = HASH_TYPE_MD5;
7309 salt_type = SALT_TYPE_INTERN;
7310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7311 opts_type = OPTS_TYPE_PT_GENERATE_LE
7312 | OPTS_TYPE_PT_ADD80
7313 | OPTS_TYPE_PT_ADDBITS14;
7314 kern_type = KERN_TYPE_HMACMD5_SLT;
7315 dgst_size = DGST_SIZE_4_4;
7316 parse_func = hmacmd5_parse_hash;
7317 sort_by_digest = sort_by_digest_4_4;
7318 opti_type = OPTI_TYPE_ZERO_BYTE
7319 | OPTI_TYPE_NOT_ITERATED;
7320 dgst_pos0 = 0;
7321 dgst_pos1 = 3;
7322 dgst_pos2 = 2;
7323 dgst_pos3 = 1;
7324 break;
7325
7326 case 100: hash_type = HASH_TYPE_SHA1;
7327 salt_type = SALT_TYPE_NONE;
7328 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7329 opts_type = OPTS_TYPE_PT_GENERATE_BE
7330 | OPTS_TYPE_PT_ADD80
7331 | OPTS_TYPE_PT_ADDBITS15;
7332 kern_type = KERN_TYPE_SHA1;
7333 dgst_size = DGST_SIZE_4_5;
7334 parse_func = sha1_parse_hash;
7335 sort_by_digest = sort_by_digest_4_5;
7336 opti_type = OPTI_TYPE_ZERO_BYTE
7337 | OPTI_TYPE_PRECOMPUTE_INIT
7338 | OPTI_TYPE_PRECOMPUTE_MERKLE
7339 | OPTI_TYPE_EARLY_SKIP
7340 | OPTI_TYPE_NOT_ITERATED
7341 | OPTI_TYPE_NOT_SALTED
7342 | OPTI_TYPE_RAW_HASH;
7343 dgst_pos0 = 3;
7344 dgst_pos1 = 4;
7345 dgst_pos2 = 2;
7346 dgst_pos3 = 1;
7347 break;
7348
7349 case 101: hash_type = HASH_TYPE_SHA1;
7350 salt_type = SALT_TYPE_NONE;
7351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7352 opts_type = OPTS_TYPE_PT_GENERATE_BE
7353 | OPTS_TYPE_PT_ADD80
7354 | OPTS_TYPE_PT_ADDBITS15;
7355 kern_type = KERN_TYPE_SHA1;
7356 dgst_size = DGST_SIZE_4_5;
7357 parse_func = sha1b64_parse_hash;
7358 sort_by_digest = sort_by_digest_4_5;
7359 opti_type = OPTI_TYPE_ZERO_BYTE
7360 | OPTI_TYPE_PRECOMPUTE_INIT
7361 | OPTI_TYPE_PRECOMPUTE_MERKLE
7362 | OPTI_TYPE_EARLY_SKIP
7363 | OPTI_TYPE_NOT_ITERATED
7364 | OPTI_TYPE_NOT_SALTED
7365 | OPTI_TYPE_RAW_HASH;
7366 dgst_pos0 = 3;
7367 dgst_pos1 = 4;
7368 dgst_pos2 = 2;
7369 dgst_pos3 = 1;
7370 break;
7371
7372 case 110: hash_type = HASH_TYPE_SHA1;
7373 salt_type = SALT_TYPE_INTERN;
7374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7375 opts_type = OPTS_TYPE_PT_GENERATE_BE
7376 | OPTS_TYPE_ST_ADD80
7377 | OPTS_TYPE_ST_ADDBITS15;
7378 kern_type = KERN_TYPE_SHA1_PWSLT;
7379 dgst_size = DGST_SIZE_4_5;
7380 parse_func = sha1s_parse_hash;
7381 sort_by_digest = sort_by_digest_4_5;
7382 opti_type = OPTI_TYPE_ZERO_BYTE
7383 | OPTI_TYPE_PRECOMPUTE_INIT
7384 | OPTI_TYPE_PRECOMPUTE_MERKLE
7385 | OPTI_TYPE_EARLY_SKIP
7386 | OPTI_TYPE_NOT_ITERATED
7387 | OPTI_TYPE_APPENDED_SALT
7388 | OPTI_TYPE_RAW_HASH;
7389 dgst_pos0 = 3;
7390 dgst_pos1 = 4;
7391 dgst_pos2 = 2;
7392 dgst_pos3 = 1;
7393 break;
7394
7395 case 111: hash_type = HASH_TYPE_SHA1;
7396 salt_type = SALT_TYPE_EMBEDDED;
7397 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7398 opts_type = OPTS_TYPE_PT_GENERATE_BE
7399 | OPTS_TYPE_ST_ADD80
7400 | OPTS_TYPE_ST_ADDBITS15;
7401 kern_type = KERN_TYPE_SHA1_PWSLT;
7402 dgst_size = DGST_SIZE_4_5;
7403 parse_func = sha1b64s_parse_hash;
7404 sort_by_digest = sort_by_digest_4_5;
7405 opti_type = OPTI_TYPE_ZERO_BYTE
7406 | OPTI_TYPE_PRECOMPUTE_INIT
7407 | OPTI_TYPE_PRECOMPUTE_MERKLE
7408 | OPTI_TYPE_EARLY_SKIP
7409 | OPTI_TYPE_NOT_ITERATED
7410 | OPTI_TYPE_APPENDED_SALT
7411 | OPTI_TYPE_RAW_HASH;
7412 dgst_pos0 = 3;
7413 dgst_pos1 = 4;
7414 dgst_pos2 = 2;
7415 dgst_pos3 = 1;
7416 break;
7417
7418 case 112: hash_type = HASH_TYPE_SHA1;
7419 salt_type = SALT_TYPE_INTERN;
7420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7421 opts_type = OPTS_TYPE_PT_GENERATE_BE
7422 | OPTS_TYPE_ST_ADD80
7423 | OPTS_TYPE_ST_ADDBITS15
7424 | OPTS_TYPE_ST_HEX;
7425 kern_type = KERN_TYPE_SHA1_PWSLT;
7426 dgst_size = DGST_SIZE_4_5;
7427 parse_func = oracles_parse_hash;
7428 sort_by_digest = sort_by_digest_4_5;
7429 opti_type = OPTI_TYPE_ZERO_BYTE
7430 | OPTI_TYPE_PRECOMPUTE_INIT
7431 | OPTI_TYPE_PRECOMPUTE_MERKLE
7432 | OPTI_TYPE_EARLY_SKIP
7433 | OPTI_TYPE_NOT_ITERATED
7434 | OPTI_TYPE_APPENDED_SALT
7435 | OPTI_TYPE_RAW_HASH;
7436 dgst_pos0 = 3;
7437 dgst_pos1 = 4;
7438 dgst_pos2 = 2;
7439 dgst_pos3 = 1;
7440 break;
7441
7442 case 120: hash_type = HASH_TYPE_SHA1;
7443 salt_type = SALT_TYPE_INTERN;
7444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7445 opts_type = OPTS_TYPE_PT_GENERATE_BE
7446 | OPTS_TYPE_PT_ADD80
7447 | OPTS_TYPE_PT_ADDBITS15;
7448 kern_type = KERN_TYPE_SHA1_SLTPW;
7449 dgst_size = DGST_SIZE_4_5;
7450 parse_func = sha1s_parse_hash;
7451 sort_by_digest = sort_by_digest_4_5;
7452 opti_type = OPTI_TYPE_ZERO_BYTE
7453 | OPTI_TYPE_PRECOMPUTE_INIT
7454 | OPTI_TYPE_PRECOMPUTE_MERKLE
7455 | OPTI_TYPE_EARLY_SKIP
7456 | OPTI_TYPE_NOT_ITERATED
7457 | OPTI_TYPE_PREPENDED_SALT
7458 | OPTI_TYPE_RAW_HASH;
7459 dgst_pos0 = 3;
7460 dgst_pos1 = 4;
7461 dgst_pos2 = 2;
7462 dgst_pos3 = 1;
7463 break;
7464
7465 case 121: hash_type = HASH_TYPE_SHA1;
7466 salt_type = SALT_TYPE_INTERN;
7467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7468 opts_type = OPTS_TYPE_PT_GENERATE_BE
7469 | OPTS_TYPE_PT_ADD80
7470 | OPTS_TYPE_PT_ADDBITS15
7471 | OPTS_TYPE_ST_LOWER;
7472 kern_type = KERN_TYPE_SHA1_SLTPW;
7473 dgst_size = DGST_SIZE_4_5;
7474 parse_func = smf_parse_hash;
7475 sort_by_digest = sort_by_digest_4_5;
7476 opti_type = OPTI_TYPE_ZERO_BYTE
7477 | OPTI_TYPE_PRECOMPUTE_INIT
7478 | OPTI_TYPE_PRECOMPUTE_MERKLE
7479 | OPTI_TYPE_EARLY_SKIP
7480 | OPTI_TYPE_NOT_ITERATED
7481 | OPTI_TYPE_PREPENDED_SALT
7482 | OPTI_TYPE_RAW_HASH;
7483 dgst_pos0 = 3;
7484 dgst_pos1 = 4;
7485 dgst_pos2 = 2;
7486 dgst_pos3 = 1;
7487 break;
7488
7489 case 122: hash_type = HASH_TYPE_SHA1;
7490 salt_type = SALT_TYPE_EMBEDDED;
7491 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7492 opts_type = OPTS_TYPE_PT_GENERATE_BE
7493 | OPTS_TYPE_PT_ADD80
7494 | OPTS_TYPE_PT_ADDBITS15
7495 | OPTS_TYPE_ST_HEX;
7496 kern_type = KERN_TYPE_SHA1_SLTPW;
7497 dgst_size = DGST_SIZE_4_5;
7498 parse_func = osx1_parse_hash;
7499 sort_by_digest = sort_by_digest_4_5;
7500 opti_type = OPTI_TYPE_ZERO_BYTE
7501 | OPTI_TYPE_PRECOMPUTE_INIT
7502 | OPTI_TYPE_PRECOMPUTE_MERKLE
7503 | OPTI_TYPE_EARLY_SKIP
7504 | OPTI_TYPE_NOT_ITERATED
7505 | OPTI_TYPE_PREPENDED_SALT
7506 | OPTI_TYPE_RAW_HASH;
7507 dgst_pos0 = 3;
7508 dgst_pos1 = 4;
7509 dgst_pos2 = 2;
7510 dgst_pos3 = 1;
7511 break;
7512
7513 case 124: hash_type = HASH_TYPE_SHA1;
7514 salt_type = SALT_TYPE_EMBEDDED;
7515 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7516 opts_type = OPTS_TYPE_PT_GENERATE_BE
7517 | OPTS_TYPE_PT_ADD80
7518 | OPTS_TYPE_PT_ADDBITS15;
7519 kern_type = KERN_TYPE_SHA1_SLTPW;
7520 dgst_size = DGST_SIZE_4_5;
7521 parse_func = djangosha1_parse_hash;
7522 sort_by_digest = sort_by_digest_4_5;
7523 opti_type = OPTI_TYPE_ZERO_BYTE
7524 | OPTI_TYPE_PRECOMPUTE_INIT
7525 | OPTI_TYPE_PRECOMPUTE_MERKLE
7526 | OPTI_TYPE_EARLY_SKIP
7527 | OPTI_TYPE_NOT_ITERATED
7528 | OPTI_TYPE_PREPENDED_SALT
7529 | OPTI_TYPE_RAW_HASH;
7530 dgst_pos0 = 3;
7531 dgst_pos1 = 4;
7532 dgst_pos2 = 2;
7533 dgst_pos3 = 1;
7534 break;
7535
7536 case 125: hash_type = HASH_TYPE_SHA1;
7537 salt_type = SALT_TYPE_EMBEDDED;
7538 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7539 opts_type = OPTS_TYPE_PT_GENERATE_BE
7540 | OPTS_TYPE_PT_ADD80
7541 | OPTS_TYPE_PT_ADDBITS15
7542 | OPTS_TYPE_ST_HEX;
7543 kern_type = KERN_TYPE_SHA1_SLTPW;
7544 dgst_size = DGST_SIZE_4_5;
7545 parse_func = arubaos_parse_hash;
7546 sort_by_digest = sort_by_digest_4_5;
7547 opti_type = OPTI_TYPE_ZERO_BYTE
7548 | OPTI_TYPE_PRECOMPUTE_INIT
7549 | OPTI_TYPE_PRECOMPUTE_MERKLE
7550 | OPTI_TYPE_EARLY_SKIP
7551 | OPTI_TYPE_NOT_ITERATED
7552 | OPTI_TYPE_PREPENDED_SALT
7553 | OPTI_TYPE_RAW_HASH;
7554 dgst_pos0 = 3;
7555 dgst_pos1 = 4;
7556 dgst_pos2 = 2;
7557 dgst_pos3 = 1;
7558 break;
7559
7560 case 130: hash_type = HASH_TYPE_SHA1;
7561 salt_type = SALT_TYPE_INTERN;
7562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7563 opts_type = OPTS_TYPE_PT_GENERATE_BE
7564 | OPTS_TYPE_PT_UNICODE
7565 | OPTS_TYPE_ST_ADD80
7566 | OPTS_TYPE_ST_ADDBITS15;
7567 kern_type = KERN_TYPE_SHA1_PWUSLT;
7568 dgst_size = DGST_SIZE_4_5;
7569 parse_func = sha1s_parse_hash;
7570 sort_by_digest = sort_by_digest_4_5;
7571 opti_type = OPTI_TYPE_ZERO_BYTE
7572 | OPTI_TYPE_PRECOMPUTE_INIT
7573 | OPTI_TYPE_PRECOMPUTE_MERKLE
7574 | OPTI_TYPE_EARLY_SKIP
7575 | OPTI_TYPE_NOT_ITERATED
7576 | OPTI_TYPE_APPENDED_SALT
7577 | OPTI_TYPE_RAW_HASH;
7578 dgst_pos0 = 3;
7579 dgst_pos1 = 4;
7580 dgst_pos2 = 2;
7581 dgst_pos3 = 1;
7582 break;
7583
7584 case 131: hash_type = HASH_TYPE_SHA1;
7585 salt_type = SALT_TYPE_EMBEDDED;
7586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7587 opts_type = OPTS_TYPE_PT_GENERATE_BE
7588 | OPTS_TYPE_PT_UNICODE
7589 | OPTS_TYPE_PT_UPPER
7590 | OPTS_TYPE_ST_ADD80
7591 | OPTS_TYPE_ST_ADDBITS15
7592 | OPTS_TYPE_ST_HEX;
7593 kern_type = KERN_TYPE_SHA1_PWUSLT;
7594 dgst_size = DGST_SIZE_4_5;
7595 parse_func = mssql2000_parse_hash;
7596 sort_by_digest = sort_by_digest_4_5;
7597 opti_type = OPTI_TYPE_ZERO_BYTE
7598 | OPTI_TYPE_PRECOMPUTE_INIT
7599 | OPTI_TYPE_PRECOMPUTE_MERKLE
7600 | OPTI_TYPE_EARLY_SKIP
7601 | OPTI_TYPE_NOT_ITERATED
7602 | OPTI_TYPE_APPENDED_SALT
7603 | OPTI_TYPE_RAW_HASH;
7604 dgst_pos0 = 3;
7605 dgst_pos1 = 4;
7606 dgst_pos2 = 2;
7607 dgst_pos3 = 1;
7608 break;
7609
7610 case 132: hash_type = HASH_TYPE_SHA1;
7611 salt_type = SALT_TYPE_EMBEDDED;
7612 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7613 opts_type = OPTS_TYPE_PT_GENERATE_BE
7614 | OPTS_TYPE_PT_UNICODE
7615 | OPTS_TYPE_ST_ADD80
7616 | OPTS_TYPE_ST_ADDBITS15
7617 | OPTS_TYPE_ST_HEX;
7618 kern_type = KERN_TYPE_SHA1_PWUSLT;
7619 dgst_size = DGST_SIZE_4_5;
7620 parse_func = mssql2005_parse_hash;
7621 sort_by_digest = sort_by_digest_4_5;
7622 opti_type = OPTI_TYPE_ZERO_BYTE
7623 | OPTI_TYPE_PRECOMPUTE_INIT
7624 | OPTI_TYPE_PRECOMPUTE_MERKLE
7625 | OPTI_TYPE_EARLY_SKIP
7626 | OPTI_TYPE_NOT_ITERATED
7627 | OPTI_TYPE_APPENDED_SALT
7628 | OPTI_TYPE_RAW_HASH;
7629 dgst_pos0 = 3;
7630 dgst_pos1 = 4;
7631 dgst_pos2 = 2;
7632 dgst_pos3 = 1;
7633 break;
7634
7635 case 133: hash_type = HASH_TYPE_SHA1;
7636 salt_type = SALT_TYPE_EMBEDDED;
7637 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7638 opts_type = OPTS_TYPE_PT_GENERATE_BE
7639 | OPTS_TYPE_PT_UNICODE
7640 | OPTS_TYPE_ST_ADD80
7641 | OPTS_TYPE_ST_ADDBITS15;
7642 kern_type = KERN_TYPE_SHA1_PWUSLT;
7643 dgst_size = DGST_SIZE_4_5;
7644 parse_func = peoplesoft_parse_hash;
7645 sort_by_digest = sort_by_digest_4_5;
7646 opti_type = OPTI_TYPE_ZERO_BYTE
7647 | OPTI_TYPE_PRECOMPUTE_INIT
7648 | OPTI_TYPE_PRECOMPUTE_MERKLE
7649 | OPTI_TYPE_EARLY_SKIP
7650 | OPTI_TYPE_NOT_ITERATED
7651 | OPTI_TYPE_APPENDED_SALT
7652 | OPTI_TYPE_RAW_HASH;
7653 dgst_pos0 = 3;
7654 dgst_pos1 = 4;
7655 dgst_pos2 = 2;
7656 dgst_pos3 = 1;
7657 break;
7658
7659 case 140: hash_type = HASH_TYPE_SHA1;
7660 salt_type = SALT_TYPE_INTERN;
7661 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7662 opts_type = OPTS_TYPE_PT_GENERATE_BE
7663 | OPTS_TYPE_PT_ADD80
7664 | OPTS_TYPE_PT_ADDBITS15
7665 | OPTS_TYPE_PT_UNICODE;
7666 kern_type = KERN_TYPE_SHA1_SLTPWU;
7667 dgst_size = DGST_SIZE_4_5;
7668 parse_func = sha1s_parse_hash;
7669 sort_by_digest = sort_by_digest_4_5;
7670 opti_type = OPTI_TYPE_ZERO_BYTE
7671 | OPTI_TYPE_PRECOMPUTE_INIT
7672 | OPTI_TYPE_PRECOMPUTE_MERKLE
7673 | OPTI_TYPE_EARLY_SKIP
7674 | OPTI_TYPE_NOT_ITERATED
7675 | OPTI_TYPE_PREPENDED_SALT
7676 | OPTI_TYPE_RAW_HASH;
7677 dgst_pos0 = 3;
7678 dgst_pos1 = 4;
7679 dgst_pos2 = 2;
7680 dgst_pos3 = 1;
7681 break;
7682
7683 case 141: hash_type = HASH_TYPE_SHA1;
7684 salt_type = SALT_TYPE_EMBEDDED;
7685 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7686 opts_type = OPTS_TYPE_PT_GENERATE_BE
7687 | OPTS_TYPE_PT_ADD80
7688 | OPTS_TYPE_PT_ADDBITS15
7689 | OPTS_TYPE_PT_UNICODE
7690 | OPTS_TYPE_ST_BASE64;
7691 kern_type = KERN_TYPE_SHA1_SLTPWU;
7692 dgst_size = DGST_SIZE_4_5;
7693 parse_func = episerver_parse_hash;
7694 sort_by_digest = sort_by_digest_4_5;
7695 opti_type = OPTI_TYPE_ZERO_BYTE
7696 | OPTI_TYPE_PRECOMPUTE_INIT
7697 | OPTI_TYPE_PRECOMPUTE_MERKLE
7698 | OPTI_TYPE_EARLY_SKIP
7699 | OPTI_TYPE_NOT_ITERATED
7700 | OPTI_TYPE_PREPENDED_SALT
7701 | OPTI_TYPE_RAW_HASH;
7702 dgst_pos0 = 3;
7703 dgst_pos1 = 4;
7704 dgst_pos2 = 2;
7705 dgst_pos3 = 1;
7706 break;
7707
7708 case 150: hash_type = HASH_TYPE_SHA1;
7709 salt_type = SALT_TYPE_INTERN;
7710 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7711 opts_type = OPTS_TYPE_PT_GENERATE_BE
7712 | OPTS_TYPE_ST_ADD80
7713 | OPTS_TYPE_ST_ADDBITS15;
7714 kern_type = KERN_TYPE_HMACSHA1_PW;
7715 dgst_size = DGST_SIZE_4_5;
7716 parse_func = hmacsha1_parse_hash;
7717 sort_by_digest = sort_by_digest_4_5;
7718 opti_type = OPTI_TYPE_ZERO_BYTE
7719 | OPTI_TYPE_NOT_ITERATED;
7720 dgst_pos0 = 3;
7721 dgst_pos1 = 4;
7722 dgst_pos2 = 2;
7723 dgst_pos3 = 1;
7724 break;
7725
7726 case 160: hash_type = HASH_TYPE_SHA1;
7727 salt_type = SALT_TYPE_INTERN;
7728 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7729 opts_type = OPTS_TYPE_PT_GENERATE_BE
7730 | OPTS_TYPE_PT_ADD80
7731 | OPTS_TYPE_PT_ADDBITS15;
7732 kern_type = KERN_TYPE_HMACSHA1_SLT;
7733 dgst_size = DGST_SIZE_4_5;
7734 parse_func = hmacsha1_parse_hash;
7735 sort_by_digest = sort_by_digest_4_5;
7736 opti_type = OPTI_TYPE_ZERO_BYTE
7737 | OPTI_TYPE_NOT_ITERATED;
7738 dgst_pos0 = 3;
7739 dgst_pos1 = 4;
7740 dgst_pos2 = 2;
7741 dgst_pos3 = 1;
7742 break;
7743
7744 case 190: hash_type = HASH_TYPE_SHA1;
7745 salt_type = SALT_TYPE_NONE;
7746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7747 opts_type = OPTS_TYPE_PT_GENERATE_BE
7748 | OPTS_TYPE_PT_ADD80
7749 | OPTS_TYPE_PT_ADDBITS15;
7750 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7751 dgst_size = DGST_SIZE_4_5;
7752 parse_func = sha1linkedin_parse_hash;
7753 sort_by_digest = sort_by_digest_4_5;
7754 opti_type = OPTI_TYPE_ZERO_BYTE
7755 | OPTI_TYPE_PRECOMPUTE_INIT
7756 | OPTI_TYPE_EARLY_SKIP
7757 | OPTI_TYPE_NOT_ITERATED
7758 | OPTI_TYPE_NOT_SALTED;
7759 dgst_pos0 = 0;
7760 dgst_pos1 = 4;
7761 dgst_pos2 = 3;
7762 dgst_pos3 = 2;
7763 break;
7764
7765 case 200: hash_type = HASH_TYPE_MYSQL;
7766 salt_type = SALT_TYPE_NONE;
7767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7768 opts_type = 0;
7769 kern_type = KERN_TYPE_MYSQL;
7770 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7771 parse_func = mysql323_parse_hash;
7772 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7773 opti_type = OPTI_TYPE_ZERO_BYTE;
7774 dgst_pos0 = 0;
7775 dgst_pos1 = 1;
7776 dgst_pos2 = 2;
7777 dgst_pos3 = 3;
7778 break;
7779
7780 case 300: hash_type = HASH_TYPE_SHA1;
7781 salt_type = SALT_TYPE_NONE;
7782 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7783 opts_type = OPTS_TYPE_PT_GENERATE_BE
7784 | OPTS_TYPE_PT_ADD80
7785 | OPTS_TYPE_PT_ADDBITS15;
7786 kern_type = KERN_TYPE_MYSQL41;
7787 dgst_size = DGST_SIZE_4_5;
7788 parse_func = sha1_parse_hash;
7789 sort_by_digest = sort_by_digest_4_5;
7790 opti_type = OPTI_TYPE_ZERO_BYTE
7791 | OPTI_TYPE_PRECOMPUTE_INIT
7792 | OPTI_TYPE_PRECOMPUTE_MERKLE
7793 | OPTI_TYPE_EARLY_SKIP
7794 | OPTI_TYPE_NOT_ITERATED
7795 | OPTI_TYPE_NOT_SALTED;
7796 dgst_pos0 = 3;
7797 dgst_pos1 = 4;
7798 dgst_pos2 = 2;
7799 dgst_pos3 = 1;
7800 break;
7801
7802 case 400: hash_type = HASH_TYPE_MD5;
7803 salt_type = SALT_TYPE_EMBEDDED;
7804 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7805 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7806 kern_type = KERN_TYPE_PHPASS;
7807 dgst_size = DGST_SIZE_4_4;
7808 parse_func = phpass_parse_hash;
7809 sort_by_digest = sort_by_digest_4_4;
7810 opti_type = OPTI_TYPE_ZERO_BYTE
7811 | OPTI_TYPE_SLOW_HASH_SIMD;
7812 dgst_pos0 = 0;
7813 dgst_pos1 = 1;
7814 dgst_pos2 = 2;
7815 dgst_pos3 = 3;
7816 break;
7817
7818 case 500: hash_type = HASH_TYPE_MD5;
7819 salt_type = SALT_TYPE_EMBEDDED;
7820 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7821 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7822 kern_type = KERN_TYPE_MD5CRYPT;
7823 dgst_size = DGST_SIZE_4_4;
7824 parse_func = md5crypt_parse_hash;
7825 sort_by_digest = sort_by_digest_4_4;
7826 opti_type = OPTI_TYPE_ZERO_BYTE;
7827 dgst_pos0 = 0;
7828 dgst_pos1 = 1;
7829 dgst_pos2 = 2;
7830 dgst_pos3 = 3;
7831 break;
7832
7833 case 501: hash_type = HASH_TYPE_MD5;
7834 salt_type = SALT_TYPE_EMBEDDED;
7835 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7836 opts_type = OPTS_TYPE_PT_GENERATE_LE
7837 | OPTS_TYPE_HASH_COPY;
7838 kern_type = KERN_TYPE_MD5CRYPT;
7839 dgst_size = DGST_SIZE_4_4;
7840 parse_func = juniper_parse_hash;
7841 sort_by_digest = sort_by_digest_4_4;
7842 opti_type = OPTI_TYPE_ZERO_BYTE;
7843 dgst_pos0 = 0;
7844 dgst_pos1 = 1;
7845 dgst_pos2 = 2;
7846 dgst_pos3 = 3;
7847 break;
7848
7849 case 900: hash_type = HASH_TYPE_MD4;
7850 salt_type = SALT_TYPE_NONE;
7851 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7852 opts_type = OPTS_TYPE_PT_GENERATE_LE
7853 | OPTS_TYPE_PT_ADD80
7854 | OPTS_TYPE_PT_ADDBITS14;
7855 kern_type = KERN_TYPE_MD4;
7856 dgst_size = DGST_SIZE_4_4;
7857 parse_func = md4_parse_hash;
7858 sort_by_digest = sort_by_digest_4_4;
7859 opti_type = OPTI_TYPE_ZERO_BYTE
7860 | OPTI_TYPE_PRECOMPUTE_INIT
7861 | OPTI_TYPE_PRECOMPUTE_MERKLE
7862 | OPTI_TYPE_MEET_IN_MIDDLE
7863 | OPTI_TYPE_EARLY_SKIP
7864 | OPTI_TYPE_NOT_ITERATED
7865 | OPTI_TYPE_NOT_SALTED
7866 | OPTI_TYPE_RAW_HASH;
7867 dgst_pos0 = 0;
7868 dgst_pos1 = 3;
7869 dgst_pos2 = 2;
7870 dgst_pos3 = 1;
7871 break;
7872
7873 case 1000: hash_type = HASH_TYPE_MD4;
7874 salt_type = SALT_TYPE_NONE;
7875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7876 opts_type = OPTS_TYPE_PT_GENERATE_LE
7877 | OPTS_TYPE_PT_ADD80
7878 | OPTS_TYPE_PT_ADDBITS14
7879 | OPTS_TYPE_PT_UNICODE;
7880 kern_type = KERN_TYPE_MD4_PWU;
7881 dgst_size = DGST_SIZE_4_4;
7882 parse_func = md4_parse_hash;
7883 sort_by_digest = sort_by_digest_4_4;
7884 opti_type = OPTI_TYPE_ZERO_BYTE
7885 | OPTI_TYPE_PRECOMPUTE_INIT
7886 | OPTI_TYPE_PRECOMPUTE_MERKLE
7887 | OPTI_TYPE_MEET_IN_MIDDLE
7888 | OPTI_TYPE_EARLY_SKIP
7889 | OPTI_TYPE_NOT_ITERATED
7890 | OPTI_TYPE_NOT_SALTED
7891 | OPTI_TYPE_RAW_HASH;
7892 dgst_pos0 = 0;
7893 dgst_pos1 = 3;
7894 dgst_pos2 = 2;
7895 dgst_pos3 = 1;
7896 break;
7897
7898 case 1100: hash_type = HASH_TYPE_MD4;
7899 salt_type = SALT_TYPE_INTERN;
7900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7901 opts_type = OPTS_TYPE_PT_GENERATE_LE
7902 | OPTS_TYPE_PT_ADD80
7903 | OPTS_TYPE_PT_ADDBITS14
7904 | OPTS_TYPE_PT_UNICODE
7905 | OPTS_TYPE_ST_ADD80
7906 | OPTS_TYPE_ST_UNICODE
7907 | OPTS_TYPE_ST_LOWER;
7908 kern_type = KERN_TYPE_MD44_PWUSLT;
7909 dgst_size = DGST_SIZE_4_4;
7910 parse_func = dcc_parse_hash;
7911 sort_by_digest = sort_by_digest_4_4;
7912 opti_type = OPTI_TYPE_ZERO_BYTE
7913 | OPTI_TYPE_PRECOMPUTE_INIT
7914 | OPTI_TYPE_PRECOMPUTE_MERKLE
7915 | OPTI_TYPE_EARLY_SKIP
7916 | OPTI_TYPE_NOT_ITERATED;
7917 dgst_pos0 = 0;
7918 dgst_pos1 = 3;
7919 dgst_pos2 = 2;
7920 dgst_pos3 = 1;
7921 break;
7922
7923 case 1400: hash_type = HASH_TYPE_SHA256;
7924 salt_type = SALT_TYPE_NONE;
7925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7926 opts_type = OPTS_TYPE_PT_GENERATE_BE
7927 | OPTS_TYPE_PT_ADD80
7928 | OPTS_TYPE_PT_ADDBITS15;
7929 kern_type = KERN_TYPE_SHA256;
7930 dgst_size = DGST_SIZE_4_8;
7931 parse_func = sha256_parse_hash;
7932 sort_by_digest = sort_by_digest_4_8;
7933 opti_type = OPTI_TYPE_ZERO_BYTE
7934 | OPTI_TYPE_PRECOMPUTE_INIT
7935 | OPTI_TYPE_PRECOMPUTE_MERKLE
7936 | OPTI_TYPE_EARLY_SKIP
7937 | OPTI_TYPE_NOT_ITERATED
7938 | OPTI_TYPE_NOT_SALTED
7939 | OPTI_TYPE_RAW_HASH;
7940 dgst_pos0 = 3;
7941 dgst_pos1 = 7;
7942 dgst_pos2 = 2;
7943 dgst_pos3 = 6;
7944 break;
7945
7946 case 1410: hash_type = HASH_TYPE_SHA256;
7947 salt_type = SALT_TYPE_INTERN;
7948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7949 opts_type = OPTS_TYPE_PT_GENERATE_BE
7950 | OPTS_TYPE_ST_ADD80
7951 | OPTS_TYPE_ST_ADDBITS15;
7952 kern_type = KERN_TYPE_SHA256_PWSLT;
7953 dgst_size = DGST_SIZE_4_8;
7954 parse_func = sha256s_parse_hash;
7955 sort_by_digest = sort_by_digest_4_8;
7956 opti_type = OPTI_TYPE_ZERO_BYTE
7957 | OPTI_TYPE_PRECOMPUTE_INIT
7958 | OPTI_TYPE_PRECOMPUTE_MERKLE
7959 | OPTI_TYPE_EARLY_SKIP
7960 | OPTI_TYPE_NOT_ITERATED
7961 | OPTI_TYPE_APPENDED_SALT
7962 | OPTI_TYPE_RAW_HASH;
7963 dgst_pos0 = 3;
7964 dgst_pos1 = 7;
7965 dgst_pos2 = 2;
7966 dgst_pos3 = 6;
7967 break;
7968
7969 case 1420: hash_type = HASH_TYPE_SHA256;
7970 salt_type = SALT_TYPE_INTERN;
7971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7972 opts_type = OPTS_TYPE_PT_GENERATE_BE
7973 | OPTS_TYPE_PT_ADD80
7974 | OPTS_TYPE_PT_ADDBITS15;
7975 kern_type = KERN_TYPE_SHA256_SLTPW;
7976 dgst_size = DGST_SIZE_4_8;
7977 parse_func = sha256s_parse_hash;
7978 sort_by_digest = sort_by_digest_4_8;
7979 opti_type = OPTI_TYPE_ZERO_BYTE
7980 | OPTI_TYPE_PRECOMPUTE_INIT
7981 | OPTI_TYPE_PRECOMPUTE_MERKLE
7982 | OPTI_TYPE_EARLY_SKIP
7983 | OPTI_TYPE_NOT_ITERATED
7984 | OPTI_TYPE_PREPENDED_SALT
7985 | OPTI_TYPE_RAW_HASH;
7986 dgst_pos0 = 3;
7987 dgst_pos1 = 7;
7988 dgst_pos2 = 2;
7989 dgst_pos3 = 6;
7990 break;
7991
7992 case 1421: hash_type = HASH_TYPE_SHA256;
7993 salt_type = SALT_TYPE_EMBEDDED;
7994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7995 opts_type = OPTS_TYPE_PT_GENERATE_BE
7996 | OPTS_TYPE_PT_ADD80
7997 | OPTS_TYPE_PT_ADDBITS15;
7998 kern_type = KERN_TYPE_SHA256_SLTPW;
7999 dgst_size = DGST_SIZE_4_8;
8000 parse_func = hmailserver_parse_hash;
8001 sort_by_digest = sort_by_digest_4_8;
8002 opti_type = OPTI_TYPE_ZERO_BYTE
8003 | OPTI_TYPE_PRECOMPUTE_INIT
8004 | OPTI_TYPE_PRECOMPUTE_MERKLE
8005 | OPTI_TYPE_EARLY_SKIP
8006 | OPTI_TYPE_NOT_ITERATED
8007 | OPTI_TYPE_PREPENDED_SALT
8008 | OPTI_TYPE_RAW_HASH;
8009 dgst_pos0 = 3;
8010 dgst_pos1 = 7;
8011 dgst_pos2 = 2;
8012 dgst_pos3 = 6;
8013 break;
8014
8015 case 1430: hash_type = HASH_TYPE_SHA256;
8016 salt_type = SALT_TYPE_INTERN;
8017 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8018 opts_type = OPTS_TYPE_PT_GENERATE_BE
8019 | OPTS_TYPE_PT_UNICODE
8020 | OPTS_TYPE_ST_ADD80
8021 | OPTS_TYPE_ST_ADDBITS15;
8022 kern_type = KERN_TYPE_SHA256_PWUSLT;
8023 dgst_size = DGST_SIZE_4_8;
8024 parse_func = sha256s_parse_hash;
8025 sort_by_digest = sort_by_digest_4_8;
8026 opti_type = OPTI_TYPE_ZERO_BYTE
8027 | OPTI_TYPE_PRECOMPUTE_INIT
8028 | OPTI_TYPE_PRECOMPUTE_MERKLE
8029 | OPTI_TYPE_EARLY_SKIP
8030 | OPTI_TYPE_NOT_ITERATED
8031 | OPTI_TYPE_APPENDED_SALT
8032 | OPTI_TYPE_RAW_HASH;
8033 dgst_pos0 = 3;
8034 dgst_pos1 = 7;
8035 dgst_pos2 = 2;
8036 dgst_pos3 = 6;
8037 break;
8038
8039 case 1440: hash_type = HASH_TYPE_SHA256;
8040 salt_type = SALT_TYPE_INTERN;
8041 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8042 opts_type = OPTS_TYPE_PT_GENERATE_BE
8043 | OPTS_TYPE_PT_ADD80
8044 | OPTS_TYPE_PT_ADDBITS15
8045 | OPTS_TYPE_PT_UNICODE;
8046 kern_type = KERN_TYPE_SHA256_SLTPWU;
8047 dgst_size = DGST_SIZE_4_8;
8048 parse_func = sha256s_parse_hash;
8049 sort_by_digest = sort_by_digest_4_8;
8050 opti_type = OPTI_TYPE_ZERO_BYTE
8051 | OPTI_TYPE_PRECOMPUTE_INIT
8052 | OPTI_TYPE_PRECOMPUTE_MERKLE
8053 | OPTI_TYPE_EARLY_SKIP
8054 | OPTI_TYPE_NOT_ITERATED
8055 | OPTI_TYPE_PREPENDED_SALT
8056 | OPTI_TYPE_RAW_HASH;
8057 dgst_pos0 = 3;
8058 dgst_pos1 = 7;
8059 dgst_pos2 = 2;
8060 dgst_pos3 = 6;
8061 break;
8062
8063 case 1441: hash_type = HASH_TYPE_SHA256;
8064 salt_type = SALT_TYPE_EMBEDDED;
8065 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8066 opts_type = OPTS_TYPE_PT_GENERATE_BE
8067 | OPTS_TYPE_PT_ADD80
8068 | OPTS_TYPE_PT_ADDBITS15
8069 | OPTS_TYPE_PT_UNICODE
8070 | OPTS_TYPE_ST_BASE64;
8071 kern_type = KERN_TYPE_SHA256_SLTPWU;
8072 dgst_size = DGST_SIZE_4_8;
8073 parse_func = episerver4_parse_hash;
8074 sort_by_digest = sort_by_digest_4_8;
8075 opti_type = OPTI_TYPE_ZERO_BYTE
8076 | OPTI_TYPE_PRECOMPUTE_INIT
8077 | OPTI_TYPE_PRECOMPUTE_MERKLE
8078 | OPTI_TYPE_EARLY_SKIP
8079 | OPTI_TYPE_NOT_ITERATED
8080 | OPTI_TYPE_PREPENDED_SALT
8081 | OPTI_TYPE_RAW_HASH;
8082 dgst_pos0 = 3;
8083 dgst_pos1 = 7;
8084 dgst_pos2 = 2;
8085 dgst_pos3 = 6;
8086 break;
8087
8088 case 1450: hash_type = HASH_TYPE_SHA256;
8089 salt_type = SALT_TYPE_INTERN;
8090 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8091 opts_type = OPTS_TYPE_PT_GENERATE_BE
8092 | OPTS_TYPE_ST_ADD80;
8093 kern_type = KERN_TYPE_HMACSHA256_PW;
8094 dgst_size = DGST_SIZE_4_8;
8095 parse_func = hmacsha256_parse_hash;
8096 sort_by_digest = sort_by_digest_4_8;
8097 opti_type = OPTI_TYPE_ZERO_BYTE
8098 | OPTI_TYPE_NOT_ITERATED;
8099 dgst_pos0 = 3;
8100 dgst_pos1 = 7;
8101 dgst_pos2 = 2;
8102 dgst_pos3 = 6;
8103 break;
8104
8105 case 1460: hash_type = HASH_TYPE_SHA256;
8106 salt_type = SALT_TYPE_INTERN;
8107 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8108 opts_type = OPTS_TYPE_PT_GENERATE_BE
8109 | OPTS_TYPE_PT_ADD80
8110 | OPTS_TYPE_PT_ADDBITS15;
8111 kern_type = KERN_TYPE_HMACSHA256_SLT;
8112 dgst_size = DGST_SIZE_4_8;
8113 parse_func = hmacsha256_parse_hash;
8114 sort_by_digest = sort_by_digest_4_8;
8115 opti_type = OPTI_TYPE_ZERO_BYTE
8116 | OPTI_TYPE_NOT_ITERATED;
8117 dgst_pos0 = 3;
8118 dgst_pos1 = 7;
8119 dgst_pos2 = 2;
8120 dgst_pos3 = 6;
8121 break;
8122
8123 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8124 salt_type = SALT_TYPE_EMBEDDED;
8125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8126 opts_type = OPTS_TYPE_PT_GENERATE_LE
8127 | OPTS_TYPE_PT_BITSLICE;
8128 kern_type = KERN_TYPE_DESCRYPT;
8129 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8130 parse_func = descrypt_parse_hash;
8131 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8132 opti_type = OPTI_TYPE_ZERO_BYTE
8133 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8134 dgst_pos0 = 0;
8135 dgst_pos1 = 1;
8136 dgst_pos2 = 2;
8137 dgst_pos3 = 3;
8138 break;
8139
8140 case 1600: hash_type = HASH_TYPE_MD5;
8141 salt_type = SALT_TYPE_EMBEDDED;
8142 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8143 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8144 kern_type = KERN_TYPE_APR1CRYPT;
8145 dgst_size = DGST_SIZE_4_4;
8146 parse_func = md5apr1_parse_hash;
8147 sort_by_digest = sort_by_digest_4_4;
8148 opti_type = OPTI_TYPE_ZERO_BYTE;
8149 dgst_pos0 = 0;
8150 dgst_pos1 = 1;
8151 dgst_pos2 = 2;
8152 dgst_pos3 = 3;
8153 break;
8154
8155 case 1700: hash_type = HASH_TYPE_SHA512;
8156 salt_type = SALT_TYPE_NONE;
8157 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8158 opts_type = OPTS_TYPE_PT_GENERATE_BE
8159 | OPTS_TYPE_PT_ADD80
8160 | OPTS_TYPE_PT_ADDBITS15;
8161 kern_type = KERN_TYPE_SHA512;
8162 dgst_size = DGST_SIZE_8_8;
8163 parse_func = sha512_parse_hash;
8164 sort_by_digest = sort_by_digest_8_8;
8165 opti_type = OPTI_TYPE_ZERO_BYTE
8166 | OPTI_TYPE_PRECOMPUTE_INIT
8167 | OPTI_TYPE_PRECOMPUTE_MERKLE
8168 | OPTI_TYPE_EARLY_SKIP
8169 | OPTI_TYPE_NOT_ITERATED
8170 | OPTI_TYPE_NOT_SALTED
8171 | OPTI_TYPE_USES_BITS_64
8172 | OPTI_TYPE_RAW_HASH;
8173 dgst_pos0 = 14;
8174 dgst_pos1 = 15;
8175 dgst_pos2 = 6;
8176 dgst_pos3 = 7;
8177 break;
8178
8179 case 1710: hash_type = HASH_TYPE_SHA512;
8180 salt_type = SALT_TYPE_INTERN;
8181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8182 opts_type = OPTS_TYPE_PT_GENERATE_BE
8183 | OPTS_TYPE_ST_ADD80
8184 | OPTS_TYPE_ST_ADDBITS15;
8185 kern_type = KERN_TYPE_SHA512_PWSLT;
8186 dgst_size = DGST_SIZE_8_8;
8187 parse_func = sha512s_parse_hash;
8188 sort_by_digest = sort_by_digest_8_8;
8189 opti_type = OPTI_TYPE_ZERO_BYTE
8190 | OPTI_TYPE_PRECOMPUTE_INIT
8191 | OPTI_TYPE_PRECOMPUTE_MERKLE
8192 | OPTI_TYPE_EARLY_SKIP
8193 | OPTI_TYPE_NOT_ITERATED
8194 | OPTI_TYPE_APPENDED_SALT
8195 | OPTI_TYPE_USES_BITS_64
8196 | OPTI_TYPE_RAW_HASH;
8197 dgst_pos0 = 14;
8198 dgst_pos1 = 15;
8199 dgst_pos2 = 6;
8200 dgst_pos3 = 7;
8201 break;
8202
8203 case 1711: hash_type = HASH_TYPE_SHA512;
8204 salt_type = SALT_TYPE_EMBEDDED;
8205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8206 opts_type = OPTS_TYPE_PT_GENERATE_BE
8207 | OPTS_TYPE_ST_ADD80
8208 | OPTS_TYPE_ST_ADDBITS15;
8209 kern_type = KERN_TYPE_SHA512_PWSLT;
8210 dgst_size = DGST_SIZE_8_8;
8211 parse_func = sha512b64s_parse_hash;
8212 sort_by_digest = sort_by_digest_8_8;
8213 opti_type = OPTI_TYPE_ZERO_BYTE
8214 | OPTI_TYPE_PRECOMPUTE_INIT
8215 | OPTI_TYPE_PRECOMPUTE_MERKLE
8216 | OPTI_TYPE_EARLY_SKIP
8217 | OPTI_TYPE_NOT_ITERATED
8218 | OPTI_TYPE_APPENDED_SALT
8219 | OPTI_TYPE_USES_BITS_64
8220 | OPTI_TYPE_RAW_HASH;
8221 dgst_pos0 = 14;
8222 dgst_pos1 = 15;
8223 dgst_pos2 = 6;
8224 dgst_pos3 = 7;
8225 break;
8226
8227 case 1720: hash_type = HASH_TYPE_SHA512;
8228 salt_type = SALT_TYPE_INTERN;
8229 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8230 opts_type = OPTS_TYPE_PT_GENERATE_BE
8231 | OPTS_TYPE_PT_ADD80
8232 | OPTS_TYPE_PT_ADDBITS15;
8233 kern_type = KERN_TYPE_SHA512_SLTPW;
8234 dgst_size = DGST_SIZE_8_8;
8235 parse_func = sha512s_parse_hash;
8236 sort_by_digest = sort_by_digest_8_8;
8237 opti_type = OPTI_TYPE_ZERO_BYTE
8238 | OPTI_TYPE_PRECOMPUTE_INIT
8239 | OPTI_TYPE_PRECOMPUTE_MERKLE
8240 | OPTI_TYPE_EARLY_SKIP
8241 | OPTI_TYPE_NOT_ITERATED
8242 | OPTI_TYPE_PREPENDED_SALT
8243 | OPTI_TYPE_USES_BITS_64
8244 | OPTI_TYPE_RAW_HASH;
8245 dgst_pos0 = 14;
8246 dgst_pos1 = 15;
8247 dgst_pos2 = 6;
8248 dgst_pos3 = 7;
8249 break;
8250
8251 case 1722: hash_type = HASH_TYPE_SHA512;
8252 salt_type = SALT_TYPE_EMBEDDED;
8253 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8254 opts_type = OPTS_TYPE_PT_GENERATE_BE
8255 | OPTS_TYPE_PT_ADD80
8256 | OPTS_TYPE_PT_ADDBITS15
8257 | OPTS_TYPE_ST_HEX;
8258 kern_type = KERN_TYPE_SHA512_SLTPW;
8259 dgst_size = DGST_SIZE_8_8;
8260 parse_func = osx512_parse_hash;
8261 sort_by_digest = sort_by_digest_8_8;
8262 opti_type = OPTI_TYPE_ZERO_BYTE
8263 | OPTI_TYPE_PRECOMPUTE_INIT
8264 | OPTI_TYPE_PRECOMPUTE_MERKLE
8265 | OPTI_TYPE_EARLY_SKIP
8266 | OPTI_TYPE_NOT_ITERATED
8267 | OPTI_TYPE_PREPENDED_SALT
8268 | OPTI_TYPE_USES_BITS_64
8269 | OPTI_TYPE_RAW_HASH;
8270 dgst_pos0 = 14;
8271 dgst_pos1 = 15;
8272 dgst_pos2 = 6;
8273 dgst_pos3 = 7;
8274 break;
8275
8276 case 1730: hash_type = HASH_TYPE_SHA512;
8277 salt_type = SALT_TYPE_INTERN;
8278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8279 opts_type = OPTS_TYPE_PT_GENERATE_BE
8280 | OPTS_TYPE_PT_UNICODE
8281 | OPTS_TYPE_ST_ADD80
8282 | OPTS_TYPE_ST_ADDBITS15;
8283 kern_type = KERN_TYPE_SHA512_PWSLTU;
8284 dgst_size = DGST_SIZE_8_8;
8285 parse_func = sha512s_parse_hash;
8286 sort_by_digest = sort_by_digest_8_8;
8287 opti_type = OPTI_TYPE_ZERO_BYTE
8288 | OPTI_TYPE_PRECOMPUTE_INIT
8289 | OPTI_TYPE_PRECOMPUTE_MERKLE
8290 | OPTI_TYPE_EARLY_SKIP
8291 | OPTI_TYPE_NOT_ITERATED
8292 | OPTI_TYPE_APPENDED_SALT
8293 | OPTI_TYPE_USES_BITS_64
8294 | OPTI_TYPE_RAW_HASH;
8295 dgst_pos0 = 14;
8296 dgst_pos1 = 15;
8297 dgst_pos2 = 6;
8298 dgst_pos3 = 7;
8299 break;
8300
8301 case 1731: hash_type = HASH_TYPE_SHA512;
8302 salt_type = SALT_TYPE_EMBEDDED;
8303 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8304 opts_type = OPTS_TYPE_PT_GENERATE_BE
8305 | OPTS_TYPE_PT_UNICODE
8306 | OPTS_TYPE_ST_ADD80
8307 | OPTS_TYPE_ST_ADDBITS15
8308 | OPTS_TYPE_ST_HEX;
8309 kern_type = KERN_TYPE_SHA512_PWSLTU;
8310 dgst_size = DGST_SIZE_8_8;
8311 parse_func = mssql2012_parse_hash;
8312 sort_by_digest = sort_by_digest_8_8;
8313 opti_type = OPTI_TYPE_ZERO_BYTE
8314 | OPTI_TYPE_PRECOMPUTE_INIT
8315 | OPTI_TYPE_PRECOMPUTE_MERKLE
8316 | OPTI_TYPE_EARLY_SKIP
8317 | OPTI_TYPE_NOT_ITERATED
8318 | OPTI_TYPE_APPENDED_SALT
8319 | OPTI_TYPE_USES_BITS_64
8320 | OPTI_TYPE_RAW_HASH;
8321 dgst_pos0 = 14;
8322 dgst_pos1 = 15;
8323 dgst_pos2 = 6;
8324 dgst_pos3 = 7;
8325 break;
8326
8327 case 1740: hash_type = HASH_TYPE_SHA512;
8328 salt_type = SALT_TYPE_INTERN;
8329 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8330 opts_type = OPTS_TYPE_PT_GENERATE_BE
8331 | OPTS_TYPE_PT_ADD80
8332 | OPTS_TYPE_PT_ADDBITS15
8333 | OPTS_TYPE_PT_UNICODE;
8334 kern_type = KERN_TYPE_SHA512_SLTPWU;
8335 dgst_size = DGST_SIZE_8_8;
8336 parse_func = sha512s_parse_hash;
8337 sort_by_digest = sort_by_digest_8_8;
8338 opti_type = OPTI_TYPE_ZERO_BYTE
8339 | OPTI_TYPE_PRECOMPUTE_INIT
8340 | OPTI_TYPE_PRECOMPUTE_MERKLE
8341 | OPTI_TYPE_EARLY_SKIP
8342 | OPTI_TYPE_NOT_ITERATED
8343 | OPTI_TYPE_PREPENDED_SALT
8344 | OPTI_TYPE_USES_BITS_64
8345 | OPTI_TYPE_RAW_HASH;
8346 dgst_pos0 = 14;
8347 dgst_pos1 = 15;
8348 dgst_pos2 = 6;
8349 dgst_pos3 = 7;
8350 break;
8351
8352 case 1750: hash_type = HASH_TYPE_SHA512;
8353 salt_type = SALT_TYPE_INTERN;
8354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8355 opts_type = OPTS_TYPE_PT_GENERATE_BE
8356 | OPTS_TYPE_ST_ADD80;
8357 kern_type = KERN_TYPE_HMACSHA512_PW;
8358 dgst_size = DGST_SIZE_8_8;
8359 parse_func = hmacsha512_parse_hash;
8360 sort_by_digest = sort_by_digest_8_8;
8361 opti_type = OPTI_TYPE_ZERO_BYTE
8362 | OPTI_TYPE_USES_BITS_64
8363 | OPTI_TYPE_NOT_ITERATED;
8364 dgst_pos0 = 14;
8365 dgst_pos1 = 15;
8366 dgst_pos2 = 6;
8367 dgst_pos3 = 7;
8368 break;
8369
8370 case 1760: hash_type = HASH_TYPE_SHA512;
8371 salt_type = SALT_TYPE_INTERN;
8372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8373 opts_type = OPTS_TYPE_PT_GENERATE_BE
8374 | OPTS_TYPE_PT_ADD80
8375 | OPTS_TYPE_PT_ADDBITS15;
8376 kern_type = KERN_TYPE_HMACSHA512_SLT;
8377 dgst_size = DGST_SIZE_8_8;
8378 parse_func = hmacsha512_parse_hash;
8379 sort_by_digest = sort_by_digest_8_8;
8380 opti_type = OPTI_TYPE_ZERO_BYTE
8381 | OPTI_TYPE_USES_BITS_64
8382 | OPTI_TYPE_NOT_ITERATED;
8383 dgst_pos0 = 14;
8384 dgst_pos1 = 15;
8385 dgst_pos2 = 6;
8386 dgst_pos3 = 7;
8387 break;
8388
8389 case 1800: hash_type = HASH_TYPE_SHA512;
8390 salt_type = SALT_TYPE_EMBEDDED;
8391 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8392 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8393 kern_type = KERN_TYPE_SHA512CRYPT;
8394 dgst_size = DGST_SIZE_8_8;
8395 parse_func = sha512crypt_parse_hash;
8396 sort_by_digest = sort_by_digest_8_8;
8397 opti_type = OPTI_TYPE_ZERO_BYTE
8398 | OPTI_TYPE_USES_BITS_64;
8399 dgst_pos0 = 0;
8400 dgst_pos1 = 1;
8401 dgst_pos2 = 2;
8402 dgst_pos3 = 3;
8403 break;
8404
8405 case 2100: hash_type = HASH_TYPE_DCC2;
8406 salt_type = SALT_TYPE_EMBEDDED;
8407 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8408 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8409 | OPTS_TYPE_ST_LOWER
8410 | OPTS_TYPE_ST_UNICODE;
8411 kern_type = KERN_TYPE_DCC2;
8412 dgst_size = DGST_SIZE_4_4;
8413 parse_func = dcc2_parse_hash;
8414 sort_by_digest = sort_by_digest_4_4;
8415 opti_type = OPTI_TYPE_ZERO_BYTE
8416 | OPTI_TYPE_SLOW_HASH_SIMD;
8417 dgst_pos0 = 0;
8418 dgst_pos1 = 1;
8419 dgst_pos2 = 2;
8420 dgst_pos3 = 3;
8421 break;
8422
8423 case 2400: hash_type = HASH_TYPE_MD5;
8424 salt_type = SALT_TYPE_NONE;
8425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8426 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8427 kern_type = KERN_TYPE_MD5PIX;
8428 dgst_size = DGST_SIZE_4_4;
8429 parse_func = md5pix_parse_hash;
8430 sort_by_digest = sort_by_digest_4_4;
8431 opti_type = OPTI_TYPE_ZERO_BYTE
8432 | OPTI_TYPE_PRECOMPUTE_INIT
8433 | OPTI_TYPE_PRECOMPUTE_MERKLE
8434 | OPTI_TYPE_EARLY_SKIP
8435 | OPTI_TYPE_NOT_ITERATED
8436 | OPTI_TYPE_NOT_SALTED;
8437 dgst_pos0 = 0;
8438 dgst_pos1 = 3;
8439 dgst_pos2 = 2;
8440 dgst_pos3 = 1;
8441 break;
8442
8443 case 2410: hash_type = HASH_TYPE_MD5;
8444 salt_type = SALT_TYPE_INTERN;
8445 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8446 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8447 kern_type = KERN_TYPE_MD5ASA;
8448 dgst_size = DGST_SIZE_4_4;
8449 parse_func = md5asa_parse_hash;
8450 sort_by_digest = sort_by_digest_4_4;
8451 opti_type = OPTI_TYPE_ZERO_BYTE
8452 | OPTI_TYPE_PRECOMPUTE_INIT
8453 | OPTI_TYPE_PRECOMPUTE_MERKLE
8454 | OPTI_TYPE_EARLY_SKIP
8455 | OPTI_TYPE_NOT_ITERATED;
8456 dgst_pos0 = 0;
8457 dgst_pos1 = 3;
8458 dgst_pos2 = 2;
8459 dgst_pos3 = 1;
8460 break;
8461
8462 case 2500: hash_type = HASH_TYPE_WPA;
8463 salt_type = SALT_TYPE_EMBEDDED;
8464 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8465 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8466 kern_type = KERN_TYPE_WPA;
8467 dgst_size = DGST_SIZE_4_4;
8468 parse_func = wpa_parse_hash;
8469 sort_by_digest = sort_by_digest_4_4;
8470 opti_type = OPTI_TYPE_ZERO_BYTE
8471 | OPTI_TYPE_SLOW_HASH_SIMD;
8472 dgst_pos0 = 0;
8473 dgst_pos1 = 1;
8474 dgst_pos2 = 2;
8475 dgst_pos3 = 3;
8476 break;
8477
8478 case 2600: hash_type = HASH_TYPE_MD5;
8479 salt_type = SALT_TYPE_VIRTUAL;
8480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8481 opts_type = OPTS_TYPE_PT_GENERATE_LE
8482 | OPTS_TYPE_PT_ADD80
8483 | OPTS_TYPE_PT_ADDBITS14
8484 | OPTS_TYPE_ST_ADD80;
8485 kern_type = KERN_TYPE_MD55_PWSLT1;
8486 dgst_size = DGST_SIZE_4_4;
8487 parse_func = md5md5_parse_hash;
8488 sort_by_digest = sort_by_digest_4_4;
8489 opti_type = OPTI_TYPE_ZERO_BYTE
8490 | OPTI_TYPE_PRECOMPUTE_INIT
8491 | OPTI_TYPE_PRECOMPUTE_MERKLE
8492 | OPTI_TYPE_EARLY_SKIP;
8493 dgst_pos0 = 0;
8494 dgst_pos1 = 3;
8495 dgst_pos2 = 2;
8496 dgst_pos3 = 1;
8497 break;
8498
8499 case 2611: hash_type = HASH_TYPE_MD5;
8500 salt_type = SALT_TYPE_INTERN;
8501 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8502 opts_type = OPTS_TYPE_PT_GENERATE_LE
8503 | OPTS_TYPE_PT_ADD80
8504 | OPTS_TYPE_PT_ADDBITS14
8505 | OPTS_TYPE_ST_ADD80;
8506 kern_type = KERN_TYPE_MD55_PWSLT1;
8507 dgst_size = DGST_SIZE_4_4;
8508 parse_func = vb3_parse_hash;
8509 sort_by_digest = sort_by_digest_4_4;
8510 opti_type = OPTI_TYPE_ZERO_BYTE
8511 | OPTI_TYPE_PRECOMPUTE_INIT
8512 | OPTI_TYPE_PRECOMPUTE_MERKLE
8513 | OPTI_TYPE_EARLY_SKIP;
8514 dgst_pos0 = 0;
8515 dgst_pos1 = 3;
8516 dgst_pos2 = 2;
8517 dgst_pos3 = 1;
8518 break;
8519
8520 case 2612: hash_type = HASH_TYPE_MD5;
8521 salt_type = SALT_TYPE_EMBEDDED;
8522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8523 opts_type = OPTS_TYPE_PT_GENERATE_LE
8524 | OPTS_TYPE_PT_ADD80
8525 | OPTS_TYPE_PT_ADDBITS14
8526 | OPTS_TYPE_ST_ADD80
8527 | OPTS_TYPE_ST_HEX;
8528 kern_type = KERN_TYPE_MD55_PWSLT1;
8529 dgst_size = DGST_SIZE_4_4;
8530 parse_func = phps_parse_hash;
8531 sort_by_digest = sort_by_digest_4_4;
8532 opti_type = OPTI_TYPE_ZERO_BYTE
8533 | OPTI_TYPE_PRECOMPUTE_INIT
8534 | OPTI_TYPE_PRECOMPUTE_MERKLE
8535 | OPTI_TYPE_EARLY_SKIP;
8536 dgst_pos0 = 0;
8537 dgst_pos1 = 3;
8538 dgst_pos2 = 2;
8539 dgst_pos3 = 1;
8540 break;
8541
8542 case 2711: hash_type = HASH_TYPE_MD5;
8543 salt_type = SALT_TYPE_INTERN;
8544 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8545 opts_type = OPTS_TYPE_PT_GENERATE_LE
8546 | OPTS_TYPE_PT_ADD80
8547 | OPTS_TYPE_PT_ADDBITS14
8548 | OPTS_TYPE_ST_ADD80;
8549 kern_type = KERN_TYPE_MD55_PWSLT2;
8550 dgst_size = DGST_SIZE_4_4;
8551 parse_func = vb30_parse_hash;
8552 sort_by_digest = sort_by_digest_4_4;
8553 opti_type = OPTI_TYPE_ZERO_BYTE
8554 | OPTI_TYPE_PRECOMPUTE_INIT
8555 | OPTI_TYPE_EARLY_SKIP;
8556 dgst_pos0 = 0;
8557 dgst_pos1 = 3;
8558 dgst_pos2 = 2;
8559 dgst_pos3 = 1;
8560 break;
8561
8562 case 2811: hash_type = HASH_TYPE_MD5;
8563 salt_type = SALT_TYPE_INTERN;
8564 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8565 opts_type = OPTS_TYPE_PT_GENERATE_LE
8566 | OPTS_TYPE_PT_ADD80
8567 | OPTS_TYPE_PT_ADDBITS14;
8568 kern_type = KERN_TYPE_MD55_SLTPW;
8569 dgst_size = DGST_SIZE_4_4;
8570 parse_func = ipb2_parse_hash;
8571 sort_by_digest = sort_by_digest_4_4;
8572 opti_type = OPTI_TYPE_ZERO_BYTE
8573 | OPTI_TYPE_PRECOMPUTE_INIT
8574 | OPTI_TYPE_EARLY_SKIP;
8575 dgst_pos0 = 0;
8576 dgst_pos1 = 3;
8577 dgst_pos2 = 2;
8578 dgst_pos3 = 1;
8579 break;
8580
8581 case 3000: hash_type = HASH_TYPE_LM;
8582 salt_type = SALT_TYPE_NONE;
8583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8584 opts_type = OPTS_TYPE_PT_GENERATE_LE
8585 | OPTS_TYPE_PT_UPPER
8586 | OPTS_TYPE_PT_BITSLICE;
8587 kern_type = KERN_TYPE_LM;
8588 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8589 parse_func = lm_parse_hash;
8590 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8591 opti_type = OPTI_TYPE_ZERO_BYTE
8592 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8593 dgst_pos0 = 0;
8594 dgst_pos1 = 1;
8595 dgst_pos2 = 2;
8596 dgst_pos3 = 3;
8597 break;
8598
8599 case 3100: hash_type = HASH_TYPE_ORACLEH;
8600 salt_type = SALT_TYPE_INTERN;
8601 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8602 opts_type = OPTS_TYPE_PT_GENERATE_LE
8603 | OPTS_TYPE_PT_UPPER
8604 | OPTS_TYPE_ST_UPPER;
8605 kern_type = KERN_TYPE_ORACLEH;
8606 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8607 parse_func = oracleh_parse_hash;
8608 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8609 opti_type = OPTI_TYPE_ZERO_BYTE;
8610 dgst_pos0 = 0;
8611 dgst_pos1 = 1;
8612 dgst_pos2 = 2;
8613 dgst_pos3 = 3;
8614 break;
8615
8616 case 3200: hash_type = HASH_TYPE_BCRYPT;
8617 salt_type = SALT_TYPE_EMBEDDED;
8618 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8619 opts_type = OPTS_TYPE_PT_GENERATE_LE
8620 | OPTS_TYPE_ST_GENERATE_LE;
8621 kern_type = KERN_TYPE_BCRYPT;
8622 dgst_size = DGST_SIZE_4_6;
8623 parse_func = bcrypt_parse_hash;
8624 sort_by_digest = sort_by_digest_4_6;
8625 opti_type = OPTI_TYPE_ZERO_BYTE;
8626 dgst_pos0 = 0;
8627 dgst_pos1 = 1;
8628 dgst_pos2 = 2;
8629 dgst_pos3 = 3;
8630 break;
8631
8632 case 3710: hash_type = HASH_TYPE_MD5;
8633 salt_type = SALT_TYPE_INTERN;
8634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8635 opts_type = OPTS_TYPE_PT_GENERATE_LE
8636 | OPTS_TYPE_PT_ADD80
8637 | OPTS_TYPE_PT_ADDBITS14;
8638 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8639 dgst_size = DGST_SIZE_4_4;
8640 parse_func = md5s_parse_hash;
8641 sort_by_digest = sort_by_digest_4_4;
8642 opti_type = OPTI_TYPE_ZERO_BYTE
8643 | OPTI_TYPE_PRECOMPUTE_INIT
8644 | OPTI_TYPE_PRECOMPUTE_MERKLE
8645 | OPTI_TYPE_EARLY_SKIP;
8646 dgst_pos0 = 0;
8647 dgst_pos1 = 3;
8648 dgst_pos2 = 2;
8649 dgst_pos3 = 1;
8650 break;
8651
8652 case 3711: hash_type = HASH_TYPE_MD5;
8653 salt_type = SALT_TYPE_EMBEDDED;
8654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8655 opts_type = OPTS_TYPE_PT_GENERATE_LE
8656 | OPTS_TYPE_PT_ADD80
8657 | OPTS_TYPE_PT_ADDBITS14;
8658 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8659 dgst_size = DGST_SIZE_4_4;
8660 parse_func = mediawiki_b_parse_hash;
8661 sort_by_digest = sort_by_digest_4_4;
8662 opti_type = OPTI_TYPE_ZERO_BYTE
8663 | OPTI_TYPE_PRECOMPUTE_INIT
8664 | OPTI_TYPE_PRECOMPUTE_MERKLE
8665 | OPTI_TYPE_EARLY_SKIP;
8666 dgst_pos0 = 0;
8667 dgst_pos1 = 3;
8668 dgst_pos2 = 2;
8669 dgst_pos3 = 1;
8670 break;
8671
8672 case 3800: hash_type = HASH_TYPE_MD5;
8673 salt_type = SALT_TYPE_INTERN;
8674 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8675 opts_type = OPTS_TYPE_PT_GENERATE_LE
8676 | OPTS_TYPE_ST_ADDBITS14;
8677 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8678 dgst_size = DGST_SIZE_4_4;
8679 parse_func = md5s_parse_hash;
8680 sort_by_digest = sort_by_digest_4_4;
8681 opti_type = OPTI_TYPE_ZERO_BYTE
8682 | OPTI_TYPE_PRECOMPUTE_INIT
8683 | OPTI_TYPE_PRECOMPUTE_MERKLE
8684 | OPTI_TYPE_EARLY_SKIP
8685 | OPTI_TYPE_NOT_ITERATED
8686 | OPTI_TYPE_RAW_HASH;
8687 dgst_pos0 = 0;
8688 dgst_pos1 = 3;
8689 dgst_pos2 = 2;
8690 dgst_pos3 = 1;
8691 break;
8692
8693 case 4300: hash_type = HASH_TYPE_MD5;
8694 salt_type = SALT_TYPE_VIRTUAL;
8695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8696 opts_type = OPTS_TYPE_PT_GENERATE_LE
8697 | OPTS_TYPE_PT_ADD80
8698 | OPTS_TYPE_PT_ADDBITS14
8699 | OPTS_TYPE_ST_ADD80;
8700 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8701 dgst_size = DGST_SIZE_4_4;
8702 parse_func = md5md5_parse_hash;
8703 sort_by_digest = sort_by_digest_4_4;
8704 opti_type = OPTI_TYPE_ZERO_BYTE
8705 | OPTI_TYPE_PRECOMPUTE_INIT
8706 | OPTI_TYPE_PRECOMPUTE_MERKLE
8707 | OPTI_TYPE_EARLY_SKIP;
8708 dgst_pos0 = 0;
8709 dgst_pos1 = 3;
8710 dgst_pos2 = 2;
8711 dgst_pos3 = 1;
8712 break;
8713
8714
8715 case 4400: hash_type = HASH_TYPE_MD5;
8716 salt_type = SALT_TYPE_NONE;
8717 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8718 opts_type = OPTS_TYPE_PT_GENERATE_BE
8719 | OPTS_TYPE_PT_ADD80
8720 | OPTS_TYPE_PT_ADDBITS15;
8721 kern_type = KERN_TYPE_MD5_SHA1;
8722 dgst_size = DGST_SIZE_4_4;
8723 parse_func = md5_parse_hash;
8724 sort_by_digest = sort_by_digest_4_4;
8725 opti_type = OPTI_TYPE_ZERO_BYTE
8726 | OPTI_TYPE_PRECOMPUTE_INIT
8727 | OPTI_TYPE_PRECOMPUTE_MERKLE
8728 | OPTI_TYPE_EARLY_SKIP
8729 | OPTI_TYPE_NOT_ITERATED
8730 | OPTI_TYPE_NOT_SALTED
8731 | OPTI_TYPE_RAW_HASH;
8732 dgst_pos0 = 0;
8733 dgst_pos1 = 3;
8734 dgst_pos2 = 2;
8735 dgst_pos3 = 1;
8736 break;
8737
8738 case 4500: hash_type = HASH_TYPE_SHA1;
8739 salt_type = SALT_TYPE_NONE;
8740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8741 opts_type = OPTS_TYPE_PT_GENERATE_BE
8742 | OPTS_TYPE_PT_ADD80
8743 | OPTS_TYPE_PT_ADDBITS15;
8744 kern_type = KERN_TYPE_SHA11;
8745 dgst_size = DGST_SIZE_4_5;
8746 parse_func = sha1_parse_hash;
8747 sort_by_digest = sort_by_digest_4_5;
8748 opti_type = OPTI_TYPE_ZERO_BYTE
8749 | OPTI_TYPE_PRECOMPUTE_INIT
8750 | OPTI_TYPE_PRECOMPUTE_MERKLE
8751 | OPTI_TYPE_EARLY_SKIP
8752 | OPTI_TYPE_NOT_SALTED;
8753 dgst_pos0 = 3;
8754 dgst_pos1 = 4;
8755 dgst_pos2 = 2;
8756 dgst_pos3 = 1;
8757 break;
8758
8759 case 4700: hash_type = HASH_TYPE_SHA1;
8760 salt_type = SALT_TYPE_NONE;
8761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8762 opts_type = OPTS_TYPE_PT_GENERATE_LE
8763 | OPTS_TYPE_PT_ADD80
8764 | OPTS_TYPE_PT_ADDBITS14;
8765 kern_type = KERN_TYPE_SHA1_MD5;
8766 dgst_size = DGST_SIZE_4_5;
8767 parse_func = sha1_parse_hash;
8768 sort_by_digest = sort_by_digest_4_5;
8769 opti_type = OPTI_TYPE_ZERO_BYTE
8770 | OPTI_TYPE_PRECOMPUTE_INIT
8771 | OPTI_TYPE_PRECOMPUTE_MERKLE
8772 | OPTI_TYPE_EARLY_SKIP
8773 | OPTI_TYPE_NOT_ITERATED
8774 | OPTI_TYPE_NOT_SALTED
8775 | OPTI_TYPE_RAW_HASH;
8776 dgst_pos0 = 3;
8777 dgst_pos1 = 4;
8778 dgst_pos2 = 2;
8779 dgst_pos3 = 1;
8780 break;
8781
8782 case 4800: hash_type = HASH_TYPE_MD5;
8783 salt_type = SALT_TYPE_EMBEDDED;
8784 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8785 opts_type = OPTS_TYPE_PT_GENERATE_LE
8786 | OPTS_TYPE_PT_ADDBITS14;
8787 kern_type = KERN_TYPE_MD5_CHAP;
8788 dgst_size = DGST_SIZE_4_4;
8789 parse_func = chap_parse_hash;
8790 sort_by_digest = sort_by_digest_4_4;
8791 opti_type = OPTI_TYPE_ZERO_BYTE
8792 | OPTI_TYPE_PRECOMPUTE_INIT
8793 | OPTI_TYPE_PRECOMPUTE_MERKLE
8794 | OPTI_TYPE_MEET_IN_MIDDLE
8795 | OPTI_TYPE_EARLY_SKIP
8796 | OPTI_TYPE_NOT_ITERATED
8797 | OPTI_TYPE_RAW_HASH;
8798 dgst_pos0 = 0;
8799 dgst_pos1 = 3;
8800 dgst_pos2 = 2;
8801 dgst_pos3 = 1;
8802 break;
8803
8804 case 4900: hash_type = HASH_TYPE_SHA1;
8805 salt_type = SALT_TYPE_INTERN;
8806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8807 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8808 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8809 dgst_size = DGST_SIZE_4_5;
8810 parse_func = sha1s_parse_hash;
8811 sort_by_digest = sort_by_digest_4_5;
8812 opti_type = OPTI_TYPE_ZERO_BYTE
8813 | OPTI_TYPE_PRECOMPUTE_INIT
8814 | OPTI_TYPE_PRECOMPUTE_MERKLE
8815 | OPTI_TYPE_EARLY_SKIP;
8816 dgst_pos0 = 3;
8817 dgst_pos1 = 4;
8818 dgst_pos2 = 2;
8819 dgst_pos3 = 1;
8820 break;
8821
8822 case 5000: hash_type = HASH_TYPE_KECCAK;
8823 salt_type = SALT_TYPE_EMBEDDED;
8824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8825 opts_type = OPTS_TYPE_PT_GENERATE_LE
8826 | OPTS_TYPE_PT_ADD01;
8827 kern_type = KERN_TYPE_KECCAK;
8828 dgst_size = DGST_SIZE_8_25;
8829 parse_func = keccak_parse_hash;
8830 sort_by_digest = sort_by_digest_8_25;
8831 opti_type = OPTI_TYPE_ZERO_BYTE
8832 | OPTI_TYPE_USES_BITS_64
8833 | OPTI_TYPE_RAW_HASH;
8834 dgst_pos0 = 2;
8835 dgst_pos1 = 3;
8836 dgst_pos2 = 4;
8837 dgst_pos3 = 5;
8838 break;
8839
8840 case 5100: hash_type = HASH_TYPE_MD5H;
8841 salt_type = SALT_TYPE_NONE;
8842 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8843 opts_type = OPTS_TYPE_PT_GENERATE_LE
8844 | OPTS_TYPE_PT_ADD80
8845 | OPTS_TYPE_PT_ADDBITS14;
8846 kern_type = KERN_TYPE_MD5H;
8847 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8848 parse_func = md5half_parse_hash;
8849 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8850 opti_type = OPTI_TYPE_ZERO_BYTE
8851 | OPTI_TYPE_RAW_HASH;
8852 dgst_pos0 = 0;
8853 dgst_pos1 = 1;
8854 dgst_pos2 = 2;
8855 dgst_pos3 = 3;
8856 break;
8857
8858 case 5200: hash_type = HASH_TYPE_SHA256;
8859 salt_type = SALT_TYPE_EMBEDDED;
8860 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8861 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8862 kern_type = KERN_TYPE_PSAFE3;
8863 dgst_size = DGST_SIZE_4_8;
8864 parse_func = psafe3_parse_hash;
8865 sort_by_digest = sort_by_digest_4_8;
8866 opti_type = OPTI_TYPE_ZERO_BYTE;
8867 dgst_pos0 = 0;
8868 dgst_pos1 = 1;
8869 dgst_pos2 = 2;
8870 dgst_pos3 = 3;
8871 break;
8872
8873 case 5300: hash_type = HASH_TYPE_MD5;
8874 salt_type = SALT_TYPE_EMBEDDED;
8875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8876 opts_type = OPTS_TYPE_PT_GENERATE_LE
8877 | OPTS_TYPE_ST_ADD80;
8878 kern_type = KERN_TYPE_IKEPSK_MD5;
8879 dgst_size = DGST_SIZE_4_4;
8880 parse_func = ikepsk_md5_parse_hash;
8881 sort_by_digest = sort_by_digest_4_4;
8882 opti_type = OPTI_TYPE_ZERO_BYTE;
8883 dgst_pos0 = 0;
8884 dgst_pos1 = 3;
8885 dgst_pos2 = 2;
8886 dgst_pos3 = 1;
8887 break;
8888
8889 case 5400: hash_type = HASH_TYPE_SHA1;
8890 salt_type = SALT_TYPE_EMBEDDED;
8891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8892 opts_type = OPTS_TYPE_PT_GENERATE_BE
8893 | OPTS_TYPE_ST_ADD80;
8894 kern_type = KERN_TYPE_IKEPSK_SHA1;
8895 dgst_size = DGST_SIZE_4_5;
8896 parse_func = ikepsk_sha1_parse_hash;
8897 sort_by_digest = sort_by_digest_4_5;
8898 opti_type = OPTI_TYPE_ZERO_BYTE;
8899 dgst_pos0 = 3;
8900 dgst_pos1 = 4;
8901 dgst_pos2 = 2;
8902 dgst_pos3 = 1;
8903 break;
8904
8905 case 5500: hash_type = HASH_TYPE_NETNTLM;
8906 salt_type = SALT_TYPE_EMBEDDED;
8907 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8908 opts_type = OPTS_TYPE_PT_GENERATE_LE
8909 | OPTS_TYPE_PT_ADD80
8910 | OPTS_TYPE_PT_ADDBITS14
8911 | OPTS_TYPE_PT_UNICODE
8912 | OPTS_TYPE_ST_HEX;
8913 kern_type = KERN_TYPE_NETNTLMv1;
8914 dgst_size = DGST_SIZE_4_4;
8915 parse_func = netntlmv1_parse_hash;
8916 sort_by_digest = sort_by_digest_4_4;
8917 opti_type = OPTI_TYPE_ZERO_BYTE
8918 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8919 dgst_pos0 = 0;
8920 dgst_pos1 = 1;
8921 dgst_pos2 = 2;
8922 dgst_pos3 = 3;
8923 break;
8924
8925 case 5600: hash_type = HASH_TYPE_MD5;
8926 salt_type = SALT_TYPE_EMBEDDED;
8927 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8928 opts_type = OPTS_TYPE_PT_GENERATE_LE
8929 | OPTS_TYPE_PT_ADD80
8930 | OPTS_TYPE_PT_ADDBITS14
8931 | OPTS_TYPE_PT_UNICODE;
8932 kern_type = KERN_TYPE_NETNTLMv2;
8933 dgst_size = DGST_SIZE_4_4;
8934 parse_func = netntlmv2_parse_hash;
8935 sort_by_digest = sort_by_digest_4_4;
8936 opti_type = OPTI_TYPE_ZERO_BYTE;
8937 dgst_pos0 = 0;
8938 dgst_pos1 = 3;
8939 dgst_pos2 = 2;
8940 dgst_pos3 = 1;
8941 break;
8942
8943 case 5700: hash_type = HASH_TYPE_SHA256;
8944 salt_type = SALT_TYPE_NONE;
8945 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8946 opts_type = OPTS_TYPE_PT_GENERATE_BE
8947 | OPTS_TYPE_PT_ADD80
8948 | OPTS_TYPE_PT_ADDBITS15;
8949 kern_type = KERN_TYPE_SHA256;
8950 dgst_size = DGST_SIZE_4_8;
8951 parse_func = cisco4_parse_hash;
8952 sort_by_digest = sort_by_digest_4_8;
8953 opti_type = OPTI_TYPE_ZERO_BYTE
8954 | OPTI_TYPE_PRECOMPUTE_INIT
8955 | OPTI_TYPE_PRECOMPUTE_MERKLE
8956 | OPTI_TYPE_EARLY_SKIP
8957 | OPTI_TYPE_NOT_ITERATED
8958 | OPTI_TYPE_NOT_SALTED
8959 | OPTI_TYPE_RAW_HASH;
8960 dgst_pos0 = 3;
8961 dgst_pos1 = 7;
8962 dgst_pos2 = 2;
8963 dgst_pos3 = 6;
8964 break;
8965
8966 case 5800: hash_type = HASH_TYPE_SHA1;
8967 salt_type = SALT_TYPE_INTERN;
8968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8969 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8970 | OPTS_TYPE_ST_ADD80;
8971 kern_type = KERN_TYPE_ANDROIDPIN;
8972 dgst_size = DGST_SIZE_4_5;
8973 parse_func = androidpin_parse_hash;
8974 sort_by_digest = sort_by_digest_4_5;
8975 opti_type = OPTI_TYPE_ZERO_BYTE;
8976 dgst_pos0 = 0;
8977 dgst_pos1 = 1;
8978 dgst_pos2 = 2;
8979 dgst_pos3 = 3;
8980 break;
8981
8982 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8983 salt_type = SALT_TYPE_NONE;
8984 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8985 opts_type = OPTS_TYPE_PT_GENERATE_LE
8986 | OPTS_TYPE_PT_ADD80;
8987 kern_type = KERN_TYPE_RIPEMD160;
8988 dgst_size = DGST_SIZE_4_5;
8989 parse_func = ripemd160_parse_hash;
8990 sort_by_digest = sort_by_digest_4_5;
8991 opti_type = OPTI_TYPE_ZERO_BYTE;
8992 dgst_pos0 = 0;
8993 dgst_pos1 = 1;
8994 dgst_pos2 = 2;
8995 dgst_pos3 = 3;
8996 break;
8997
8998 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8999 salt_type = SALT_TYPE_NONE;
9000 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9001 opts_type = OPTS_TYPE_PT_GENERATE_BE
9002 | OPTS_TYPE_PT_ADD80;
9003 kern_type = KERN_TYPE_WHIRLPOOL;
9004 dgst_size = DGST_SIZE_4_16;
9005 parse_func = whirlpool_parse_hash;
9006 sort_by_digest = sort_by_digest_4_16;
9007 opti_type = OPTI_TYPE_ZERO_BYTE;
9008 dgst_pos0 = 0;
9009 dgst_pos1 = 1;
9010 dgst_pos2 = 2;
9011 dgst_pos3 = 3;
9012 break;
9013
9014 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9015 salt_type = SALT_TYPE_EMBEDDED;
9016 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9017 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9018 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9019 dgst_size = DGST_SIZE_4_5;
9020 parse_func = truecrypt_parse_hash_2k;
9021 sort_by_digest = sort_by_digest_4_5;
9022 opti_type = OPTI_TYPE_ZERO_BYTE;
9023 dgst_pos0 = 0;
9024 dgst_pos1 = 1;
9025 dgst_pos2 = 2;
9026 dgst_pos3 = 3;
9027 break;
9028
9029 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9030 salt_type = SALT_TYPE_EMBEDDED;
9031 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9032 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9033 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9034 dgst_size = DGST_SIZE_4_5;
9035 parse_func = truecrypt_parse_hash_2k;
9036 sort_by_digest = sort_by_digest_4_5;
9037 opti_type = OPTI_TYPE_ZERO_BYTE;
9038 dgst_pos0 = 0;
9039 dgst_pos1 = 1;
9040 dgst_pos2 = 2;
9041 dgst_pos3 = 3;
9042 break;
9043
9044 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9045 salt_type = SALT_TYPE_EMBEDDED;
9046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9047 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9048 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9049 dgst_size = DGST_SIZE_4_5;
9050 parse_func = truecrypt_parse_hash_2k;
9051 sort_by_digest = sort_by_digest_4_5;
9052 opti_type = OPTI_TYPE_ZERO_BYTE;
9053 dgst_pos0 = 0;
9054 dgst_pos1 = 1;
9055 dgst_pos2 = 2;
9056 dgst_pos3 = 3;
9057 break;
9058
9059 case 6221: hash_type = HASH_TYPE_SHA512;
9060 salt_type = SALT_TYPE_EMBEDDED;
9061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9062 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9063 kern_type = KERN_TYPE_TCSHA512_XTS512;
9064 dgst_size = DGST_SIZE_8_8;
9065 parse_func = truecrypt_parse_hash_1k;
9066 sort_by_digest = sort_by_digest_8_8;
9067 opti_type = OPTI_TYPE_ZERO_BYTE
9068 | OPTI_TYPE_USES_BITS_64;
9069 dgst_pos0 = 0;
9070 dgst_pos1 = 1;
9071 dgst_pos2 = 2;
9072 dgst_pos3 = 3;
9073 break;
9074
9075 case 6222: hash_type = HASH_TYPE_SHA512;
9076 salt_type = SALT_TYPE_EMBEDDED;
9077 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9078 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9079 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9080 dgst_size = DGST_SIZE_8_8;
9081 parse_func = truecrypt_parse_hash_1k;
9082 sort_by_digest = sort_by_digest_8_8;
9083 opti_type = OPTI_TYPE_ZERO_BYTE
9084 | OPTI_TYPE_USES_BITS_64;
9085 dgst_pos0 = 0;
9086 dgst_pos1 = 1;
9087 dgst_pos2 = 2;
9088 dgst_pos3 = 3;
9089 break;
9090
9091 case 6223: hash_type = HASH_TYPE_SHA512;
9092 salt_type = SALT_TYPE_EMBEDDED;
9093 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9094 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9095 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9096 dgst_size = DGST_SIZE_8_8;
9097 parse_func = truecrypt_parse_hash_1k;
9098 sort_by_digest = sort_by_digest_8_8;
9099 opti_type = OPTI_TYPE_ZERO_BYTE
9100 | OPTI_TYPE_USES_BITS_64;
9101 dgst_pos0 = 0;
9102 dgst_pos1 = 1;
9103 dgst_pos2 = 2;
9104 dgst_pos3 = 3;
9105 break;
9106
9107 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9108 salt_type = SALT_TYPE_EMBEDDED;
9109 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9110 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9111 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9112 dgst_size = DGST_SIZE_4_8;
9113 parse_func = truecrypt_parse_hash_1k;
9114 sort_by_digest = sort_by_digest_4_8;
9115 opti_type = OPTI_TYPE_ZERO_BYTE;
9116 dgst_pos0 = 0;
9117 dgst_pos1 = 1;
9118 dgst_pos2 = 2;
9119 dgst_pos3 = 3;
9120 break;
9121
9122 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9123 salt_type = SALT_TYPE_EMBEDDED;
9124 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9125 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9126 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9127 dgst_size = DGST_SIZE_4_8;
9128 parse_func = truecrypt_parse_hash_1k;
9129 sort_by_digest = sort_by_digest_4_8;
9130 opti_type = OPTI_TYPE_ZERO_BYTE;
9131 dgst_pos0 = 0;
9132 dgst_pos1 = 1;
9133 dgst_pos2 = 2;
9134 dgst_pos3 = 3;
9135 break;
9136
9137 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9138 salt_type = SALT_TYPE_EMBEDDED;
9139 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9140 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9141 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9142 dgst_size = DGST_SIZE_4_8;
9143 parse_func = truecrypt_parse_hash_1k;
9144 sort_by_digest = sort_by_digest_4_8;
9145 opti_type = OPTI_TYPE_ZERO_BYTE;
9146 dgst_pos0 = 0;
9147 dgst_pos1 = 1;
9148 dgst_pos2 = 2;
9149 dgst_pos3 = 3;
9150 break;
9151
9152 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9153 salt_type = SALT_TYPE_EMBEDDED;
9154 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9155 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9156 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9157 dgst_size = DGST_SIZE_4_5;
9158 parse_func = truecrypt_parse_hash_1k;
9159 sort_by_digest = sort_by_digest_4_5;
9160 opti_type = OPTI_TYPE_ZERO_BYTE;
9161 dgst_pos0 = 0;
9162 dgst_pos1 = 1;
9163 dgst_pos2 = 2;
9164 dgst_pos3 = 3;
9165 break;
9166
9167 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9168 salt_type = SALT_TYPE_EMBEDDED;
9169 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9170 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9171 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9172 dgst_size = DGST_SIZE_4_5;
9173 parse_func = truecrypt_parse_hash_1k;
9174 sort_by_digest = sort_by_digest_4_5;
9175 opti_type = OPTI_TYPE_ZERO_BYTE;
9176 dgst_pos0 = 0;
9177 dgst_pos1 = 1;
9178 dgst_pos2 = 2;
9179 dgst_pos3 = 3;
9180 break;
9181
9182 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9183 salt_type = SALT_TYPE_EMBEDDED;
9184 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9185 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9186 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9187 dgst_size = DGST_SIZE_4_5;
9188 parse_func = truecrypt_parse_hash_1k;
9189 sort_by_digest = sort_by_digest_4_5;
9190 opti_type = OPTI_TYPE_ZERO_BYTE;
9191 dgst_pos0 = 0;
9192 dgst_pos1 = 1;
9193 dgst_pos2 = 2;
9194 dgst_pos3 = 3;
9195 break;
9196
9197 case 6300: hash_type = HASH_TYPE_MD5;
9198 salt_type = SALT_TYPE_EMBEDDED;
9199 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9200 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9201 kern_type = KERN_TYPE_MD5AIX;
9202 dgst_size = DGST_SIZE_4_4;
9203 parse_func = md5aix_parse_hash;
9204 sort_by_digest = sort_by_digest_4_4;
9205 opti_type = OPTI_TYPE_ZERO_BYTE;
9206 dgst_pos0 = 0;
9207 dgst_pos1 = 1;
9208 dgst_pos2 = 2;
9209 dgst_pos3 = 3;
9210 break;
9211
9212 case 6400: hash_type = HASH_TYPE_SHA256;
9213 salt_type = SALT_TYPE_EMBEDDED;
9214 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9215 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9216 kern_type = KERN_TYPE_SHA256AIX;
9217 dgst_size = DGST_SIZE_4_8;
9218 parse_func = sha256aix_parse_hash;
9219 sort_by_digest = sort_by_digest_4_8;
9220 opti_type = OPTI_TYPE_ZERO_BYTE;
9221 dgst_pos0 = 0;
9222 dgst_pos1 = 1;
9223 dgst_pos2 = 2;
9224 dgst_pos3 = 3;
9225 break;
9226
9227 case 6500: hash_type = HASH_TYPE_SHA512;
9228 salt_type = SALT_TYPE_EMBEDDED;
9229 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9230 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9231 kern_type = KERN_TYPE_SHA512AIX;
9232 dgst_size = DGST_SIZE_8_8;
9233 parse_func = sha512aix_parse_hash;
9234 sort_by_digest = sort_by_digest_8_8;
9235 opti_type = OPTI_TYPE_ZERO_BYTE
9236 | OPTI_TYPE_USES_BITS_64;
9237 dgst_pos0 = 0;
9238 dgst_pos1 = 1;
9239 dgst_pos2 = 2;
9240 dgst_pos3 = 3;
9241 break;
9242
9243 case 6600: hash_type = HASH_TYPE_AES;
9244 salt_type = SALT_TYPE_EMBEDDED;
9245 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9246 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9247 kern_type = KERN_TYPE_AGILEKEY;
9248 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9249 parse_func = agilekey_parse_hash;
9250 sort_by_digest = sort_by_digest_4_5;
9251 opti_type = OPTI_TYPE_ZERO_BYTE;
9252 dgst_pos0 = 0;
9253 dgst_pos1 = 1;
9254 dgst_pos2 = 2;
9255 dgst_pos3 = 3;
9256 break;
9257
9258 case 6700: hash_type = HASH_TYPE_SHA1;
9259 salt_type = SALT_TYPE_EMBEDDED;
9260 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9261 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9262 kern_type = KERN_TYPE_SHA1AIX;
9263 dgst_size = DGST_SIZE_4_5;
9264 parse_func = sha1aix_parse_hash;
9265 sort_by_digest = sort_by_digest_4_5;
9266 opti_type = OPTI_TYPE_ZERO_BYTE;
9267 dgst_pos0 = 0;
9268 dgst_pos1 = 1;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 3;
9271 break;
9272
9273 case 6800: hash_type = HASH_TYPE_AES;
9274 salt_type = SALT_TYPE_EMBEDDED;
9275 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9276 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9277 kern_type = KERN_TYPE_LASTPASS;
9278 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9279 parse_func = lastpass_parse_hash;
9280 sort_by_digest = sort_by_digest_4_8;
9281 opti_type = OPTI_TYPE_ZERO_BYTE;
9282 dgst_pos0 = 0;
9283 dgst_pos1 = 1;
9284 dgst_pos2 = 2;
9285 dgst_pos3 = 3;
9286 break;
9287
9288 case 6900: hash_type = HASH_TYPE_GOST;
9289 salt_type = SALT_TYPE_NONE;
9290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9291 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9292 kern_type = KERN_TYPE_GOST;
9293 dgst_size = DGST_SIZE_4_8;
9294 parse_func = gost_parse_hash;
9295 sort_by_digest = sort_by_digest_4_8;
9296 opti_type = OPTI_TYPE_ZERO_BYTE;
9297 dgst_pos0 = 0;
9298 dgst_pos1 = 1;
9299 dgst_pos2 = 2;
9300 dgst_pos3 = 3;
9301 break;
9302
9303 case 7100: hash_type = HASH_TYPE_SHA512;
9304 salt_type = SALT_TYPE_EMBEDDED;
9305 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9306 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9307 kern_type = KERN_TYPE_PBKDF2_SHA512;
9308 dgst_size = DGST_SIZE_8_16;
9309 parse_func = sha512osx_parse_hash;
9310 sort_by_digest = sort_by_digest_8_16;
9311 opti_type = OPTI_TYPE_ZERO_BYTE
9312 | OPTI_TYPE_USES_BITS_64
9313 | OPTI_TYPE_SLOW_HASH_SIMD;
9314 dgst_pos0 = 0;
9315 dgst_pos1 = 1;
9316 dgst_pos2 = 2;
9317 dgst_pos3 = 3;
9318 break;
9319
9320 case 7200: hash_type = HASH_TYPE_SHA512;
9321 salt_type = SALT_TYPE_EMBEDDED;
9322 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9323 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9324 kern_type = KERN_TYPE_PBKDF2_SHA512;
9325 dgst_size = DGST_SIZE_8_16;
9326 parse_func = sha512grub_parse_hash;
9327 sort_by_digest = sort_by_digest_8_16;
9328 opti_type = OPTI_TYPE_ZERO_BYTE
9329 | OPTI_TYPE_USES_BITS_64
9330 | OPTI_TYPE_SLOW_HASH_SIMD;
9331 dgst_pos0 = 0;
9332 dgst_pos1 = 1;
9333 dgst_pos2 = 2;
9334 dgst_pos3 = 3;
9335 break;
9336
9337 case 7300: hash_type = HASH_TYPE_SHA1;
9338 salt_type = SALT_TYPE_EMBEDDED;
9339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9340 opts_type = OPTS_TYPE_PT_GENERATE_BE
9341 | OPTS_TYPE_ST_ADD80
9342 | OPTS_TYPE_ST_ADDBITS15;
9343 kern_type = KERN_TYPE_RAKP;
9344 dgst_size = DGST_SIZE_4_5;
9345 parse_func = rakp_parse_hash;
9346 sort_by_digest = sort_by_digest_4_5;
9347 opti_type = OPTI_TYPE_ZERO_BYTE
9348 | OPTI_TYPE_NOT_ITERATED;
9349 dgst_pos0 = 3;
9350 dgst_pos1 = 4;
9351 dgst_pos2 = 2;
9352 dgst_pos3 = 1;
9353 break;
9354
9355 case 7400: hash_type = HASH_TYPE_SHA256;
9356 salt_type = SALT_TYPE_EMBEDDED;
9357 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9358 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9359 kern_type = KERN_TYPE_SHA256CRYPT;
9360 dgst_size = DGST_SIZE_4_8;
9361 parse_func = sha256crypt_parse_hash;
9362 sort_by_digest = sort_by_digest_4_8;
9363 opti_type = OPTI_TYPE_ZERO_BYTE;
9364 dgst_pos0 = 0;
9365 dgst_pos1 = 1;
9366 dgst_pos2 = 2;
9367 dgst_pos3 = 3;
9368 break;
9369
9370 case 7500: hash_type = HASH_TYPE_KRB5PA;
9371 salt_type = SALT_TYPE_EMBEDDED;
9372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9373 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9374 kern_type = KERN_TYPE_KRB5PA;
9375 dgst_size = DGST_SIZE_4_4;
9376 parse_func = krb5pa_parse_hash;
9377 sort_by_digest = sort_by_digest_4_4;
9378 opti_type = OPTI_TYPE_ZERO_BYTE
9379 | OPTI_TYPE_NOT_ITERATED;
9380 dgst_pos0 = 0;
9381 dgst_pos1 = 1;
9382 dgst_pos2 = 2;
9383 dgst_pos3 = 3;
9384 break;
9385
9386 case 7600: hash_type = HASH_TYPE_SHA1;
9387 salt_type = SALT_TYPE_INTERN;
9388 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9389 opts_type = OPTS_TYPE_PT_GENERATE_BE
9390 | OPTS_TYPE_PT_ADD80
9391 | OPTS_TYPE_PT_ADDBITS15;
9392 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9393 dgst_size = DGST_SIZE_4_5;
9394 parse_func = redmine_parse_hash;
9395 sort_by_digest = sort_by_digest_4_5;
9396 opti_type = OPTI_TYPE_ZERO_BYTE
9397 | OPTI_TYPE_PRECOMPUTE_INIT
9398 | OPTI_TYPE_EARLY_SKIP
9399 | OPTI_TYPE_NOT_ITERATED
9400 | OPTI_TYPE_PREPENDED_SALT;
9401 dgst_pos0 = 3;
9402 dgst_pos1 = 4;
9403 dgst_pos2 = 2;
9404 dgst_pos3 = 1;
9405 break;
9406
9407 case 7700: hash_type = HASH_TYPE_SAPB;
9408 salt_type = SALT_TYPE_EMBEDDED;
9409 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9410 opts_type = OPTS_TYPE_PT_GENERATE_LE
9411 | OPTS_TYPE_PT_UPPER
9412 | OPTS_TYPE_ST_UPPER;
9413 kern_type = KERN_TYPE_SAPB;
9414 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9415 parse_func = sapb_parse_hash;
9416 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9417 opti_type = OPTI_TYPE_ZERO_BYTE
9418 | OPTI_TYPE_PRECOMPUTE_INIT
9419 | OPTI_TYPE_NOT_ITERATED;
9420 dgst_pos0 = 0;
9421 dgst_pos1 = 1;
9422 dgst_pos2 = 2;
9423 dgst_pos3 = 3;
9424 break;
9425
9426 case 7800: hash_type = HASH_TYPE_SAPG;
9427 salt_type = SALT_TYPE_EMBEDDED;
9428 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9429 opts_type = OPTS_TYPE_PT_GENERATE_BE
9430 | OPTS_TYPE_ST_ADD80
9431 | OPTS_TYPE_ST_UPPER;
9432 kern_type = KERN_TYPE_SAPG;
9433 dgst_size = DGST_SIZE_4_5;
9434 parse_func = sapg_parse_hash;
9435 sort_by_digest = sort_by_digest_4_5;
9436 opti_type = OPTI_TYPE_ZERO_BYTE
9437 | OPTI_TYPE_PRECOMPUTE_INIT
9438 | OPTI_TYPE_NOT_ITERATED;
9439 dgst_pos0 = 3;
9440 dgst_pos1 = 4;
9441 dgst_pos2 = 2;
9442 dgst_pos3 = 1;
9443 break;
9444
9445 case 7900: hash_type = HASH_TYPE_SHA512;
9446 salt_type = SALT_TYPE_EMBEDDED;
9447 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9448 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9449 kern_type = KERN_TYPE_DRUPAL7;
9450 dgst_size = DGST_SIZE_8_8;
9451 parse_func = drupal7_parse_hash;
9452 sort_by_digest = sort_by_digest_8_8;
9453 opti_type = OPTI_TYPE_ZERO_BYTE
9454 | OPTI_TYPE_USES_BITS_64;
9455 dgst_pos0 = 0;
9456 dgst_pos1 = 1;
9457 dgst_pos2 = 2;
9458 dgst_pos3 = 3;
9459 break;
9460
9461 case 8000: hash_type = HASH_TYPE_SHA256;
9462 salt_type = SALT_TYPE_EMBEDDED;
9463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9464 opts_type = OPTS_TYPE_PT_GENERATE_BE
9465 | OPTS_TYPE_PT_UNICODE
9466 | OPTS_TYPE_ST_ADD80
9467 | OPTS_TYPE_ST_HEX;
9468 kern_type = KERN_TYPE_SYBASEASE;
9469 dgst_size = DGST_SIZE_4_8;
9470 parse_func = sybasease_parse_hash;
9471 sort_by_digest = sort_by_digest_4_8;
9472 opti_type = OPTI_TYPE_ZERO_BYTE
9473 | OPTI_TYPE_PRECOMPUTE_INIT
9474 | OPTI_TYPE_EARLY_SKIP
9475 | OPTI_TYPE_NOT_ITERATED
9476 | OPTI_TYPE_RAW_HASH;
9477 dgst_pos0 = 3;
9478 dgst_pos1 = 7;
9479 dgst_pos2 = 2;
9480 dgst_pos3 = 6;
9481 break;
9482
9483 case 8100: hash_type = HASH_TYPE_SHA1;
9484 salt_type = SALT_TYPE_EMBEDDED;
9485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9486 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9487 kern_type = KERN_TYPE_NETSCALER;
9488 dgst_size = DGST_SIZE_4_5;
9489 parse_func = netscaler_parse_hash;
9490 sort_by_digest = sort_by_digest_4_5;
9491 opti_type = OPTI_TYPE_ZERO_BYTE
9492 | OPTI_TYPE_PRECOMPUTE_INIT
9493 | OPTI_TYPE_PRECOMPUTE_MERKLE
9494 | OPTI_TYPE_EARLY_SKIP
9495 | OPTI_TYPE_NOT_ITERATED
9496 | OPTI_TYPE_PREPENDED_SALT
9497 | OPTI_TYPE_RAW_HASH;
9498 dgst_pos0 = 3;
9499 dgst_pos1 = 4;
9500 dgst_pos2 = 2;
9501 dgst_pos3 = 1;
9502 break;
9503
9504 case 8200: hash_type = HASH_TYPE_SHA256;
9505 salt_type = SALT_TYPE_EMBEDDED;
9506 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9507 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9508 kern_type = KERN_TYPE_CLOUDKEY;
9509 dgst_size = DGST_SIZE_4_8;
9510 parse_func = cloudkey_parse_hash;
9511 sort_by_digest = sort_by_digest_4_8;
9512 opti_type = OPTI_TYPE_ZERO_BYTE;
9513 dgst_pos0 = 0;
9514 dgst_pos1 = 1;
9515 dgst_pos2 = 2;
9516 dgst_pos3 = 3;
9517 break;
9518
9519 case 8300: hash_type = HASH_TYPE_SHA1;
9520 salt_type = SALT_TYPE_EMBEDDED;
9521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9522 opts_type = OPTS_TYPE_PT_GENERATE_BE
9523 | OPTS_TYPE_ST_HEX
9524 | OPTS_TYPE_ST_ADD80;
9525 kern_type = KERN_TYPE_NSEC3;
9526 dgst_size = DGST_SIZE_4_5;
9527 parse_func = nsec3_parse_hash;
9528 sort_by_digest = sort_by_digest_4_5;
9529 opti_type = OPTI_TYPE_ZERO_BYTE;
9530 dgst_pos0 = 3;
9531 dgst_pos1 = 4;
9532 dgst_pos2 = 2;
9533 dgst_pos3 = 1;
9534 break;
9535
9536 case 8400: hash_type = HASH_TYPE_SHA1;
9537 salt_type = SALT_TYPE_INTERN;
9538 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9539 opts_type = OPTS_TYPE_PT_GENERATE_BE
9540 | OPTS_TYPE_PT_ADD80
9541 | OPTS_TYPE_PT_ADDBITS15;
9542 kern_type = KERN_TYPE_WBB3;
9543 dgst_size = DGST_SIZE_4_5;
9544 parse_func = wbb3_parse_hash;
9545 sort_by_digest = sort_by_digest_4_5;
9546 opti_type = OPTI_TYPE_ZERO_BYTE
9547 | OPTI_TYPE_PRECOMPUTE_INIT
9548 | OPTI_TYPE_NOT_ITERATED;
9549 dgst_pos0 = 3;
9550 dgst_pos1 = 4;
9551 dgst_pos2 = 2;
9552 dgst_pos3 = 1;
9553 break;
9554
9555 case 8500: hash_type = HASH_TYPE_DESRACF;
9556 salt_type = SALT_TYPE_EMBEDDED;
9557 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9558 opts_type = OPTS_TYPE_PT_GENERATE_LE
9559 | OPTS_TYPE_ST_UPPER;
9560 kern_type = KERN_TYPE_RACF;
9561 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9562 parse_func = racf_parse_hash;
9563 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9564 opti_type = OPTI_TYPE_ZERO_BYTE
9565 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9566 dgst_pos0 = 0;
9567 dgst_pos1 = 1;
9568 dgst_pos2 = 2;
9569 dgst_pos3 = 3;
9570 break;
9571
9572 case 8600: hash_type = HASH_TYPE_LOTUS5;
9573 salt_type = SALT_TYPE_NONE;
9574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9575 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9576 kern_type = KERN_TYPE_LOTUS5;
9577 dgst_size = DGST_SIZE_4_4;
9578 parse_func = lotus5_parse_hash;
9579 sort_by_digest = sort_by_digest_4_4;
9580 opti_type = OPTI_TYPE_EARLY_SKIP
9581 | OPTI_TYPE_NOT_ITERATED
9582 | OPTI_TYPE_NOT_SALTED
9583 | OPTI_TYPE_RAW_HASH;
9584 dgst_pos0 = 0;
9585 dgst_pos1 = 1;
9586 dgst_pos2 = 2;
9587 dgst_pos3 = 3;
9588 break;
9589
9590 case 8700: hash_type = HASH_TYPE_LOTUS6;
9591 salt_type = SALT_TYPE_EMBEDDED;
9592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9593 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9594 kern_type = KERN_TYPE_LOTUS6;
9595 dgst_size = DGST_SIZE_4_4;
9596 parse_func = lotus6_parse_hash;
9597 sort_by_digest = sort_by_digest_4_4;
9598 opti_type = OPTI_TYPE_EARLY_SKIP
9599 | OPTI_TYPE_NOT_ITERATED
9600 | OPTI_TYPE_RAW_HASH;
9601 dgst_pos0 = 0;
9602 dgst_pos1 = 1;
9603 dgst_pos2 = 2;
9604 dgst_pos3 = 3;
9605 break;
9606
9607 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9608 salt_type = SALT_TYPE_EMBEDDED;
9609 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9610 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9611 kern_type = KERN_TYPE_ANDROIDFDE;
9612 dgst_size = DGST_SIZE_4_4;
9613 parse_func = androidfde_parse_hash;
9614 sort_by_digest = sort_by_digest_4_4;
9615 opti_type = OPTI_TYPE_ZERO_BYTE;
9616 dgst_pos0 = 0;
9617 dgst_pos1 = 1;
9618 dgst_pos2 = 2;
9619 dgst_pos3 = 3;
9620 break;
9621
9622 case 8900: hash_type = HASH_TYPE_SCRYPT;
9623 salt_type = SALT_TYPE_EMBEDDED;
9624 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9625 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9626 kern_type = KERN_TYPE_SCRYPT;
9627 dgst_size = DGST_SIZE_4_8;
9628 parse_func = scrypt_parse_hash;
9629 sort_by_digest = sort_by_digest_4_8;
9630 opti_type = OPTI_TYPE_ZERO_BYTE;
9631 dgst_pos0 = 0;
9632 dgst_pos1 = 1;
9633 dgst_pos2 = 2;
9634 dgst_pos3 = 3;
9635 break;
9636
9637 case 9000: hash_type = HASH_TYPE_SHA1;
9638 salt_type = SALT_TYPE_EMBEDDED;
9639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9640 opts_type = OPTS_TYPE_PT_GENERATE_LE
9641 | OPTS_TYPE_ST_GENERATE_LE;
9642 kern_type = KERN_TYPE_PSAFE2;
9643 dgst_size = DGST_SIZE_4_5;
9644 parse_func = psafe2_parse_hash;
9645 sort_by_digest = sort_by_digest_4_5;
9646 opti_type = OPTI_TYPE_ZERO_BYTE;
9647 dgst_pos0 = 0;
9648 dgst_pos1 = 1;
9649 dgst_pos2 = 2;
9650 dgst_pos3 = 3;
9651 break;
9652
9653 case 9100: hash_type = HASH_TYPE_LOTUS8;
9654 salt_type = SALT_TYPE_EMBEDDED;
9655 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9656 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9657 kern_type = KERN_TYPE_LOTUS8;
9658 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9659 parse_func = lotus8_parse_hash;
9660 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9661 opti_type = OPTI_TYPE_ZERO_BYTE;
9662 dgst_pos0 = 0;
9663 dgst_pos1 = 1;
9664 dgst_pos2 = 2;
9665 dgst_pos3 = 3;
9666 break;
9667
9668 case 9200: hash_type = HASH_TYPE_SHA256;
9669 salt_type = SALT_TYPE_EMBEDDED;
9670 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9671 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9672 kern_type = KERN_TYPE_PBKDF2_SHA256;
9673 dgst_size = DGST_SIZE_4_32;
9674 parse_func = cisco8_parse_hash;
9675 sort_by_digest = sort_by_digest_4_32;
9676 opti_type = OPTI_TYPE_ZERO_BYTE
9677 | OPTI_TYPE_SLOW_HASH_SIMD;
9678 dgst_pos0 = 0;
9679 dgst_pos1 = 1;
9680 dgst_pos2 = 2;
9681 dgst_pos3 = 3;
9682 break;
9683
9684 case 9300: hash_type = HASH_TYPE_SCRYPT;
9685 salt_type = SALT_TYPE_EMBEDDED;
9686 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9687 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9688 kern_type = KERN_TYPE_SCRYPT;
9689 dgst_size = DGST_SIZE_4_8;
9690 parse_func = cisco9_parse_hash;
9691 sort_by_digest = sort_by_digest_4_8;
9692 opti_type = OPTI_TYPE_ZERO_BYTE;
9693 dgst_pos0 = 0;
9694 dgst_pos1 = 1;
9695 dgst_pos2 = 2;
9696 dgst_pos3 = 3;
9697 break;
9698
9699 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9700 salt_type = SALT_TYPE_EMBEDDED;
9701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9702 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9703 kern_type = KERN_TYPE_OFFICE2007;
9704 dgst_size = DGST_SIZE_4_4;
9705 parse_func = office2007_parse_hash;
9706 sort_by_digest = sort_by_digest_4_4;
9707 opti_type = OPTI_TYPE_ZERO_BYTE;
9708 dgst_pos0 = 0;
9709 dgst_pos1 = 1;
9710 dgst_pos2 = 2;
9711 dgst_pos3 = 3;
9712 break;
9713
9714 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9715 salt_type = SALT_TYPE_EMBEDDED;
9716 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9717 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9718 kern_type = KERN_TYPE_OFFICE2010;
9719 dgst_size = DGST_SIZE_4_4;
9720 parse_func = office2010_parse_hash;
9721 sort_by_digest = sort_by_digest_4_4;
9722 opti_type = OPTI_TYPE_ZERO_BYTE;
9723 dgst_pos0 = 0;
9724 dgst_pos1 = 1;
9725 dgst_pos2 = 2;
9726 dgst_pos3 = 3;
9727 break;
9728
9729 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9730 salt_type = SALT_TYPE_EMBEDDED;
9731 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9732 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9733 kern_type = KERN_TYPE_OFFICE2013;
9734 dgst_size = DGST_SIZE_4_4;
9735 parse_func = office2013_parse_hash;
9736 sort_by_digest = sort_by_digest_4_4;
9737 opti_type = OPTI_TYPE_ZERO_BYTE;
9738 dgst_pos0 = 0;
9739 dgst_pos1 = 1;
9740 dgst_pos2 = 2;
9741 dgst_pos3 = 3;
9742 break;
9743
9744 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9745 salt_type = SALT_TYPE_EMBEDDED;
9746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9747 opts_type = OPTS_TYPE_PT_GENERATE_LE
9748 | OPTS_TYPE_PT_ADD80
9749 | OPTS_TYPE_PT_UNICODE;
9750 kern_type = KERN_TYPE_OLDOFFICE01;
9751 dgst_size = DGST_SIZE_4_4;
9752 parse_func = oldoffice01_parse_hash;
9753 sort_by_digest = sort_by_digest_4_4;
9754 opti_type = OPTI_TYPE_ZERO_BYTE
9755 | OPTI_TYPE_PRECOMPUTE_INIT
9756 | OPTI_TYPE_NOT_ITERATED;
9757 dgst_pos0 = 0;
9758 dgst_pos1 = 1;
9759 dgst_pos2 = 2;
9760 dgst_pos3 = 3;
9761 break;
9762
9763 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9764 salt_type = SALT_TYPE_EMBEDDED;
9765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9766 opts_type = OPTS_TYPE_PT_GENERATE_LE
9767 | OPTS_TYPE_PT_ADD80;
9768 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9769 dgst_size = DGST_SIZE_4_4;
9770 parse_func = oldoffice01cm1_parse_hash;
9771 sort_by_digest = sort_by_digest_4_4;
9772 opti_type = OPTI_TYPE_ZERO_BYTE
9773 | OPTI_TYPE_PRECOMPUTE_INIT
9774 | OPTI_TYPE_NOT_ITERATED;
9775 dgst_pos0 = 0;
9776 dgst_pos1 = 1;
9777 dgst_pos2 = 2;
9778 dgst_pos3 = 3;
9779 break;
9780
9781 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9782 salt_type = SALT_TYPE_EMBEDDED;
9783 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9784 opts_type = OPTS_TYPE_PT_GENERATE_LE
9785 | OPTS_TYPE_PT_ADD80
9786 | OPTS_TYPE_PT_UNICODE
9787 | OPTS_TYPE_PT_NEVERCRACK;
9788 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9789 dgst_size = DGST_SIZE_4_4;
9790 parse_func = oldoffice01cm2_parse_hash;
9791 sort_by_digest = sort_by_digest_4_4;
9792 opti_type = OPTI_TYPE_ZERO_BYTE
9793 | OPTI_TYPE_PRECOMPUTE_INIT
9794 | OPTI_TYPE_NOT_ITERATED;
9795 dgst_pos0 = 0;
9796 dgst_pos1 = 1;
9797 dgst_pos2 = 2;
9798 dgst_pos3 = 3;
9799 break;
9800
9801 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9802 salt_type = SALT_TYPE_EMBEDDED;
9803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9804 opts_type = OPTS_TYPE_PT_GENERATE_BE
9805 | OPTS_TYPE_PT_ADD80
9806 | OPTS_TYPE_PT_UNICODE;
9807 kern_type = KERN_TYPE_OLDOFFICE34;
9808 dgst_size = DGST_SIZE_4_4;
9809 parse_func = oldoffice34_parse_hash;
9810 sort_by_digest = sort_by_digest_4_4;
9811 opti_type = OPTI_TYPE_ZERO_BYTE
9812 | OPTI_TYPE_PRECOMPUTE_INIT
9813 | OPTI_TYPE_NOT_ITERATED;
9814 dgst_pos0 = 0;
9815 dgst_pos1 = 1;
9816 dgst_pos2 = 2;
9817 dgst_pos3 = 3;
9818 break;
9819
9820 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9821 salt_type = SALT_TYPE_EMBEDDED;
9822 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9823 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9824 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9825 dgst_size = DGST_SIZE_4_4;
9826 parse_func = oldoffice34cm1_parse_hash;
9827 sort_by_digest = sort_by_digest_4_4;
9828 opti_type = OPTI_TYPE_ZERO_BYTE
9829 | OPTI_TYPE_PRECOMPUTE_INIT
9830 | OPTI_TYPE_NOT_ITERATED;
9831 dgst_pos0 = 0;
9832 dgst_pos1 = 1;
9833 dgst_pos2 = 2;
9834 dgst_pos3 = 3;
9835 break;
9836
9837 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9838 salt_type = SALT_TYPE_EMBEDDED;
9839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9840 opts_type = OPTS_TYPE_PT_GENERATE_BE
9841 | OPTS_TYPE_PT_ADD80
9842 | OPTS_TYPE_PT_UNICODE
9843 | OPTS_TYPE_PT_NEVERCRACK;
9844 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9845 dgst_size = DGST_SIZE_4_4;
9846 parse_func = oldoffice34cm2_parse_hash;
9847 sort_by_digest = sort_by_digest_4_4;
9848 opti_type = OPTI_TYPE_ZERO_BYTE
9849 | OPTI_TYPE_PRECOMPUTE_INIT
9850 | OPTI_TYPE_NOT_ITERATED;
9851 dgst_pos0 = 0;
9852 dgst_pos1 = 1;
9853 dgst_pos2 = 2;
9854 dgst_pos3 = 3;
9855 break;
9856
9857 case 9900: hash_type = HASH_TYPE_MD5;
9858 salt_type = SALT_TYPE_NONE;
9859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9860 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9861 kern_type = KERN_TYPE_RADMIN2;
9862 dgst_size = DGST_SIZE_4_4;
9863 parse_func = radmin2_parse_hash;
9864 sort_by_digest = sort_by_digest_4_4;
9865 opti_type = OPTI_TYPE_ZERO_BYTE
9866 | OPTI_TYPE_PRECOMPUTE_INIT
9867 | OPTI_TYPE_EARLY_SKIP
9868 | OPTI_TYPE_NOT_ITERATED
9869 | OPTI_TYPE_NOT_SALTED;
9870 dgst_pos0 = 0;
9871 dgst_pos1 = 3;
9872 dgst_pos2 = 2;
9873 dgst_pos3 = 1;
9874 break;
9875
9876 case 10000: hash_type = HASH_TYPE_SHA256;
9877 salt_type = SALT_TYPE_EMBEDDED;
9878 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9879 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9880 kern_type = KERN_TYPE_PBKDF2_SHA256;
9881 dgst_size = DGST_SIZE_4_32;
9882 parse_func = djangopbkdf2_parse_hash;
9883 sort_by_digest = sort_by_digest_4_32;
9884 opti_type = OPTI_TYPE_ZERO_BYTE
9885 | OPTI_TYPE_SLOW_HASH_SIMD;
9886 dgst_pos0 = 0;
9887 dgst_pos1 = 1;
9888 dgst_pos2 = 2;
9889 dgst_pos3 = 3;
9890 break;
9891
9892 case 10100: hash_type = HASH_TYPE_SIPHASH;
9893 salt_type = SALT_TYPE_EMBEDDED;
9894 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9895 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9896 kern_type = KERN_TYPE_SIPHASH;
9897 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9898 parse_func = siphash_parse_hash;
9899 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9900 opti_type = OPTI_TYPE_ZERO_BYTE
9901 | OPTI_TYPE_NOT_ITERATED
9902 | OPTI_TYPE_RAW_HASH;
9903 dgst_pos0 = 0;
9904 dgst_pos1 = 1;
9905 dgst_pos2 = 2;
9906 dgst_pos3 = 3;
9907 break;
9908
9909 case 10200: hash_type = HASH_TYPE_MD5;
9910 salt_type = SALT_TYPE_EMBEDDED;
9911 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9912 opts_type = OPTS_TYPE_PT_GENERATE_LE
9913 | OPTS_TYPE_ST_ADD80
9914 | OPTS_TYPE_ST_ADDBITS14;
9915 kern_type = KERN_TYPE_HMACMD5_PW;
9916 dgst_size = DGST_SIZE_4_4;
9917 parse_func = crammd5_parse_hash;
9918 sort_by_digest = sort_by_digest_4_4;
9919 opti_type = OPTI_TYPE_ZERO_BYTE
9920 | OPTI_TYPE_NOT_ITERATED;
9921 dgst_pos0 = 0;
9922 dgst_pos1 = 3;
9923 dgst_pos2 = 2;
9924 dgst_pos3 = 1;
9925 break;
9926
9927 case 10300: hash_type = HASH_TYPE_SHA1;
9928 salt_type = SALT_TYPE_EMBEDDED;
9929 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9930 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9931 kern_type = KERN_TYPE_SAPH_SHA1;
9932 dgst_size = DGST_SIZE_4_5;
9933 parse_func = saph_sha1_parse_hash;
9934 sort_by_digest = sort_by_digest_4_5;
9935 opti_type = OPTI_TYPE_ZERO_BYTE;
9936 dgst_pos0 = 0;
9937 dgst_pos1 = 1;
9938 dgst_pos2 = 2;
9939 dgst_pos3 = 3;
9940 break;
9941
9942 case 10400: hash_type = HASH_TYPE_PDFU16;
9943 salt_type = SALT_TYPE_EMBEDDED;
9944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9945 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9946 kern_type = KERN_TYPE_PDF11;
9947 dgst_size = DGST_SIZE_4_4;
9948 parse_func = pdf11_parse_hash;
9949 sort_by_digest = sort_by_digest_4_4;
9950 opti_type = OPTI_TYPE_ZERO_BYTE
9951 | OPTI_TYPE_NOT_ITERATED;
9952 dgst_pos0 = 0;
9953 dgst_pos1 = 1;
9954 dgst_pos2 = 2;
9955 dgst_pos3 = 3;
9956 break;
9957
9958 case 10410: hash_type = HASH_TYPE_PDFU16;
9959 salt_type = SALT_TYPE_EMBEDDED;
9960 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9961 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9962 kern_type = KERN_TYPE_PDF11CM1;
9963 dgst_size = DGST_SIZE_4_4;
9964 parse_func = pdf11cm1_parse_hash;
9965 sort_by_digest = sort_by_digest_4_4;
9966 opti_type = OPTI_TYPE_ZERO_BYTE
9967 | OPTI_TYPE_NOT_ITERATED;
9968 dgst_pos0 = 0;
9969 dgst_pos1 = 1;
9970 dgst_pos2 = 2;
9971 dgst_pos3 = 3;
9972 break;
9973
9974 case 10420: hash_type = HASH_TYPE_PDFU16;
9975 salt_type = SALT_TYPE_EMBEDDED;
9976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9977 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9978 kern_type = KERN_TYPE_PDF11CM2;
9979 dgst_size = DGST_SIZE_4_4;
9980 parse_func = pdf11cm2_parse_hash;
9981 sort_by_digest = sort_by_digest_4_4;
9982 opti_type = OPTI_TYPE_ZERO_BYTE
9983 | OPTI_TYPE_NOT_ITERATED;
9984 dgst_pos0 = 0;
9985 dgst_pos1 = 1;
9986 dgst_pos2 = 2;
9987 dgst_pos3 = 3;
9988 break;
9989
9990 case 10500: hash_type = HASH_TYPE_PDFU16;
9991 salt_type = SALT_TYPE_EMBEDDED;
9992 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9993 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9994 kern_type = KERN_TYPE_PDF14;
9995 dgst_size = DGST_SIZE_4_4;
9996 parse_func = pdf14_parse_hash;
9997 sort_by_digest = sort_by_digest_4_4;
9998 opti_type = OPTI_TYPE_ZERO_BYTE
9999 | OPTI_TYPE_NOT_ITERATED;
10000 dgst_pos0 = 0;
10001 dgst_pos1 = 1;
10002 dgst_pos2 = 2;
10003 dgst_pos3 = 3;
10004 break;
10005
10006 case 10600: hash_type = HASH_TYPE_SHA256;
10007 salt_type = SALT_TYPE_EMBEDDED;
10008 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10009 opts_type = OPTS_TYPE_PT_GENERATE_BE
10010 | OPTS_TYPE_ST_ADD80
10011 | OPTS_TYPE_ST_ADDBITS15
10012 | OPTS_TYPE_HASH_COPY;
10013 kern_type = KERN_TYPE_SHA256_PWSLT;
10014 dgst_size = DGST_SIZE_4_8;
10015 parse_func = pdf17l3_parse_hash;
10016 sort_by_digest = sort_by_digest_4_8;
10017 opti_type = OPTI_TYPE_ZERO_BYTE
10018 | OPTI_TYPE_PRECOMPUTE_INIT
10019 | OPTI_TYPE_PRECOMPUTE_MERKLE
10020 | OPTI_TYPE_EARLY_SKIP
10021 | OPTI_TYPE_NOT_ITERATED
10022 | OPTI_TYPE_APPENDED_SALT
10023 | OPTI_TYPE_RAW_HASH;
10024 dgst_pos0 = 3;
10025 dgst_pos1 = 7;
10026 dgst_pos2 = 2;
10027 dgst_pos3 = 6;
10028 break;
10029
10030 case 10700: hash_type = HASH_TYPE_PDFU32;
10031 salt_type = SALT_TYPE_EMBEDDED;
10032 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10033 opts_type = OPTS_TYPE_PT_GENERATE_LE
10034 | OPTS_TYPE_HASH_COPY;
10035 kern_type = KERN_TYPE_PDF17L8;
10036 dgst_size = DGST_SIZE_4_8;
10037 parse_func = pdf17l8_parse_hash;
10038 sort_by_digest = sort_by_digest_4_8;
10039 opti_type = OPTI_TYPE_ZERO_BYTE
10040 | OPTI_TYPE_NOT_ITERATED;
10041 dgst_pos0 = 0;
10042 dgst_pos1 = 1;
10043 dgst_pos2 = 2;
10044 dgst_pos3 = 3;
10045 break;
10046
10047 case 10800: hash_type = HASH_TYPE_SHA384;
10048 salt_type = SALT_TYPE_NONE;
10049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10050 opts_type = OPTS_TYPE_PT_GENERATE_BE
10051 | OPTS_TYPE_PT_ADD80
10052 | OPTS_TYPE_PT_ADDBITS15;
10053 kern_type = KERN_TYPE_SHA384;
10054 dgst_size = DGST_SIZE_8_8;
10055 parse_func = sha384_parse_hash;
10056 sort_by_digest = sort_by_digest_8_8;
10057 opti_type = OPTI_TYPE_ZERO_BYTE
10058 | OPTI_TYPE_PRECOMPUTE_INIT
10059 | OPTI_TYPE_PRECOMPUTE_MERKLE
10060 | OPTI_TYPE_EARLY_SKIP
10061 | OPTI_TYPE_NOT_ITERATED
10062 | OPTI_TYPE_NOT_SALTED
10063 | OPTI_TYPE_USES_BITS_64
10064 | OPTI_TYPE_RAW_HASH;
10065 dgst_pos0 = 6;
10066 dgst_pos1 = 7;
10067 dgst_pos2 = 4;
10068 dgst_pos3 = 5;
10069 break;
10070
10071 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10072 salt_type = SALT_TYPE_EMBEDDED;
10073 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10074 opts_type = OPTS_TYPE_PT_GENERATE_LE
10075 | OPTS_TYPE_ST_BASE64
10076 | OPTS_TYPE_HASH_COPY;
10077 kern_type = KERN_TYPE_PBKDF2_SHA256;
10078 dgst_size = DGST_SIZE_4_32;
10079 parse_func = pbkdf2_sha256_parse_hash;
10080 sort_by_digest = sort_by_digest_4_32;
10081 opti_type = OPTI_TYPE_ZERO_BYTE
10082 | OPTI_TYPE_SLOW_HASH_SIMD;
10083 dgst_pos0 = 0;
10084 dgst_pos1 = 1;
10085 dgst_pos2 = 2;
10086 dgst_pos3 = 3;
10087 break;
10088
10089 case 11000: hash_type = HASH_TYPE_MD5;
10090 salt_type = SALT_TYPE_INTERN;
10091 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10092 opts_type = OPTS_TYPE_PT_GENERATE_LE
10093 | OPTS_TYPE_PT_ADD80;
10094 kern_type = KERN_TYPE_PRESTASHOP;
10095 dgst_size = DGST_SIZE_4_4;
10096 parse_func = prestashop_parse_hash;
10097 sort_by_digest = sort_by_digest_4_4;
10098 opti_type = OPTI_TYPE_ZERO_BYTE
10099 | OPTI_TYPE_PRECOMPUTE_INIT
10100 | OPTI_TYPE_NOT_ITERATED
10101 | OPTI_TYPE_PREPENDED_SALT;
10102 dgst_pos0 = 0;
10103 dgst_pos1 = 3;
10104 dgst_pos2 = 2;
10105 dgst_pos3 = 1;
10106 break;
10107
10108 case 11100: hash_type = HASH_TYPE_MD5;
10109 salt_type = SALT_TYPE_EMBEDDED;
10110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10111 opts_type = OPTS_TYPE_PT_GENERATE_LE
10112 | OPTS_TYPE_ST_ADD80;
10113 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10114 dgst_size = DGST_SIZE_4_4;
10115 parse_func = postgresql_auth_parse_hash;
10116 sort_by_digest = sort_by_digest_4_4;
10117 opti_type = OPTI_TYPE_ZERO_BYTE
10118 | OPTI_TYPE_PRECOMPUTE_INIT
10119 | OPTI_TYPE_PRECOMPUTE_MERKLE
10120 | OPTI_TYPE_EARLY_SKIP;
10121 dgst_pos0 = 0;
10122 dgst_pos1 = 3;
10123 dgst_pos2 = 2;
10124 dgst_pos3 = 1;
10125 break;
10126
10127 case 11200: hash_type = HASH_TYPE_SHA1;
10128 salt_type = SALT_TYPE_EMBEDDED;
10129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10130 opts_type = OPTS_TYPE_PT_GENERATE_BE
10131 | OPTS_TYPE_PT_ADD80
10132 | OPTS_TYPE_ST_HEX;
10133 kern_type = KERN_TYPE_MYSQL_AUTH;
10134 dgst_size = DGST_SIZE_4_5;
10135 parse_func = mysql_auth_parse_hash;
10136 sort_by_digest = sort_by_digest_4_5;
10137 opti_type = OPTI_TYPE_ZERO_BYTE
10138 | OPTI_TYPE_EARLY_SKIP;
10139 dgst_pos0 = 3;
10140 dgst_pos1 = 4;
10141 dgst_pos2 = 2;
10142 dgst_pos3 = 1;
10143 break;
10144
10145 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10146 salt_type = SALT_TYPE_EMBEDDED;
10147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10148 opts_type = OPTS_TYPE_PT_GENERATE_LE
10149 | OPTS_TYPE_ST_HEX
10150 | OPTS_TYPE_ST_ADD80;
10151 kern_type = KERN_TYPE_BITCOIN_WALLET;
10152 dgst_size = DGST_SIZE_4_4;
10153 parse_func = bitcoin_wallet_parse_hash;
10154 sort_by_digest = sort_by_digest_4_4;
10155 opti_type = OPTI_TYPE_ZERO_BYTE;
10156 dgst_pos0 = 0;
10157 dgst_pos1 = 1;
10158 dgst_pos2 = 2;
10159 dgst_pos3 = 3;
10160 break;
10161
10162 case 11400: hash_type = HASH_TYPE_MD5;
10163 salt_type = SALT_TYPE_EMBEDDED;
10164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10165 opts_type = OPTS_TYPE_PT_GENERATE_LE
10166 | OPTS_TYPE_PT_ADD80
10167 | OPTS_TYPE_HASH_COPY;
10168 kern_type = KERN_TYPE_SIP_AUTH;
10169 dgst_size = DGST_SIZE_4_4;
10170 parse_func = sip_auth_parse_hash;
10171 sort_by_digest = sort_by_digest_4_4;
10172 opti_type = OPTI_TYPE_ZERO_BYTE;
10173 dgst_pos0 = 0;
10174 dgst_pos1 = 3;
10175 dgst_pos2 = 2;
10176 dgst_pos3 = 1;
10177 break;
10178
10179 case 11500: hash_type = HASH_TYPE_CRC32;
10180 salt_type = SALT_TYPE_INTERN;
10181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10182 opts_type = OPTS_TYPE_PT_GENERATE_LE
10183 | OPTS_TYPE_ST_GENERATE_LE
10184 | OPTS_TYPE_ST_HEX;
10185 kern_type = KERN_TYPE_CRC32;
10186 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10187 parse_func = crc32_parse_hash;
10188 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10189 opti_type = OPTI_TYPE_ZERO_BYTE;
10190 dgst_pos0 = 0;
10191 dgst_pos1 = 1;
10192 dgst_pos2 = 2;
10193 dgst_pos3 = 3;
10194 break;
10195
10196 case 11600: hash_type = HASH_TYPE_AES;
10197 salt_type = SALT_TYPE_EMBEDDED;
10198 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10199 opts_type = OPTS_TYPE_PT_GENERATE_LE
10200 | OPTS_TYPE_PT_NEVERCRACK;
10201 kern_type = KERN_TYPE_SEVEN_ZIP;
10202 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10203 parse_func = seven_zip_parse_hash;
10204 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10205 opti_type = OPTI_TYPE_ZERO_BYTE;
10206 dgst_pos0 = 0;
10207 dgst_pos1 = 1;
10208 dgst_pos2 = 2;
10209 dgst_pos3 = 3;
10210 break;
10211
10212 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10213 salt_type = SALT_TYPE_NONE;
10214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10215 opts_type = OPTS_TYPE_PT_GENERATE_LE
10216 | OPTS_TYPE_PT_ADD01;
10217 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10218 dgst_size = DGST_SIZE_4_8;
10219 parse_func = gost2012sbog_256_parse_hash;
10220 sort_by_digest = sort_by_digest_4_8;
10221 opti_type = OPTI_TYPE_ZERO_BYTE;
10222 dgst_pos0 = 0;
10223 dgst_pos1 = 1;
10224 dgst_pos2 = 2;
10225 dgst_pos3 = 3;
10226 break;
10227
10228 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10229 salt_type = SALT_TYPE_NONE;
10230 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10231 opts_type = OPTS_TYPE_PT_GENERATE_LE
10232 | OPTS_TYPE_PT_ADD01;
10233 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10234 dgst_size = DGST_SIZE_4_16;
10235 parse_func = gost2012sbog_512_parse_hash;
10236 sort_by_digest = sort_by_digest_4_16;
10237 opti_type = OPTI_TYPE_ZERO_BYTE;
10238 dgst_pos0 = 0;
10239 dgst_pos1 = 1;
10240 dgst_pos2 = 2;
10241 dgst_pos3 = 3;
10242 break;
10243
10244 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10245 salt_type = SALT_TYPE_EMBEDDED;
10246 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10247 opts_type = OPTS_TYPE_PT_GENERATE_LE
10248 | OPTS_TYPE_ST_BASE64
10249 | OPTS_TYPE_HASH_COPY;
10250 kern_type = KERN_TYPE_PBKDF2_MD5;
10251 dgst_size = DGST_SIZE_4_32;
10252 parse_func = pbkdf2_md5_parse_hash;
10253 sort_by_digest = sort_by_digest_4_32;
10254 opti_type = OPTI_TYPE_ZERO_BYTE
10255 | OPTI_TYPE_SLOW_HASH_SIMD;
10256 dgst_pos0 = 0;
10257 dgst_pos1 = 1;
10258 dgst_pos2 = 2;
10259 dgst_pos3 = 3;
10260 break;
10261
10262 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10263 salt_type = SALT_TYPE_EMBEDDED;
10264 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10265 opts_type = OPTS_TYPE_PT_GENERATE_LE
10266 | OPTS_TYPE_ST_BASE64
10267 | OPTS_TYPE_HASH_COPY;
10268 kern_type = KERN_TYPE_PBKDF2_SHA1;
10269 dgst_size = DGST_SIZE_4_32;
10270 parse_func = pbkdf2_sha1_parse_hash;
10271 sort_by_digest = sort_by_digest_4_32;
10272 opti_type = OPTI_TYPE_ZERO_BYTE
10273 | OPTI_TYPE_SLOW_HASH_SIMD;
10274 dgst_pos0 = 0;
10275 dgst_pos1 = 1;
10276 dgst_pos2 = 2;
10277 dgst_pos3 = 3;
10278 break;
10279
10280 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10281 salt_type = SALT_TYPE_EMBEDDED;
10282 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10283 opts_type = OPTS_TYPE_PT_GENERATE_LE
10284 | OPTS_TYPE_ST_BASE64
10285 | OPTS_TYPE_HASH_COPY;
10286 kern_type = KERN_TYPE_PBKDF2_SHA512;
10287 dgst_size = DGST_SIZE_8_16;
10288 parse_func = pbkdf2_sha512_parse_hash;
10289 sort_by_digest = sort_by_digest_8_16;
10290 opti_type = OPTI_TYPE_ZERO_BYTE
10291 | OPTI_TYPE_USES_BITS_64
10292 | OPTI_TYPE_SLOW_HASH_SIMD;
10293 dgst_pos0 = 0;
10294 dgst_pos1 = 1;
10295 dgst_pos2 = 2;
10296 dgst_pos3 = 3;
10297 break;
10298
10299 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10300 salt_type = SALT_TYPE_EMBEDDED;
10301 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10302 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10303 kern_type = KERN_TYPE_ECRYPTFS;
10304 dgst_size = DGST_SIZE_8_8;
10305 parse_func = ecryptfs_parse_hash;
10306 sort_by_digest = sort_by_digest_8_8;
10307 opti_type = OPTI_TYPE_ZERO_BYTE
10308 | OPTI_TYPE_USES_BITS_64;
10309 dgst_pos0 = 0;
10310 dgst_pos1 = 1;
10311 dgst_pos2 = 2;
10312 dgst_pos3 = 3;
10313 break;
10314
10315 case 12300: hash_type = HASH_TYPE_ORACLET;
10316 salt_type = SALT_TYPE_EMBEDDED;
10317 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10318 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10319 kern_type = KERN_TYPE_ORACLET;
10320 dgst_size = DGST_SIZE_8_16;
10321 parse_func = oraclet_parse_hash;
10322 sort_by_digest = sort_by_digest_8_16;
10323 opti_type = OPTI_TYPE_ZERO_BYTE
10324 | OPTI_TYPE_USES_BITS_64;
10325 dgst_pos0 = 0;
10326 dgst_pos1 = 1;
10327 dgst_pos2 = 2;
10328 dgst_pos3 = 3;
10329 break;
10330
10331 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10332 salt_type = SALT_TYPE_EMBEDDED;
10333 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10334 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10335 kern_type = KERN_TYPE_BSDICRYPT;
10336 dgst_size = DGST_SIZE_4_4;
10337 parse_func = bsdicrypt_parse_hash;
10338 sort_by_digest = sort_by_digest_4_4;
10339 opti_type = OPTI_TYPE_ZERO_BYTE
10340 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10341 dgst_pos0 = 0;
10342 dgst_pos1 = 1;
10343 dgst_pos2 = 2;
10344 dgst_pos3 = 3;
10345 break;
10346
10347 case 12500: hash_type = HASH_TYPE_RAR3HP;
10348 salt_type = SALT_TYPE_EMBEDDED;
10349 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10350 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10351 kern_type = KERN_TYPE_RAR3;
10352 dgst_size = DGST_SIZE_4_4;
10353 parse_func = rar3hp_parse_hash;
10354 sort_by_digest = sort_by_digest_4_4;
10355 opti_type = OPTI_TYPE_ZERO_BYTE;
10356 dgst_pos0 = 0;
10357 dgst_pos1 = 1;
10358 dgst_pos2 = 2;
10359 dgst_pos3 = 3;
10360 break;
10361
10362 case 12600: hash_type = HASH_TYPE_SHA256;
10363 salt_type = SALT_TYPE_INTERN;
10364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10365 opts_type = OPTS_TYPE_PT_GENERATE_BE
10366 | OPTS_TYPE_PT_ADD80;
10367 kern_type = KERN_TYPE_CF10;
10368 dgst_size = DGST_SIZE_4_8;
10369 parse_func = cf10_parse_hash;
10370 sort_by_digest = sort_by_digest_4_8;
10371 opti_type = OPTI_TYPE_ZERO_BYTE
10372 | OPTI_TYPE_PRECOMPUTE_INIT
10373 | OPTI_TYPE_EARLY_SKIP
10374 | OPTI_TYPE_NOT_ITERATED;
10375 dgst_pos0 = 3;
10376 dgst_pos1 = 7;
10377 dgst_pos2 = 2;
10378 dgst_pos3 = 6;
10379 break;
10380
10381 case 12700: hash_type = HASH_TYPE_AES;
10382 salt_type = SALT_TYPE_EMBEDDED;
10383 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10384 opts_type = OPTS_TYPE_PT_GENERATE_LE
10385 | OPTS_TYPE_HASH_COPY;
10386 kern_type = KERN_TYPE_MYWALLET;
10387 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10388 parse_func = mywallet_parse_hash;
10389 sort_by_digest = sort_by_digest_4_5;
10390 opti_type = OPTI_TYPE_ZERO_BYTE;
10391 dgst_pos0 = 0;
10392 dgst_pos1 = 1;
10393 dgst_pos2 = 2;
10394 dgst_pos3 = 3;
10395 break;
10396
10397 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10398 salt_type = SALT_TYPE_EMBEDDED;
10399 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10400 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10401 kern_type = KERN_TYPE_MS_DRSR;
10402 dgst_size = DGST_SIZE_4_8;
10403 parse_func = ms_drsr_parse_hash;
10404 sort_by_digest = sort_by_digest_4_8;
10405 opti_type = OPTI_TYPE_ZERO_BYTE;
10406 dgst_pos0 = 0;
10407 dgst_pos1 = 1;
10408 dgst_pos2 = 2;
10409 dgst_pos3 = 3;
10410 break;
10411
10412 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10413 salt_type = SALT_TYPE_EMBEDDED;
10414 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10415 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10416 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10417 dgst_size = DGST_SIZE_4_8;
10418 parse_func = androidfde_samsung_parse_hash;
10419 sort_by_digest = sort_by_digest_4_8;
10420 opti_type = OPTI_TYPE_ZERO_BYTE;
10421 dgst_pos0 = 0;
10422 dgst_pos1 = 1;
10423 dgst_pos2 = 2;
10424 dgst_pos3 = 3;
10425 break;
10426
10427 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10428 salt_type = SALT_TYPE_EMBEDDED;
10429 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10430 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10431 kern_type = KERN_TYPE_RAR5;
10432 dgst_size = DGST_SIZE_4_4;
10433 parse_func = rar5_parse_hash;
10434 sort_by_digest = sort_by_digest_4_4;
10435 opti_type = OPTI_TYPE_ZERO_BYTE;
10436 dgst_pos0 = 0;
10437 dgst_pos1 = 1;
10438 dgst_pos2 = 2;
10439 dgst_pos3 = 3;
10440 break;
10441
10442 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10443 salt_type = SALT_TYPE_EMBEDDED;
10444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10445 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10446 kern_type = KERN_TYPE_KRB5TGS;
10447 dgst_size = DGST_SIZE_4_4;
10448 parse_func = krb5tgs_parse_hash;
10449 sort_by_digest = sort_by_digest_4_4;
10450 opti_type = OPTI_TYPE_ZERO_BYTE
10451 | OPTI_TYPE_NOT_ITERATED;
10452 dgst_pos0 = 0;
10453 dgst_pos1 = 1;
10454 dgst_pos2 = 2;
10455 dgst_pos3 = 3;
10456 break;
10457
10458 case 13200: hash_type = HASH_TYPE_AES;
10459 salt_type = SALT_TYPE_EMBEDDED;
10460 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10461 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10462 kern_type = KERN_TYPE_AXCRYPT;
10463 dgst_size = DGST_SIZE_4_4;
10464 parse_func = axcrypt_parse_hash;
10465 sort_by_digest = sort_by_digest_4_4;
10466 opti_type = OPTI_TYPE_ZERO_BYTE;
10467 dgst_pos0 = 0;
10468 dgst_pos1 = 1;
10469 dgst_pos2 = 2;
10470 dgst_pos3 = 3;
10471 break;
10472
10473 case 13300: hash_type = HASH_TYPE_SHA1;
10474 salt_type = SALT_TYPE_NONE;
10475 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10476 opts_type = OPTS_TYPE_PT_GENERATE_BE
10477 | OPTS_TYPE_PT_ADD80
10478 | OPTS_TYPE_PT_ADDBITS15;
10479 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10480 dgst_size = DGST_SIZE_4_5;
10481 parse_func = sha1axcrypt_parse_hash;
10482 sort_by_digest = sort_by_digest_4_5;
10483 opti_type = OPTI_TYPE_ZERO_BYTE
10484 | OPTI_TYPE_PRECOMPUTE_INIT
10485 | OPTI_TYPE_EARLY_SKIP
10486 | OPTI_TYPE_NOT_ITERATED
10487 | OPTI_TYPE_NOT_SALTED;
10488 dgst_pos0 = 0;
10489 dgst_pos1 = 4;
10490 dgst_pos2 = 3;
10491 dgst_pos3 = 2;
10492 break;
10493
10494 case 13400: hash_type = HASH_TYPE_AES;
10495 salt_type = SALT_TYPE_EMBEDDED;
10496 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10497 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10498 kern_type = KERN_TYPE_KEEPASS;
10499 dgst_size = DGST_SIZE_4_4;
10500 parse_func = keepass_parse_hash;
10501 sort_by_digest = sort_by_digest_4_4;
10502 opti_type = OPTI_TYPE_ZERO_BYTE;
10503 dgst_pos0 = 0;
10504 dgst_pos1 = 1;
10505 dgst_pos2 = 2;
10506 dgst_pos3 = 3;
10507 break;
10508
10509 case 13500: hash_type = HASH_TYPE_SHA1;
10510 salt_type = SALT_TYPE_EMBEDDED;
10511 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10512 opts_type = OPTS_TYPE_PT_GENERATE_BE
10513 | OPTS_TYPE_PT_UNICODE
10514 | OPTS_TYPE_PT_ADD80;
10515 kern_type = KERN_TYPE_PSTOKEN;
10516 dgst_size = DGST_SIZE_4_5;
10517 parse_func = pstoken_parse_hash;
10518 sort_by_digest = sort_by_digest_4_5;
10519 opti_type = OPTI_TYPE_ZERO_BYTE
10520 | OPTI_TYPE_PRECOMPUTE_INIT
10521 | OPTI_TYPE_EARLY_SKIP
10522 | OPTI_TYPE_NOT_ITERATED
10523 | OPTI_TYPE_PREPENDED_SALT
10524 | OPTI_TYPE_RAW_HASH;
10525 dgst_pos0 = 3;
10526 dgst_pos1 = 4;
10527 dgst_pos2 = 2;
10528 dgst_pos3 = 1;
10529 break;
10530
10531 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10532 salt_type = SALT_TYPE_EMBEDDED;
10533 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10534 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10535 kern_type = KERN_TYPE_ZIP2;
10536 dgst_size = DGST_SIZE_4_4;
10537 parse_func = zip2_parse_hash;
10538 sort_by_digest = sort_by_digest_4_4;
10539 opti_type = OPTI_TYPE_ZERO_BYTE;
10540 dgst_pos0 = 0;
10541 dgst_pos1 = 1;
10542 dgst_pos2 = 2;
10543 dgst_pos3 = 3;
10544 break;
10545
10546 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10547 salt_type = SALT_TYPE_EMBEDDED;
10548 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10549 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10550 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10551 dgst_size = DGST_SIZE_4_5;
10552 parse_func = veracrypt_parse_hash_655331;
10553 sort_by_digest = sort_by_digest_4_5;
10554 opti_type = OPTI_TYPE_ZERO_BYTE;
10555 dgst_pos0 = 0;
10556 dgst_pos1 = 1;
10557 dgst_pos2 = 2;
10558 dgst_pos3 = 3;
10559 break;
10560
10561 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10562 salt_type = SALT_TYPE_EMBEDDED;
10563 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10564 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10565 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10566 dgst_size = DGST_SIZE_4_5;
10567 parse_func = veracrypt_parse_hash_655331;
10568 sort_by_digest = sort_by_digest_4_5;
10569 opti_type = OPTI_TYPE_ZERO_BYTE;
10570 dgst_pos0 = 0;
10571 dgst_pos1 = 1;
10572 dgst_pos2 = 2;
10573 dgst_pos3 = 3;
10574 break;
10575
10576 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10577 salt_type = SALT_TYPE_EMBEDDED;
10578 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10579 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10580 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10581 dgst_size = DGST_SIZE_4_5;
10582 parse_func = veracrypt_parse_hash_655331;
10583 sort_by_digest = sort_by_digest_4_5;
10584 opti_type = OPTI_TYPE_ZERO_BYTE;
10585 dgst_pos0 = 0;
10586 dgst_pos1 = 1;
10587 dgst_pos2 = 2;
10588 dgst_pos3 = 3;
10589 break;
10590
10591 case 13721: hash_type = HASH_TYPE_SHA512;
10592 salt_type = SALT_TYPE_EMBEDDED;
10593 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10594 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10595 kern_type = KERN_TYPE_TCSHA512_XTS512;
10596 dgst_size = DGST_SIZE_8_8;
10597 parse_func = veracrypt_parse_hash_500000;
10598 sort_by_digest = sort_by_digest_8_8;
10599 opti_type = OPTI_TYPE_ZERO_BYTE
10600 | OPTI_TYPE_USES_BITS_64;
10601 dgst_pos0 = 0;
10602 dgst_pos1 = 1;
10603 dgst_pos2 = 2;
10604 dgst_pos3 = 3;
10605 break;
10606
10607 case 13722: hash_type = HASH_TYPE_SHA512;
10608 salt_type = SALT_TYPE_EMBEDDED;
10609 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10610 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10611 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10612 dgst_size = DGST_SIZE_8_8;
10613 parse_func = veracrypt_parse_hash_500000;
10614 sort_by_digest = sort_by_digest_8_8;
10615 opti_type = OPTI_TYPE_ZERO_BYTE
10616 | OPTI_TYPE_USES_BITS_64;
10617 dgst_pos0 = 0;
10618 dgst_pos1 = 1;
10619 dgst_pos2 = 2;
10620 dgst_pos3 = 3;
10621 break;
10622
10623 case 13723: hash_type = HASH_TYPE_SHA512;
10624 salt_type = SALT_TYPE_EMBEDDED;
10625 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10626 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10627 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10628 dgst_size = DGST_SIZE_8_8;
10629 parse_func = veracrypt_parse_hash_500000;
10630 sort_by_digest = sort_by_digest_8_8;
10631 opti_type = OPTI_TYPE_ZERO_BYTE
10632 | OPTI_TYPE_USES_BITS_64;
10633 dgst_pos0 = 0;
10634 dgst_pos1 = 1;
10635 dgst_pos2 = 2;
10636 dgst_pos3 = 3;
10637 break;
10638
10639 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10640 salt_type = SALT_TYPE_EMBEDDED;
10641 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10642 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10643 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10644 dgst_size = DGST_SIZE_4_8;
10645 parse_func = veracrypt_parse_hash_500000;
10646 sort_by_digest = sort_by_digest_4_8;
10647 opti_type = OPTI_TYPE_ZERO_BYTE;
10648 dgst_pos0 = 0;
10649 dgst_pos1 = 1;
10650 dgst_pos2 = 2;
10651 dgst_pos3 = 3;
10652 break;
10653
10654 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10655 salt_type = SALT_TYPE_EMBEDDED;
10656 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10657 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10658 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10659 dgst_size = DGST_SIZE_4_8;
10660 parse_func = veracrypt_parse_hash_500000;
10661 sort_by_digest = sort_by_digest_4_8;
10662 opti_type = OPTI_TYPE_ZERO_BYTE;
10663 dgst_pos0 = 0;
10664 dgst_pos1 = 1;
10665 dgst_pos2 = 2;
10666 dgst_pos3 = 3;
10667 break;
10668
10669 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10670 salt_type = SALT_TYPE_EMBEDDED;
10671 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10672 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10673 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10674 dgst_size = DGST_SIZE_4_8;
10675 parse_func = veracrypt_parse_hash_500000;
10676 sort_by_digest = sort_by_digest_4_8;
10677 opti_type = OPTI_TYPE_ZERO_BYTE;
10678 dgst_pos0 = 0;
10679 dgst_pos1 = 1;
10680 dgst_pos2 = 2;
10681 dgst_pos3 = 3;
10682 break;
10683
10684 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10685 salt_type = SALT_TYPE_EMBEDDED;
10686 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10687 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10688 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10689 dgst_size = DGST_SIZE_4_5;
10690 parse_func = veracrypt_parse_hash_327661;
10691 sort_by_digest = sort_by_digest_4_5;
10692 opti_type = OPTI_TYPE_ZERO_BYTE;
10693 dgst_pos0 = 0;
10694 dgst_pos1 = 1;
10695 dgst_pos2 = 2;
10696 dgst_pos3 = 3;
10697 break;
10698
10699 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10700 salt_type = SALT_TYPE_EMBEDDED;
10701 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10702 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10703 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10704 dgst_size = DGST_SIZE_4_5;
10705 parse_func = veracrypt_parse_hash_327661;
10706 sort_by_digest = sort_by_digest_4_5;
10707 opti_type = OPTI_TYPE_ZERO_BYTE;
10708 dgst_pos0 = 0;
10709 dgst_pos1 = 1;
10710 dgst_pos2 = 2;
10711 dgst_pos3 = 3;
10712 break;
10713
10714 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10715 salt_type = SALT_TYPE_EMBEDDED;
10716 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10717 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10718 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10719 dgst_size = DGST_SIZE_4_5;
10720 parse_func = veracrypt_parse_hash_327661;
10721 sort_by_digest = sort_by_digest_4_5;
10722 opti_type = OPTI_TYPE_ZERO_BYTE;
10723 dgst_pos0 = 0;
10724 dgst_pos1 = 1;
10725 dgst_pos2 = 2;
10726 dgst_pos3 = 3;
10727 break;
10728
10729 case 13751: hash_type = HASH_TYPE_SHA256;
10730 salt_type = SALT_TYPE_EMBEDDED;
10731 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10732 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10733 kern_type = KERN_TYPE_VCSHA256_XTS512;
10734 dgst_size = DGST_SIZE_4_8;
10735 parse_func = veracrypt_parse_hash_500000;
10736 sort_by_digest = sort_by_digest_4_8;
10737 opti_type = OPTI_TYPE_ZERO_BYTE;
10738 dgst_pos0 = 0;
10739 dgst_pos1 = 1;
10740 dgst_pos2 = 2;
10741 dgst_pos3 = 3;
10742 break;
10743
10744 case 13752: hash_type = HASH_TYPE_SHA256;
10745 salt_type = SALT_TYPE_EMBEDDED;
10746 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10747 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10748 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10749 dgst_size = DGST_SIZE_4_8;
10750 parse_func = veracrypt_parse_hash_500000;
10751 sort_by_digest = sort_by_digest_4_8;
10752 opti_type = OPTI_TYPE_ZERO_BYTE;
10753 dgst_pos0 = 0;
10754 dgst_pos1 = 1;
10755 dgst_pos2 = 2;
10756 dgst_pos3 = 3;
10757 break;
10758
10759 case 13753: hash_type = HASH_TYPE_SHA256;
10760 salt_type = SALT_TYPE_EMBEDDED;
10761 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10762 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10763 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10764 dgst_size = DGST_SIZE_4_8;
10765 parse_func = veracrypt_parse_hash_500000;
10766 sort_by_digest = sort_by_digest_4_8;
10767 opti_type = OPTI_TYPE_ZERO_BYTE;
10768 dgst_pos0 = 0;
10769 dgst_pos1 = 1;
10770 dgst_pos2 = 2;
10771 dgst_pos3 = 3;
10772 break;
10773
10774 case 13761: hash_type = HASH_TYPE_SHA256;
10775 salt_type = SALT_TYPE_EMBEDDED;
10776 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10777 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10778 kern_type = KERN_TYPE_VCSHA256_XTS512;
10779 dgst_size = DGST_SIZE_4_8;
10780 parse_func = veracrypt_parse_hash_200000;
10781 sort_by_digest = sort_by_digest_4_8;
10782 opti_type = OPTI_TYPE_ZERO_BYTE;
10783 dgst_pos0 = 0;
10784 dgst_pos1 = 1;
10785 dgst_pos2 = 2;
10786 dgst_pos3 = 3;
10787 break;
10788
10789 case 13762: hash_type = HASH_TYPE_SHA256;
10790 salt_type = SALT_TYPE_EMBEDDED;
10791 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10792 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10793 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10794 dgst_size = DGST_SIZE_4_8;
10795 parse_func = veracrypt_parse_hash_200000;
10796 sort_by_digest = sort_by_digest_4_8;
10797 opti_type = OPTI_TYPE_ZERO_BYTE;
10798 dgst_pos0 = 0;
10799 dgst_pos1 = 1;
10800 dgst_pos2 = 2;
10801 dgst_pos3 = 3;
10802 break;
10803
10804 case 13763: hash_type = HASH_TYPE_SHA256;
10805 salt_type = SALT_TYPE_EMBEDDED;
10806 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10807 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10808 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10809 dgst_size = DGST_SIZE_4_8;
10810 parse_func = veracrypt_parse_hash_200000;
10811 sort_by_digest = sort_by_digest_4_8;
10812 opti_type = OPTI_TYPE_ZERO_BYTE;
10813 dgst_pos0 = 0;
10814 dgst_pos1 = 1;
10815 dgst_pos2 = 2;
10816 dgst_pos3 = 3;
10817 break;
10818
10819 case 13800: hash_type = HASH_TYPE_SHA256;
10820 salt_type = SALT_TYPE_EMBEDDED;
10821 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10822 opts_type = OPTS_TYPE_PT_GENERATE_BE
10823 | OPTS_TYPE_PT_UNICODE;
10824 kern_type = KERN_TYPE_WIN8PHONE;
10825 dgst_size = DGST_SIZE_4_8;
10826 parse_func = win8phone_parse_hash;
10827 sort_by_digest = sort_by_digest_4_8;
10828 opti_type = OPTI_TYPE_ZERO_BYTE
10829 | OPTI_TYPE_PRECOMPUTE_INIT
10830 | OPTI_TYPE_EARLY_SKIP
10831 | OPTI_TYPE_NOT_ITERATED
10832 | OPTI_TYPE_RAW_HASH;
10833 dgst_pos0 = 3;
10834 dgst_pos1 = 7;
10835 dgst_pos2 = 2;
10836 dgst_pos3 = 6;
10837 break;
10838
10839
10840 default: usage_mini_print (PROGNAME); return (-1);
10841 }
10842
10843 /**
10844 * parser
10845 */
10846
10847 data.parse_func = parse_func;
10848
10849 /**
10850 * misc stuff
10851 */
10852
10853 if (hex_salt)
10854 {
10855 if (salt_type == SALT_TYPE_INTERN)
10856 {
10857 opts_type |= OPTS_TYPE_ST_HEX;
10858 }
10859 else
10860 {
10861 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10862
10863 return (-1);
10864 }
10865 }
10866
10867 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10868 | (salt_type == SALT_TYPE_EXTERN)
10869 | (salt_type == SALT_TYPE_EMBEDDED)
10870 | (salt_type == SALT_TYPE_VIRTUAL));
10871
10872 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10873
10874 data.hash_type = hash_type;
10875 data.attack_mode = attack_mode;
10876 data.attack_kern = attack_kern;
10877 data.attack_exec = attack_exec;
10878 data.kern_type = kern_type;
10879 data.opts_type = opts_type;
10880 data.dgst_size = dgst_size;
10881 data.salt_type = salt_type;
10882 data.isSalted = isSalted;
10883 data.sort_by_digest = sort_by_digest;
10884 data.dgst_pos0 = dgst_pos0;
10885 data.dgst_pos1 = dgst_pos1;
10886 data.dgst_pos2 = dgst_pos2;
10887 data.dgst_pos3 = dgst_pos3;
10888
10889 esalt_size = 0;
10890
10891 switch (hash_mode)
10892 {
10893 case 2500: esalt_size = sizeof (wpa_t); break;
10894 case 5300: esalt_size = sizeof (ikepsk_t); break;
10895 case 5400: esalt_size = sizeof (ikepsk_t); break;
10896 case 5500: esalt_size = sizeof (netntlm_t); break;
10897 case 5600: esalt_size = sizeof (netntlm_t); break;
10898 case 6211: esalt_size = sizeof (tc_t); break;
10899 case 6212: esalt_size = sizeof (tc_t); break;
10900 case 6213: esalt_size = sizeof (tc_t); break;
10901 case 6221: esalt_size = sizeof (tc_t); break;
10902 case 6222: esalt_size = sizeof (tc_t); break;
10903 case 6223: esalt_size = sizeof (tc_t); break;
10904 case 6231: esalt_size = sizeof (tc_t); break;
10905 case 6232: esalt_size = sizeof (tc_t); break;
10906 case 6233: esalt_size = sizeof (tc_t); break;
10907 case 6241: esalt_size = sizeof (tc_t); break;
10908 case 6242: esalt_size = sizeof (tc_t); break;
10909 case 6243: esalt_size = sizeof (tc_t); break;
10910 case 6600: esalt_size = sizeof (agilekey_t); break;
10911 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10912 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10913 case 7300: esalt_size = sizeof (rakp_t); break;
10914 case 7500: esalt_size = sizeof (krb5pa_t); break;
10915 case 8200: esalt_size = sizeof (cloudkey_t); break;
10916 case 8800: esalt_size = sizeof (androidfde_t); break;
10917 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10918 case 9400: esalt_size = sizeof (office2007_t); break;
10919 case 9500: esalt_size = sizeof (office2010_t); break;
10920 case 9600: esalt_size = sizeof (office2013_t); break;
10921 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10922 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10923 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10924 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10925 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10926 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10927 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10928 case 10200: esalt_size = sizeof (cram_md5_t); break;
10929 case 10400: esalt_size = sizeof (pdf_t); break;
10930 case 10410: esalt_size = sizeof (pdf_t); break;
10931 case 10420: esalt_size = sizeof (pdf_t); break;
10932 case 10500: esalt_size = sizeof (pdf_t); break;
10933 case 10600: esalt_size = sizeof (pdf_t); break;
10934 case 10700: esalt_size = sizeof (pdf_t); break;
10935 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10936 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10937 case 11400: esalt_size = sizeof (sip_t); break;
10938 case 11600: esalt_size = sizeof (seven_zip_t); break;
10939 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10940 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10941 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10942 case 13000: esalt_size = sizeof (rar5_t); break;
10943 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10944 case 13400: esalt_size = sizeof (keepass_t); break;
10945 case 13500: esalt_size = sizeof (pstoken_t); break;
10946 case 13600: esalt_size = sizeof (zip2_t); break;
10947 case 13711: esalt_size = sizeof (tc_t); break;
10948 case 13712: esalt_size = sizeof (tc_t); break;
10949 case 13713: esalt_size = sizeof (tc_t); break;
10950 case 13721: esalt_size = sizeof (tc_t); break;
10951 case 13722: esalt_size = sizeof (tc_t); break;
10952 case 13723: esalt_size = sizeof (tc_t); break;
10953 case 13731: esalt_size = sizeof (tc_t); break;
10954 case 13732: esalt_size = sizeof (tc_t); break;
10955 case 13733: esalt_size = sizeof (tc_t); break;
10956 case 13741: esalt_size = sizeof (tc_t); break;
10957 case 13742: esalt_size = sizeof (tc_t); break;
10958 case 13743: esalt_size = sizeof (tc_t); break;
10959 case 13751: esalt_size = sizeof (tc_t); break;
10960 case 13752: esalt_size = sizeof (tc_t); break;
10961 case 13753: esalt_size = sizeof (tc_t); break;
10962 case 13761: esalt_size = sizeof (tc_t); break;
10963 case 13762: esalt_size = sizeof (tc_t); break;
10964 case 13763: esalt_size = sizeof (tc_t); break;
10965 case 13800: esalt_size = sizeof (win8phone_t); break;
10966 }
10967
10968 data.esalt_size = esalt_size;
10969
10970 /**
10971 * choose dictionary parser
10972 */
10973
10974 if (hash_type == HASH_TYPE_LM)
10975 {
10976 get_next_word_func = get_next_word_lm;
10977 }
10978 else if (opts_type & OPTS_TYPE_PT_UPPER)
10979 {
10980 get_next_word_func = get_next_word_uc;
10981 }
10982 else
10983 {
10984 get_next_word_func = get_next_word_std;
10985 }
10986
10987 /**
10988 * dictstat
10989 */
10990
10991 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10992
10993 #ifdef _POSIX
10994 size_t dictstat_nmemb = 0;
10995 #endif
10996
10997 #ifdef _WIN
10998 uint dictstat_nmemb = 0;
10999 #endif
11000
11001 char dictstat[256] = { 0 };
11002
11003 FILE *dictstat_fp = NULL;
11004
11005 if (keyspace == 0)
11006 {
11007 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11008
11009 dictstat_fp = fopen (dictstat, "rb");
11010
11011 if (dictstat_fp)
11012 {
11013 #ifdef _POSIX
11014 struct stat tmpstat;
11015
11016 fstat (fileno (dictstat_fp), &tmpstat);
11017 #endif
11018
11019 #ifdef _WIN
11020 struct stat64 tmpstat;
11021
11022 _fstat64 (fileno (dictstat_fp), &tmpstat);
11023 #endif
11024
11025 if (tmpstat.st_mtime < COMPTIME)
11026 {
11027 /* with v0.15 the format changed so we have to ensure user is using a good version
11028 since there is no version-header in the dictstat file */
11029
11030 fclose (dictstat_fp);
11031
11032 unlink (dictstat);
11033 }
11034 else
11035 {
11036 while (!feof (dictstat_fp))
11037 {
11038 dictstat_t d;
11039
11040 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11041
11042 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11043
11044 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11045 {
11046 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11047
11048 return -1;
11049 }
11050 }
11051
11052 fclose (dictstat_fp);
11053 }
11054 }
11055 }
11056
11057 /**
11058 * potfile
11059 */
11060
11061 char potfile[256] = { 0 };
11062
11063 if (potfile_path == NULL)
11064 {
11065 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11066 }
11067 else
11068 {
11069 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11070 }
11071
11072 data.pot_fp = NULL;
11073
11074 FILE *out_fp = NULL;
11075 FILE *pot_fp = NULL;
11076
11077 if (show == 1 || left == 1)
11078 {
11079 pot_fp = fopen (potfile, "rb");
11080
11081 if (pot_fp == NULL)
11082 {
11083 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11084
11085 return (-1);
11086 }
11087
11088 if (outfile != NULL)
11089 {
11090 if ((out_fp = fopen (outfile, "ab")) == NULL)
11091 {
11092 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11093
11094 fclose (pot_fp);
11095
11096 return (-1);
11097 }
11098 }
11099 else
11100 {
11101 out_fp = stdout;
11102 }
11103 }
11104 else
11105 {
11106 if (potfile_disable == 0)
11107 {
11108 pot_fp = fopen (potfile, "ab");
11109
11110 if (pot_fp == NULL)
11111 {
11112 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11113
11114 return (-1);
11115 }
11116
11117 data.pot_fp = pot_fp;
11118 }
11119 }
11120
11121 pot_t *pot = NULL;
11122
11123 uint pot_cnt = 0;
11124 uint pot_avail = 0;
11125
11126 if (show == 1 || left == 1)
11127 {
11128 SUPPRESS_OUTPUT = 1;
11129
11130 pot_avail = count_lines (pot_fp);
11131
11132 rewind (pot_fp);
11133
11134 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11135
11136 uint pot_hashes_avail = 0;
11137
11138 uint line_num = 0;
11139
11140 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11141
11142 while (!feof (pot_fp))
11143 {
11144 line_num++;
11145
11146 int line_len = fgetl (pot_fp, line_buf);
11147
11148 if (line_len == 0) continue;
11149
11150 char *plain_buf = line_buf + line_len;
11151
11152 pot_t *pot_ptr = &pot[pot_cnt];
11153
11154 hash_t *hashes_buf = &pot_ptr->hash;
11155
11156 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11157 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11158
11159 if (pot_cnt == pot_hashes_avail)
11160 {
11161 uint pos = 0;
11162
11163 for (pos = 0; pos < INCR_POT; pos++)
11164 {
11165 if ((pot_cnt + pos) >= pot_avail) break;
11166
11167 pot_t *tmp_pot = &pot[pot_cnt + pos];
11168
11169 hash_t *tmp_hash = &tmp_pot->hash;
11170
11171 tmp_hash->digest = mymalloc (dgst_size);
11172
11173 if (isSalted)
11174 {
11175 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11176 }
11177
11178 if (esalt_size)
11179 {
11180 tmp_hash->esalt = mymalloc (esalt_size);
11181 }
11182
11183 pot_hashes_avail++;
11184 }
11185 }
11186
11187 int plain_len = 0;
11188
11189 int parser_status;
11190
11191 int iter = MAX_CUT_TRIES;
11192
11193 do
11194 {
11195 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11196 {
11197 if (line_buf[i] == ':')
11198 {
11199 line_len--;
11200
11201 break;
11202 }
11203 }
11204
11205 if (data.hash_mode != 2500)
11206 {
11207 parser_status = parse_func (line_buf, line_len, hashes_buf);
11208 }
11209 else
11210 {
11211 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11212
11213 if (line_len > max_salt_size)
11214 {
11215 parser_status = PARSER_GLOBAL_LENGTH;
11216 }
11217 else
11218 {
11219 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11220
11221 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11222
11223 hashes_buf->salt->salt_len = line_len;
11224
11225 parser_status = PARSER_OK;
11226 }
11227 }
11228
11229 // if NOT parsed without error, we add the ":" to the plain
11230
11231 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11232 {
11233 plain_len++;
11234 plain_buf--;
11235 }
11236
11237 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11238
11239 if (parser_status < PARSER_GLOBAL_ZERO)
11240 {
11241 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11242
11243 continue;
11244 }
11245
11246 if (plain_len >= 255) continue;
11247
11248 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11249
11250 pot_ptr->plain_len = plain_len;
11251
11252 pot_cnt++;
11253 }
11254
11255 myfree (line_buf);
11256
11257 fclose (pot_fp);
11258
11259 SUPPRESS_OUTPUT = 0;
11260
11261 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11262 }
11263
11264 /**
11265 * word len
11266 */
11267
11268 uint pw_min = PW_MIN;
11269 uint pw_max = PW_MAX;
11270
11271 switch (hash_mode)
11272 {
11273 case 125: if (pw_max > 32) pw_max = 32;
11274 break;
11275 case 400: if (pw_max > 40) pw_max = 40;
11276 break;
11277 case 500: if (pw_max > 16) pw_max = 16;
11278 break;
11279 case 1500: if (pw_max > 8) pw_max = 8;
11280 break;
11281 case 1600: if (pw_max > 16) pw_max = 16;
11282 break;
11283 case 1800: if (pw_max > 16) pw_max = 16;
11284 break;
11285 case 2100: if (pw_max > 16) pw_max = 16;
11286 break;
11287 case 2500: if (pw_min < 8) pw_min = 8;
11288 break;
11289 case 3000: if (pw_max > 7) pw_max = 7;
11290 break;
11291 case 5200: if (pw_max > 24) pw_max = 24;
11292 break;
11293 case 5800: if (pw_max > 16) pw_max = 16;
11294 break;
11295 case 6300: if (pw_max > 16) pw_max = 16;
11296 break;
11297 case 7400: if (pw_max > 16) pw_max = 16;
11298 break;
11299 case 7700: if (pw_max > 8) pw_max = 8;
11300 break;
11301 case 7900: if (pw_max > 48) pw_max = 48;
11302 break;
11303 case 8500: if (pw_max > 8) pw_max = 8;
11304 break;
11305 case 8600: if (pw_max > 16) pw_max = 16;
11306 break;
11307 case 9710: pw_min = 5;
11308 pw_max = 5;
11309 break;
11310 case 9810: pw_min = 5;
11311 pw_max = 5;
11312 break;
11313 case 10410: pw_min = 5;
11314 pw_max = 5;
11315 break;
11316 case 10300: if (pw_max < 3) pw_min = 3;
11317 if (pw_max > 40) pw_max = 40;
11318 break;
11319 case 10500: if (pw_max < 3) pw_min = 3;
11320 if (pw_max > 40) pw_max = 40;
11321 break;
11322 case 10700: if (pw_max > 16) pw_max = 16;
11323 break;
11324 case 11300: if (pw_max > 40) pw_max = 40;
11325 break;
11326 case 11600: if (pw_max > 32) pw_max = 32;
11327 break;
11328 case 12500: if (pw_max > 20) pw_max = 20;
11329 break;
11330 case 12800: if (pw_max > 24) pw_max = 24;
11331 break;
11332 }
11333
11334 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11335 {
11336 switch (attack_kern)
11337 {
11338 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11339 break;
11340 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11341 break;
11342 }
11343 }
11344
11345 /**
11346 * charsets : keep them together for more easy maintainnce
11347 */
11348
11349 cs_t mp_sys[6] = { { { 0 }, 0 } };
11350 cs_t mp_usr[4] = { { { 0 }, 0 } };
11351
11352 mp_setup_sys (mp_sys);
11353
11354 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11355 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11356 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11357 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11358
11359 /**
11360 * load hashes, part I: find input mode, count hashes
11361 */
11362
11363 uint hashlist_mode = 0;
11364 uint hashlist_format = HLFMT_HASHCAT;
11365
11366 uint hashes_avail = 0;
11367
11368 if (benchmark == 0)
11369 {
11370 struct stat f;
11371
11372 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11373
11374 if ((hash_mode == 2500) ||
11375 (hash_mode == 5200) ||
11376 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11377 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11378 (hash_mode == 9000))
11379 {
11380 hashlist_mode = HL_MODE_ARG;
11381
11382 char *hashfile = myargv[optind];
11383
11384 data.hashfile = hashfile;
11385
11386 logfile_top_var_string ("target", hashfile);
11387 }
11388
11389 if (hashlist_mode == HL_MODE_ARG)
11390 {
11391 if (hash_mode == 2500)
11392 {
11393 struct stat st;
11394
11395 if (stat (data.hashfile, &st) == -1)
11396 {
11397 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11398
11399 return (-1);
11400 }
11401
11402 hashes_avail = st.st_size / sizeof (hccap_t);
11403 }
11404 else
11405 {
11406 hashes_avail = 1;
11407 }
11408 }
11409 else if (hashlist_mode == HL_MODE_FILE)
11410 {
11411 char *hashfile = myargv[optind];
11412
11413 data.hashfile = hashfile;
11414
11415 logfile_top_var_string ("target", hashfile);
11416
11417 FILE *fp = NULL;
11418
11419 if ((fp = fopen (hashfile, "rb")) == NULL)
11420 {
11421 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11422
11423 return (-1);
11424 }
11425
11426 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11427
11428 hashes_avail = count_lines (fp);
11429
11430 rewind (fp);
11431
11432 if (hashes_avail == 0)
11433 {
11434 log_error ("ERROR: hashfile is empty or corrupt");
11435
11436 fclose (fp);
11437
11438 return (-1);
11439 }
11440
11441 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11442
11443 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11444 {
11445 log_error ("ERROR: remove not supported in native hashfile-format mode");
11446
11447 fclose (fp);
11448
11449 return (-1);
11450 }
11451
11452 fclose (fp);
11453 }
11454 }
11455 else
11456 {
11457 hashlist_mode = HL_MODE_ARG;
11458
11459 hashes_avail = 1;
11460 }
11461
11462 if (hash_mode == 3000) hashes_avail *= 2;
11463
11464 data.hashlist_mode = hashlist_mode;
11465 data.hashlist_format = hashlist_format;
11466
11467 logfile_top_uint (hashlist_mode);
11468 logfile_top_uint (hashlist_format);
11469
11470 /**
11471 * load hashes, part II: allocate required memory, set pointers
11472 */
11473
11474 hash_t *hashes_buf = NULL;
11475 void *digests_buf = NULL;
11476 salt_t *salts_buf = NULL;
11477 void *esalts_buf = NULL;
11478
11479 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11480
11481 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11482
11483 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11484 {
11485 u32 hash_pos;
11486
11487 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11488 {
11489 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11490
11491 hashes_buf[hash_pos].hash_info = hash_info;
11492
11493 if (username && (remove || show || left))
11494 {
11495 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11496 }
11497
11498 if (benchmark)
11499 {
11500 hash_info->orighash = (char *) mymalloc (256);
11501 }
11502 }
11503 }
11504
11505 if (isSalted)
11506 {
11507 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11508
11509 if (esalt_size)
11510 {
11511 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11512 }
11513 }
11514 else
11515 {
11516 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11517 }
11518
11519 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11520 {
11521 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11522
11523 if (isSalted)
11524 {
11525 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11526
11527 if (esalt_size)
11528 {
11529 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11530 }
11531 }
11532 else
11533 {
11534 hashes_buf[hash_pos].salt = &salts_buf[0];
11535 }
11536 }
11537
11538 /**
11539 * load hashes, part III: parse hashes or generate them if benchmark
11540 */
11541
11542 uint hashes_cnt = 0;
11543
11544 if (benchmark == 0)
11545 {
11546 if (keyspace == 1)
11547 {
11548 // useless to read hash file for keyspace, cheat a little bit w/ optind
11549 }
11550 else if (hashes_avail == 0)
11551 {
11552 }
11553 else if (hashlist_mode == HL_MODE_ARG)
11554 {
11555 char *input_buf = myargv[optind];
11556
11557 uint input_len = strlen (input_buf);
11558
11559 logfile_top_var_string ("target", input_buf);
11560
11561 char *hash_buf = NULL;
11562 int hash_len = 0;
11563
11564 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11565
11566 bool hash_fmt_error = 0;
11567
11568 if (hash_len < 1) hash_fmt_error = 1;
11569 if (hash_buf == NULL) hash_fmt_error = 1;
11570
11571 if (hash_fmt_error)
11572 {
11573 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11574 }
11575 else
11576 {
11577 if (opts_type & OPTS_TYPE_HASH_COPY)
11578 {
11579 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11580
11581 hash_info_tmp->orighash = mystrdup (hash_buf);
11582 }
11583
11584 if (isSalted)
11585 {
11586 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11587 }
11588
11589 int parser_status = PARSER_OK;
11590
11591 if (hash_mode == 2500)
11592 {
11593 if (hash_len == 0)
11594 {
11595 log_error ("ERROR: hccap file not specified");
11596
11597 return (-1);
11598 }
11599
11600 hashlist_mode = HL_MODE_FILE;
11601
11602 data.hashlist_mode = hashlist_mode;
11603
11604 FILE *fp = fopen (hash_buf, "rb");
11605
11606 if (fp == NULL)
11607 {
11608 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11609
11610 return (-1);
11611 }
11612
11613 if (hashes_avail < 1)
11614 {
11615 log_error ("ERROR: hccap file is empty or corrupt");
11616
11617 fclose (fp);
11618
11619 return (-1);
11620 }
11621
11622 uint hccap_size = sizeof (hccap_t);
11623
11624 char *in = (char *) mymalloc (hccap_size);
11625
11626 while (!feof (fp))
11627 {
11628 int n = fread (in, hccap_size, 1, fp);
11629
11630 if (n != 1)
11631 {
11632 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11633
11634 break;
11635 }
11636
11637 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11638
11639 if (parser_status != PARSER_OK)
11640 {
11641 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11642
11643 continue;
11644 }
11645
11646 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11647
11648 if ((show == 1) || (left == 1))
11649 {
11650 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11651
11652 char *salt_ptr = (char *) tmp_salt->salt_buf;
11653
11654 int cur_pos = tmp_salt->salt_len;
11655 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11656
11657 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11658
11659 // do the appending task
11660
11661 snprintf (salt_ptr + cur_pos,
11662 rem_len,
11663 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11664 wpa->orig_mac1[0],
11665 wpa->orig_mac1[1],
11666 wpa->orig_mac1[2],
11667 wpa->orig_mac1[3],
11668 wpa->orig_mac1[4],
11669 wpa->orig_mac1[5],
11670 wpa->orig_mac2[0],
11671 wpa->orig_mac2[1],
11672 wpa->orig_mac2[2],
11673 wpa->orig_mac2[3],
11674 wpa->orig_mac2[4],
11675 wpa->orig_mac2[5]);
11676
11677 // memset () the remaining part of the salt
11678
11679 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11680 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11681
11682 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11683
11684 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11685 }
11686
11687 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);
11688 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);
11689
11690 hashes_cnt++;
11691 }
11692
11693 fclose (fp);
11694
11695 myfree (in);
11696 }
11697 else if (hash_mode == 3000)
11698 {
11699 if (hash_len == 32)
11700 {
11701 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11702
11703 hash_t *lm_hash_left = NULL;
11704
11705 if (parser_status == PARSER_OK)
11706 {
11707 lm_hash_left = &hashes_buf[hashes_cnt];
11708
11709 hashes_cnt++;
11710 }
11711 else
11712 {
11713 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11714 }
11715
11716 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11717
11718 hash_t *lm_hash_right = NULL;
11719
11720 if (parser_status == PARSER_OK)
11721 {
11722 lm_hash_right = &hashes_buf[hashes_cnt];
11723
11724 hashes_cnt++;
11725 }
11726 else
11727 {
11728 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11729 }
11730
11731 // show / left
11732
11733 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11734 {
11735 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);
11736 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);
11737 }
11738 }
11739 else
11740 {
11741 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11742
11743 if (parser_status == PARSER_OK)
11744 {
11745 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11746 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11747 }
11748
11749 if (parser_status == PARSER_OK)
11750 {
11751 hashes_cnt++;
11752 }
11753 else
11754 {
11755 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11756 }
11757 }
11758 }
11759 else
11760 {
11761 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11762
11763 if (parser_status == PARSER_OK)
11764 {
11765 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11766 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11767 }
11768
11769 if (parser_status == PARSER_OK)
11770 {
11771 hashes_cnt++;
11772 }
11773 else
11774 {
11775 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11776 }
11777 }
11778 }
11779 }
11780 else if (hashlist_mode == HL_MODE_FILE)
11781 {
11782 char *hashfile = data.hashfile;
11783
11784 FILE *fp;
11785
11786 if ((fp = fopen (hashfile, "rb")) == NULL)
11787 {
11788 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11789
11790 return (-1);
11791 }
11792
11793 uint line_num = 0;
11794
11795 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11796
11797 while (!feof (fp))
11798 {
11799 line_num++;
11800
11801 int line_len = fgetl (fp, line_buf);
11802
11803 if (line_len == 0) continue;
11804
11805 char *hash_buf = NULL;
11806 int hash_len = 0;
11807
11808 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11809
11810 bool hash_fmt_error = 0;
11811
11812 if (hash_len < 1) hash_fmt_error = 1;
11813 if (hash_buf == NULL) hash_fmt_error = 1;
11814
11815 if (hash_fmt_error)
11816 {
11817 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11818
11819 continue;
11820 }
11821
11822 if (username)
11823 {
11824 char *user_buf = NULL;
11825 int user_len = 0;
11826
11827 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11828
11829 if (remove || show)
11830 {
11831 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11832
11833 *user = (user_t *) mymalloc (sizeof (user_t));
11834
11835 user_t *user_ptr = *user;
11836
11837 if (user_buf != NULL)
11838 {
11839 user_ptr->user_name = mystrdup (user_buf);
11840 }
11841 else
11842 {
11843 user_ptr->user_name = mystrdup ("");
11844 }
11845
11846 user_ptr->user_len = user_len;
11847 }
11848 }
11849
11850 if (opts_type & OPTS_TYPE_HASH_COPY)
11851 {
11852 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11853
11854 hash_info_tmp->orighash = mystrdup (hash_buf);
11855 }
11856
11857 if (isSalted)
11858 {
11859 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11860 }
11861
11862 if (hash_mode == 3000)
11863 {
11864 if (hash_len == 32)
11865 {
11866 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11867
11868 if (parser_status < PARSER_GLOBAL_ZERO)
11869 {
11870 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11871
11872 continue;
11873 }
11874
11875 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11876
11877 hashes_cnt++;
11878
11879 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11880
11881 if (parser_status < PARSER_GLOBAL_ZERO)
11882 {
11883 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11884
11885 continue;
11886 }
11887
11888 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11889
11890 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);
11891
11892 hashes_cnt++;
11893
11894 // show / left
11895
11896 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);
11897 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);
11898 }
11899 else
11900 {
11901 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11902
11903 if (parser_status < PARSER_GLOBAL_ZERO)
11904 {
11905 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11906
11907 continue;
11908 }
11909
11910 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);
11911
11912 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11913 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11914
11915 hashes_cnt++;
11916 }
11917 }
11918 else
11919 {
11920 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11921
11922 if (parser_status < PARSER_GLOBAL_ZERO)
11923 {
11924 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11925
11926 continue;
11927 }
11928
11929 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);
11930
11931 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11932 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11933
11934 hashes_cnt++;
11935 }
11936 }
11937
11938 myfree (line_buf);
11939
11940 fclose (fp);
11941
11942 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11943
11944 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11945 }
11946 }
11947 else
11948 {
11949 if (isSalted)
11950 {
11951 hashes_buf[0].salt->salt_len = 8;
11952
11953 // special salt handling
11954
11955 switch (hash_mode)
11956 {
11957 case 1500: hashes_buf[0].salt->salt_len = 2;
11958 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11959 break;
11960 case 1731: hashes_buf[0].salt->salt_len = 4;
11961 break;
11962 case 2410: hashes_buf[0].salt->salt_len = 4;
11963 break;
11964 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11965 break;
11966 case 3100: hashes_buf[0].salt->salt_len = 1;
11967 break;
11968 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11969 break;
11970 case 5800: hashes_buf[0].salt->salt_len = 16;
11971 break;
11972 case 6800: hashes_buf[0].salt->salt_len = 32;
11973 break;
11974 case 8400: hashes_buf[0].salt->salt_len = 40;
11975 break;
11976 case 8800: hashes_buf[0].salt->salt_len = 16;
11977 break;
11978 case 8900: hashes_buf[0].salt->salt_len = 16;
11979 hashes_buf[0].salt->scrypt_N = 1024;
11980 hashes_buf[0].salt->scrypt_r = 1;
11981 hashes_buf[0].salt->scrypt_p = 1;
11982 break;
11983 case 9100: hashes_buf[0].salt->salt_len = 16;
11984 break;
11985 case 9300: hashes_buf[0].salt->salt_len = 14;
11986 hashes_buf[0].salt->scrypt_N = 16384;
11987 hashes_buf[0].salt->scrypt_r = 1;
11988 hashes_buf[0].salt->scrypt_p = 1;
11989 break;
11990 case 9400: hashes_buf[0].salt->salt_len = 16;
11991 break;
11992 case 9500: hashes_buf[0].salt->salt_len = 16;
11993 break;
11994 case 9600: hashes_buf[0].salt->salt_len = 16;
11995 break;
11996 case 9700: hashes_buf[0].salt->salt_len = 16;
11997 break;
11998 case 9710: hashes_buf[0].salt->salt_len = 16;
11999 break;
12000 case 9720: hashes_buf[0].salt->salt_len = 16;
12001 break;
12002 case 9800: hashes_buf[0].salt->salt_len = 16;
12003 break;
12004 case 9810: hashes_buf[0].salt->salt_len = 16;
12005 break;
12006 case 9820: hashes_buf[0].salt->salt_len = 16;
12007 break;
12008 case 10300: hashes_buf[0].salt->salt_len = 12;
12009 break;
12010 case 11500: hashes_buf[0].salt->salt_len = 4;
12011 break;
12012 case 11600: hashes_buf[0].salt->salt_len = 4;
12013 break;
12014 case 12400: hashes_buf[0].salt->salt_len = 4;
12015 break;
12016 case 12500: hashes_buf[0].salt->salt_len = 8;
12017 break;
12018 case 12600: hashes_buf[0].salt->salt_len = 64;
12019 break;
12020 }
12021
12022 // special esalt handling
12023
12024 switch (hash_mode)
12025 {
12026 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12027 break;
12028 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12029 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12030 break;
12031 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12032 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12033 break;
12034 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12035 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12036 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12037 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12038 break;
12039 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12040 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12041 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12042 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12043 break;
12044 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12045 break;
12046 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12047 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12048 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12049 break;
12050 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12051 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12052 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12053 break;
12054 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12055 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12056 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12057 break;
12058 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12059 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12060 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12061 break;
12062 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12063 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12064 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12065 break;
12066 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12067 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12068 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12069 break;
12070 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12071 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12072 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12073 break;
12074 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12075 break;
12076 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12077 break;
12078 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12079 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12080 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12081 break;
12082 }
12083 }
12084
12085 // set hashfile
12086
12087 switch (hash_mode)
12088 {
12089 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12090 break;
12091 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12092 break;
12093 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12094 break;
12095 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12096 break;
12097 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12098 break;
12099 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12100 break;
12101 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12102 break;
12103 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12104 break;
12105 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12106 break;
12107 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12108 break;
12109 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12110 break;
12111 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12112 break;
12113 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12114 break;
12115 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12116 break;
12117 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12118 break;
12119 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12120 break;
12121 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12122 break;
12123 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12124 break;
12125 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12126 break;
12127 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12128 break;
12129 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12130 break;
12131 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12132 break;
12133 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12134 break;
12135 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12136 break;
12137 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12138 break;
12139 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12140 break;
12141 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12142 break;
12143 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12144 break;
12145 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12146 break;
12147 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12148 break;
12149 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12150 break;
12151 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12152 break;
12153 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12154 break;
12155 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12156 break;
12157 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12158 break;
12159 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12160 break;
12161 }
12162
12163 // set default iterations
12164
12165 switch (hash_mode)
12166 {
12167 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12168 break;
12169 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12170 break;
12171 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12172 break;
12173 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12174 break;
12175 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12176 break;
12177 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12178 break;
12179 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12180 break;
12181 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12182 break;
12183 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12184 break;
12185 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12186 break;
12187 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12188 break;
12189 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12190 break;
12191 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12192 break;
12193 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12194 break;
12195 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12196 break;
12197 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12198 break;
12199 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12200 break;
12201 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12202 break;
12203 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12204 break;
12205 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12206 break;
12207 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12208 break;
12209 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12210 break;
12211 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12212 break;
12213 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12214 break;
12215 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12216 break;
12217 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12218 break;
12219 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12220 break;
12221 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12222 break;
12223 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12224 break;
12225 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12226 break;
12227 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12228 break;
12229 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12230 break;
12231 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12232 break;
12233 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12234 break;
12235 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12236 break;
12237 case 8900: hashes_buf[0].salt->salt_iter = 1;
12238 break;
12239 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12240 break;
12241 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12242 break;
12243 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12244 break;
12245 case 9300: hashes_buf[0].salt->salt_iter = 1;
12246 break;
12247 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12248 break;
12249 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12250 break;
12251 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12252 break;
12253 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12254 break;
12255 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12256 break;
12257 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12258 break;
12259 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12260 break;
12261 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12262 break;
12263 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12264 break;
12265 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12266 break;
12267 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12268 break;
12269 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12270 break;
12271 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12272 break;
12273 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12274 break;
12275 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12276 break;
12277 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12278 break;
12279 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12280 break;
12281 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12282 break;
12283 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12284 break;
12285 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12286 break;
12287 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12288 break;
12289 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12290 break;
12291 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12292 break;
12293 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12294 break;
12295 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12296 break;
12297 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12298 break;
12299 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12300 break;
12301 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12302 break;
12303 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12304 break;
12305 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12306 break;
12307 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12308 break;
12309 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12310 break;
12311 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12312 break;
12313 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12314 break;
12315 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12316 break;
12317 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12318 break;
12319 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12320 break;
12321 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12322 break;
12323 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12324 break;
12325 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12326 break;
12327 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12328 break;
12329 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12330 break;
12331 }
12332
12333 hashes_cnt = 1;
12334 }
12335
12336 if (show == 1 || left == 1)
12337 {
12338 for (uint i = 0; i < pot_cnt; i++)
12339 {
12340 pot_t *pot_ptr = &pot[i];
12341
12342 hash_t *hashes_buf = &pot_ptr->hash;
12343
12344 local_free (hashes_buf->digest);
12345
12346 if (isSalted)
12347 {
12348 local_free (hashes_buf->salt);
12349 }
12350 }
12351
12352 local_free (pot);
12353
12354 if (data.quiet == 0) log_info_nn ("");
12355
12356 return (0);
12357 }
12358
12359 if (keyspace == 0)
12360 {
12361 if (hashes_cnt == 0)
12362 {
12363 log_error ("ERROR: No hashes loaded");
12364
12365 return (-1);
12366 }
12367 }
12368
12369 /**
12370 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12371 */
12372
12373 if (data.outfile != NULL)
12374 {
12375 if (data.hashfile != NULL)
12376 {
12377 #ifdef _POSIX
12378 struct stat tmpstat_outfile;
12379 struct stat tmpstat_hashfile;
12380 #endif
12381
12382 #ifdef _WIN
12383 struct stat64 tmpstat_outfile;
12384 struct stat64 tmpstat_hashfile;
12385 #endif
12386
12387 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12388
12389 if (tmp_outfile_fp)
12390 {
12391 #ifdef _POSIX
12392 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12393 #endif
12394
12395 #ifdef _WIN
12396 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12397 #endif
12398
12399 fclose (tmp_outfile_fp);
12400 }
12401
12402 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12403
12404 if (tmp_hashfile_fp)
12405 {
12406 #ifdef _POSIX
12407 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12408 #endif
12409
12410 #ifdef _WIN
12411 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12412 #endif
12413
12414 fclose (tmp_hashfile_fp);
12415 }
12416
12417 if (tmp_outfile_fp && tmp_outfile_fp)
12418 {
12419 tmpstat_outfile.st_mode = 0;
12420 tmpstat_outfile.st_nlink = 0;
12421 tmpstat_outfile.st_uid = 0;
12422 tmpstat_outfile.st_gid = 0;
12423 tmpstat_outfile.st_rdev = 0;
12424 tmpstat_outfile.st_atime = 0;
12425
12426 tmpstat_hashfile.st_mode = 0;
12427 tmpstat_hashfile.st_nlink = 0;
12428 tmpstat_hashfile.st_uid = 0;
12429 tmpstat_hashfile.st_gid = 0;
12430 tmpstat_hashfile.st_rdev = 0;
12431 tmpstat_hashfile.st_atime = 0;
12432
12433 #ifdef _POSIX
12434 tmpstat_outfile.st_blksize = 0;
12435 tmpstat_outfile.st_blocks = 0;
12436
12437 tmpstat_hashfile.st_blksize = 0;
12438 tmpstat_hashfile.st_blocks = 0;
12439 #endif
12440
12441 #ifdef _POSIX
12442 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12443 {
12444 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12445
12446 return (-1);
12447 }
12448 #endif
12449
12450 #ifdef _WIN
12451 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12452 {
12453 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12454
12455 return (-1);
12456 }
12457 #endif
12458 }
12459 }
12460 }
12461
12462 /**
12463 * Remove duplicates
12464 */
12465
12466 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12467
12468 if (isSalted)
12469 {
12470 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12471 }
12472 else
12473 {
12474 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12475 }
12476
12477 uint hashes_cnt_orig = hashes_cnt;
12478
12479 hashes_cnt = 1;
12480
12481 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12482 {
12483 if (isSalted)
12484 {
12485 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12486 {
12487 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12488 }
12489 }
12490 else
12491 {
12492 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12493 }
12494
12495 if (hashes_pos > hashes_cnt)
12496 {
12497 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12498 }
12499
12500 hashes_cnt++;
12501 }
12502
12503 /**
12504 * Potfile removes
12505 */
12506
12507 uint potfile_remove_cracks = 0;
12508
12509 if (potfile_disable == 0)
12510 {
12511 hash_t hash_buf;
12512
12513 hash_buf.digest = mymalloc (dgst_size);
12514 hash_buf.salt = NULL;
12515 hash_buf.esalt = NULL;
12516 hash_buf.hash_info = NULL;
12517 hash_buf.cracked = 0;
12518
12519 if (isSalted)
12520 {
12521 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12522 }
12523
12524 if (esalt_size)
12525 {
12526 hash_buf.esalt = mymalloc (esalt_size);
12527 }
12528
12529 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12530
12531 // no solution for these special hash types (for instane because they use hashfile in output etc)
12532 if ((hash_mode != 5200) &&
12533 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12534 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12535 (hash_mode != 9000))
12536 {
12537 FILE *fp = fopen (potfile, "rb");
12538
12539 if (fp != NULL)
12540 {
12541 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12542
12543 // to be safe work with a copy (because of line_len loop, i etc)
12544 // moved up here because it's easier to handle continue case
12545 // it's just 64kb
12546
12547 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12548
12549 while (!feof (fp))
12550 {
12551 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12552
12553 if (ptr == NULL) break;
12554
12555 int line_len = strlen (line_buf);
12556
12557 if (line_len == 0) continue;
12558
12559 int iter = MAX_CUT_TRIES;
12560
12561 for (int i = line_len - 1; i && iter; i--, line_len--)
12562 {
12563 if (line_buf[i] != ':') continue;
12564
12565 if (isSalted)
12566 {
12567 memset (hash_buf.salt, 0, sizeof (salt_t));
12568 }
12569
12570 hash_t *found = NULL;
12571
12572 if (hash_mode == 6800)
12573 {
12574 if (i < 64) // 64 = 16 * uint in salt_buf[]
12575 {
12576 // manipulate salt_buf
12577 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12578
12579 hash_buf.salt->salt_len = i;
12580
12581 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12582 }
12583 }
12584 else if (hash_mode == 2500)
12585 {
12586 if (i < 64) // 64 = 16 * uint in salt_buf[]
12587 {
12588 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12589 // manipulate salt_buf
12590
12591 memcpy (line_buf_cpy, line_buf, i);
12592
12593 char *mac2_pos = strrchr (line_buf_cpy, ':');
12594
12595 if (mac2_pos == NULL) continue;
12596
12597 mac2_pos[0] = 0;
12598 mac2_pos++;
12599
12600 if (strlen (mac2_pos) != 12) continue;
12601
12602 char *mac1_pos = strrchr (line_buf_cpy, ':');
12603
12604 if (mac1_pos == NULL) continue;
12605
12606 mac1_pos[0] = 0;
12607 mac1_pos++;
12608
12609 if (strlen (mac1_pos) != 12) continue;
12610
12611 uint essid_length = mac1_pos - line_buf_cpy - 1;
12612
12613 // here we need the ESSID
12614 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12615
12616 hash_buf.salt->salt_len = essid_length;
12617
12618 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12619
12620 if (found)
12621 {
12622 wpa_t *wpa = (wpa_t *) found->esalt;
12623
12624 // compare hex string(s) vs binary MAC address(es)
12625
12626 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12627 {
12628 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12629 {
12630 found = NULL;
12631
12632 break;
12633 }
12634 }
12635
12636 // early skip ;)
12637 if (!found) continue;
12638
12639 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12640 {
12641 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12642 {
12643 found = NULL;
12644
12645 break;
12646 }
12647 }
12648 }
12649 }
12650 }
12651 else
12652 {
12653 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12654
12655 if (parser_status == PARSER_OK)
12656 {
12657 if (isSalted)
12658 {
12659 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12660 }
12661 else
12662 {
12663 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12664 }
12665 }
12666 }
12667
12668 if (found == NULL) continue;
12669
12670 if (!found->cracked) potfile_remove_cracks++;
12671
12672 found->cracked = 1;
12673
12674 if (found) break;
12675
12676 iter--;
12677 }
12678 }
12679
12680 myfree (line_buf_cpy);
12681
12682 myfree (line_buf);
12683
12684 fclose (fp);
12685 }
12686 }
12687
12688 if (esalt_size)
12689 {
12690 local_free (hash_buf.esalt);
12691 }
12692
12693 if (isSalted)
12694 {
12695 local_free (hash_buf.salt);
12696 }
12697
12698 local_free (hash_buf.digest);
12699 }
12700
12701 /**
12702 * Now generate all the buffers required for later
12703 */
12704
12705 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12706
12707 salt_t *salts_buf_new = NULL;
12708 void *esalts_buf_new = NULL;
12709
12710 if (isSalted)
12711 {
12712 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12713
12714 if (esalt_size)
12715 {
12716 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12717 }
12718 }
12719 else
12720 {
12721 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12722 }
12723
12724 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12725
12726 uint digests_cnt = hashes_cnt;
12727 uint digests_done = 0;
12728
12729 size_t size_digests = digests_cnt * dgst_size;
12730 size_t size_shown = digests_cnt * sizeof (uint);
12731
12732 uint *digests_shown = (uint *) mymalloc (size_shown);
12733 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12734
12735 uint salts_cnt = 0;
12736 uint salts_done = 0;
12737
12738 hashinfo_t **hash_info = NULL;
12739
12740 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12741 {
12742 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12743
12744 if (username && (remove || show))
12745 {
12746 uint user_pos;
12747
12748 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12749 {
12750 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12751
12752 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12753 }
12754 }
12755 }
12756
12757 uint *salts_shown = (uint *) mymalloc (size_shown);
12758
12759 salt_t *salt_buf;
12760
12761 {
12762 // copied from inner loop
12763
12764 salt_buf = &salts_buf_new[salts_cnt];
12765
12766 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12767
12768 if (esalt_size)
12769 {
12770 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12771 }
12772
12773 salt_buf->digests_cnt = 0;
12774 salt_buf->digests_done = 0;
12775 salt_buf->digests_offset = 0;
12776
12777 salts_cnt++;
12778 }
12779
12780 if (hashes_buf[0].cracked == 1)
12781 {
12782 digests_shown[0] = 1;
12783
12784 digests_done++;
12785
12786 salt_buf->digests_done++;
12787 }
12788
12789 salt_buf->digests_cnt++;
12790
12791 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12792
12793 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12794 {
12795 hash_info[0] = hashes_buf[0].hash_info;
12796 }
12797
12798 // copy from inner loop
12799
12800 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12801 {
12802 if (isSalted)
12803 {
12804 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12805 {
12806 salt_buf = &salts_buf_new[salts_cnt];
12807
12808 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12809
12810 if (esalt_size)
12811 {
12812 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12813 }
12814
12815 salt_buf->digests_cnt = 0;
12816 salt_buf->digests_done = 0;
12817 salt_buf->digests_offset = hashes_pos;
12818
12819 salts_cnt++;
12820 }
12821 }
12822
12823 if (hashes_buf[hashes_pos].cracked == 1)
12824 {
12825 digests_shown[hashes_pos] = 1;
12826
12827 digests_done++;
12828
12829 salt_buf->digests_done++;
12830 }
12831
12832 salt_buf->digests_cnt++;
12833
12834 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12835
12836 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12837 {
12838 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12839 }
12840 }
12841
12842 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12843 {
12844 salt_t *salt_buf = &salts_buf_new[salt_pos];
12845
12846 if (salt_buf->digests_done == salt_buf->digests_cnt)
12847 {
12848 salts_shown[salt_pos] = 1;
12849
12850 salts_done++;
12851 }
12852
12853 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12854 }
12855
12856 local_free (digests_buf);
12857 local_free (salts_buf);
12858 local_free (esalts_buf);
12859
12860 digests_buf = digests_buf_new;
12861 salts_buf = salts_buf_new;
12862 esalts_buf = esalts_buf_new;
12863
12864 local_free (hashes_buf);
12865
12866 /**
12867 * special modification not set from parser
12868 */
12869
12870 switch (hash_mode)
12871 {
12872 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12873 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12874 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12875 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12876 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12877 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12878 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12879 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12880 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12881 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12882 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12883 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12884 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12885 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12886 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12887 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12888 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12889 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12890 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12891 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12892 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12893 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12894 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12895 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12896 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12897 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12898 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12899 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12900 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12901 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12902 }
12903
12904 if (truecrypt_keyfiles)
12905 {
12906 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12907
12908 char *keyfiles = strdup (truecrypt_keyfiles);
12909
12910 char *keyfile = strtok (keyfiles, ",");
12911
12912 do
12913 {
12914 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12915
12916 } while ((keyfile = strtok (NULL, ",")) != NULL);
12917
12918 free (keyfiles);
12919 }
12920
12921 if (veracrypt_keyfiles)
12922 {
12923 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12924
12925 char *keyfiles = strdup (veracrypt_keyfiles);
12926
12927 char *keyfile = strtok (keyfiles, ",");
12928
12929 do
12930 {
12931 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12932
12933 } while ((keyfile = strtok (NULL, ",")) != NULL);
12934
12935 free (keyfiles);
12936 }
12937
12938 data.digests_cnt = digests_cnt;
12939 data.digests_done = digests_done;
12940 data.digests_buf = digests_buf;
12941 data.digests_shown = digests_shown;
12942 data.digests_shown_tmp = digests_shown_tmp;
12943
12944 data.salts_cnt = salts_cnt;
12945 data.salts_done = salts_done;
12946 data.salts_buf = salts_buf;
12947 data.salts_shown = salts_shown;
12948
12949 data.esalts_buf = esalts_buf;
12950 data.hash_info = hash_info;
12951
12952 /**
12953 * Automatic Optimizers
12954 */
12955
12956 if (salts_cnt == 1)
12957 opti_type |= OPTI_TYPE_SINGLE_SALT;
12958
12959 if (digests_cnt == 1)
12960 opti_type |= OPTI_TYPE_SINGLE_HASH;
12961
12962 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12963 opti_type |= OPTI_TYPE_NOT_ITERATED;
12964
12965 if (attack_mode == ATTACK_MODE_BF)
12966 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12967
12968 data.opti_type = opti_type;
12969
12970 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12971 {
12972 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12973 {
12974 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12975 {
12976 if (opts_type & OPTS_TYPE_ST_ADD80)
12977 {
12978 opts_type &= ~OPTS_TYPE_ST_ADD80;
12979 opts_type |= OPTS_TYPE_PT_ADD80;
12980 }
12981
12982 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12983 {
12984 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12985 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12986 }
12987
12988 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12989 {
12990 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12991 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12992 }
12993 }
12994 }
12995 }
12996
12997 /**
12998 * Some algorithm, like descrypt, can benefit from JIT compilation
12999 */
13000
13001 int force_jit_compilation = -1;
13002
13003 if (hash_mode == 8900)
13004 {
13005 force_jit_compilation = 8900;
13006 }
13007 else if (hash_mode == 9300)
13008 {
13009 force_jit_compilation = 8900;
13010 }
13011 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13012 {
13013 force_jit_compilation = 1500;
13014 }
13015
13016 /**
13017 * generate bitmap tables
13018 */
13019
13020 const uint bitmap_shift1 = 5;
13021 const uint bitmap_shift2 = 13;
13022
13023 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13024
13025 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13026 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13027 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13028 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13029 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13030 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13031 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13032 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13033
13034 uint bitmap_bits;
13035 uint bitmap_nums;
13036 uint bitmap_mask;
13037 uint bitmap_size;
13038
13039 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13040 {
13041 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13042
13043 bitmap_nums = 1 << bitmap_bits;
13044
13045 bitmap_mask = bitmap_nums - 1;
13046
13047 bitmap_size = bitmap_nums * sizeof (uint);
13048
13049 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13050
13051 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;
13052 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;
13053
13054 break;
13055 }
13056
13057 bitmap_nums = 1 << bitmap_bits;
13058
13059 bitmap_mask = bitmap_nums - 1;
13060
13061 bitmap_size = bitmap_nums * sizeof (uint);
13062
13063 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);
13064 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);
13065
13066 /**
13067 * prepare quick rule
13068 */
13069
13070 data.rule_buf_l = rule_buf_l;
13071 data.rule_buf_r = rule_buf_r;
13072
13073 int rule_len_l = (int) strlen (rule_buf_l);
13074 int rule_len_r = (int) strlen (rule_buf_r);
13075
13076 data.rule_len_l = rule_len_l;
13077 data.rule_len_r = rule_len_r;
13078
13079 /**
13080 * load rules
13081 */
13082
13083 uint *all_kernel_rules_cnt = NULL;
13084
13085 kernel_rule_t **all_kernel_rules_buf = NULL;
13086
13087 if (rp_files_cnt)
13088 {
13089 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13090
13091 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13092 }
13093
13094 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13095
13096 int rule_len = 0;
13097
13098 for (uint i = 0; i < rp_files_cnt; i++)
13099 {
13100 uint kernel_rules_avail = 0;
13101
13102 uint kernel_rules_cnt = 0;
13103
13104 kernel_rule_t *kernel_rules_buf = NULL;
13105
13106 char *rp_file = rp_files[i];
13107
13108 char in[BLOCK_SIZE] = { 0 };
13109 char out[BLOCK_SIZE] = { 0 };
13110
13111 FILE *fp = NULL;
13112
13113 uint rule_line = 0;
13114
13115 if ((fp = fopen (rp_file, "rb")) == NULL)
13116 {
13117 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13118
13119 return (-1);
13120 }
13121
13122 while (!feof (fp))
13123 {
13124 memset (rule_buf, 0, HCBUFSIZ);
13125
13126 rule_len = fgetl (fp, rule_buf);
13127
13128 rule_line++;
13129
13130 if (rule_len == 0) continue;
13131
13132 if (rule_buf[0] == '#') continue;
13133
13134 if (kernel_rules_avail == kernel_rules_cnt)
13135 {
13136 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13137
13138 kernel_rules_avail += INCR_RULES;
13139 }
13140
13141 memset (in, 0, BLOCK_SIZE);
13142 memset (out, 0, BLOCK_SIZE);
13143
13144 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13145
13146 if (result == -1)
13147 {
13148 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13149
13150 continue;
13151 }
13152
13153 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13154 {
13155 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13156
13157 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13158
13159 continue;
13160 }
13161
13162 /* its so slow
13163 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13164 {
13165 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13166
13167 continue;
13168 }
13169 */
13170
13171 kernel_rules_cnt++;
13172 }
13173
13174 fclose (fp);
13175
13176 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13177
13178 all_kernel_rules_buf[i] = kernel_rules_buf;
13179 }
13180
13181 /**
13182 * merge rules or automatic rule generator
13183 */
13184
13185 uint kernel_rules_cnt = 0;
13186
13187 kernel_rule_t *kernel_rules_buf = NULL;
13188
13189 if (attack_mode == ATTACK_MODE_STRAIGHT)
13190 {
13191 if (rp_files_cnt)
13192 {
13193 kernel_rules_cnt = 1;
13194
13195 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13196
13197 repeats[0] = kernel_rules_cnt;
13198
13199 for (uint i = 0; i < rp_files_cnt; i++)
13200 {
13201 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13202
13203 repeats[i + 1] = kernel_rules_cnt;
13204 }
13205
13206 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13207
13208 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13209
13210 for (uint i = 0; i < kernel_rules_cnt; i++)
13211 {
13212 uint out_pos = 0;
13213
13214 kernel_rule_t *out = &kernel_rules_buf[i];
13215
13216 for (uint j = 0; j < rp_files_cnt; j++)
13217 {
13218 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13219 uint in_pos;
13220
13221 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13222
13223 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13224 {
13225 if (out_pos == RULES_MAX - 1)
13226 {
13227 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13228
13229 break;
13230 }
13231
13232 out->cmds[out_pos] = in->cmds[in_pos];
13233 }
13234 }
13235 }
13236
13237 local_free (repeats);
13238 }
13239 else if (rp_gen)
13240 {
13241 uint kernel_rules_avail = 0;
13242
13243 while (kernel_rules_cnt < rp_gen)
13244 {
13245 if (kernel_rules_avail == kernel_rules_cnt)
13246 {
13247 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13248
13249 kernel_rules_avail += INCR_RULES;
13250 }
13251
13252 memset (rule_buf, 0, HCBUFSIZ);
13253
13254 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13255
13256 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13257
13258 kernel_rules_cnt++;
13259 }
13260 }
13261 }
13262
13263 myfree (rule_buf);
13264
13265 /**
13266 * generate NOP rules
13267 */
13268
13269 if (kernel_rules_cnt == 0)
13270 {
13271 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13272
13273 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13274
13275 kernel_rules_cnt++;
13276 }
13277
13278 data.kernel_rules_cnt = kernel_rules_cnt;
13279 data.kernel_rules_buf = kernel_rules_buf;
13280
13281 /**
13282 * OpenCL platforms: detect
13283 */
13284
13285 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13286 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13287
13288 cl_uint platforms_cnt = 0;
13289 cl_uint platform_devices_cnt = 0;
13290
13291 if (keyspace == 0)
13292 {
13293 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13294
13295 if (platforms_cnt == 0)
13296 {
13297 log_info ("");
13298 log_info ("ATTENTION! No OpenCL compatible platform found");
13299 log_info ("");
13300 log_info ("You're probably missing the OpenCL runtime installation");
13301 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13302 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13303 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13304 log_info ("");
13305
13306 return (-1);
13307 }
13308
13309 if (opencl_platforms_filter != (uint) -1)
13310 {
13311 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13312
13313 if (opencl_platforms_filter > platform_cnt_mask)
13314 {
13315 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13316
13317 return (-1);
13318 }
13319 }
13320 }
13321
13322 /**
13323 * OpenCL device types:
13324 * 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.
13325 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13326 */
13327
13328 if (opencl_device_types == NULL)
13329 {
13330 cl_device_type device_types_all = 0;
13331
13332 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13333 {
13334 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13335
13336 cl_platform_id platform = platforms[platform_id];
13337
13338 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13339
13340 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13341 {
13342 cl_device_id device = platform_devices[platform_devices_id];
13343
13344 cl_device_type device_type;
13345
13346 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13347
13348 device_types_all |= device_type;
13349 }
13350 }
13351
13352 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13353 {
13354 device_types_filter |= CL_DEVICE_TYPE_CPU;
13355 }
13356 }
13357
13358 /**
13359 * OpenCL devices: simply push all devices from all platforms into the same device array
13360 */
13361
13362 int need_adl = 0;
13363 int need_nvapi = 0;
13364 int need_nvml = 0;
13365
13366 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13367
13368 data.devices_param = devices_param;
13369
13370 uint devices_cnt = 0;
13371
13372 uint devices_active = 0;
13373
13374 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13375 {
13376 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13377
13378 cl_platform_id platform = platforms[platform_id];
13379
13380 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13381
13382 char platform_vendor[INFOSZ] = { 0 };
13383
13384 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13385
13386 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13387 // this causes trouble with vendor id based macros
13388 // we'll assign generic to those without special optimization available
13389
13390 cl_uint platform_vendor_id = 0;
13391
13392 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13393 {
13394 platform_vendor_id = VENDOR_ID_AMD;
13395 }
13396 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13397 {
13398 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13399 }
13400 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13401 {
13402 platform_vendor_id = VENDOR_ID_APPLE;
13403 }
13404 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13405 {
13406 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13407 }
13408 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13409 {
13410 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13411 }
13412 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13413 {
13414 platform_vendor_id = VENDOR_ID_MESA;
13415 }
13416 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13417 {
13418 platform_vendor_id = VENDOR_ID_NV;
13419 }
13420 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13421 {
13422 platform_vendor_id = VENDOR_ID_POCL;
13423 }
13424 else
13425 {
13426 platform_vendor_id = VENDOR_ID_GENERIC;
13427 }
13428
13429 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13430 {
13431 size_t param_value_size = 0;
13432
13433 const uint device_id = devices_cnt;
13434
13435 hc_device_param_t *device_param = &data.devices_param[device_id];
13436
13437 device_param->platform_vendor_id = platform_vendor_id;
13438
13439 device_param->device = platform_devices[platform_devices_id];
13440
13441 device_param->device_id = device_id;
13442
13443 device_param->platform_devices_id = platform_devices_id;
13444
13445 // device_type
13446
13447 cl_device_type device_type;
13448
13449 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13450
13451 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13452
13453 device_param->device_type = device_type;
13454
13455 // device_name
13456
13457 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13458
13459 char *device_name = (char *) mymalloc (param_value_size);
13460
13461 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13462
13463 device_param->device_name = device_name;
13464
13465 // device_vendor
13466
13467 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13468
13469 char *device_vendor = (char *) mymalloc (param_value_size);
13470
13471 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13472
13473 device_param->device_vendor = device_vendor;
13474
13475 cl_uint device_vendor_id = 0;
13476
13477 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13478 {
13479 device_vendor_id = VENDOR_ID_AMD;
13480 }
13481 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13482 {
13483 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13484 }
13485 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13486 {
13487 device_vendor_id = VENDOR_ID_APPLE;
13488 }
13489 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13490 {
13491 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13492 }
13493 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13494 {
13495 device_vendor_id = VENDOR_ID_INTEL_SDK;
13496 }
13497 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13498 {
13499 device_vendor_id = VENDOR_ID_MESA;
13500 }
13501 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13502 {
13503 device_vendor_id = VENDOR_ID_NV;
13504 }
13505 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13506 {
13507 device_vendor_id = VENDOR_ID_POCL;
13508 }
13509 else
13510 {
13511 device_vendor_id = VENDOR_ID_GENERIC;
13512 }
13513
13514 device_param->device_vendor_id = device_vendor_id;
13515
13516 // tuning db
13517
13518 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13519
13520 // device_version
13521
13522 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13523
13524 char *device_version = (char *) mymalloc (param_value_size);
13525
13526 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13527
13528 device_param->device_version = device_version;
13529
13530 // device_opencl_version
13531
13532 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13533
13534 char *device_opencl_version = (char *) mymalloc (param_value_size);
13535
13536 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13537
13538 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13539
13540 myfree (device_opencl_version);
13541
13542 // vector_width
13543
13544 cl_uint vector_width;
13545
13546 if (opencl_vector_width_chgd == 0)
13547 {
13548 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13549 {
13550 if (opti_type & OPTI_TYPE_USES_BITS_64)
13551 {
13552 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13553 }
13554 else
13555 {
13556 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13557 }
13558 }
13559 else
13560 {
13561 vector_width = (cl_uint) tuningdb_entry->vector_width;
13562 }
13563 }
13564 else
13565 {
13566 vector_width = opencl_vector_width;
13567 }
13568
13569 if (vector_width > 16) vector_width = 16;
13570
13571 device_param->vector_width = vector_width;
13572
13573 // max_compute_units
13574
13575 cl_uint device_processors;
13576
13577 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13578
13579 device_param->device_processors = device_processors;
13580
13581 // device_maxmem_alloc
13582 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13583
13584 cl_ulong device_maxmem_alloc;
13585
13586 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13587
13588 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13589
13590 // device_global_mem
13591
13592 cl_ulong device_global_mem;
13593
13594 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13595
13596 device_param->device_global_mem = device_global_mem;
13597
13598 // max_work_group_size
13599
13600 size_t device_maxworkgroup_size;
13601
13602 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13603
13604 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13605
13606 // max_clock_frequency
13607
13608 cl_uint device_maxclock_frequency;
13609
13610 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13611
13612 device_param->device_maxclock_frequency = device_maxclock_frequency;
13613
13614 // device_endian_little
13615
13616 cl_bool device_endian_little;
13617
13618 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13619
13620 if (device_endian_little == CL_FALSE)
13621 {
13622 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13623
13624 device_param->skipped = 1;
13625 }
13626
13627 // device_available
13628
13629 cl_bool device_available;
13630
13631 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13632
13633 if (device_available == CL_FALSE)
13634 {
13635 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13636
13637 device_param->skipped = 1;
13638 }
13639
13640 // device_compiler_available
13641
13642 cl_bool device_compiler_available;
13643
13644 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13645
13646 if (device_compiler_available == CL_FALSE)
13647 {
13648 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13649
13650 device_param->skipped = 1;
13651 }
13652
13653 // device_execution_capabilities
13654
13655 cl_device_exec_capabilities device_execution_capabilities;
13656
13657 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13658
13659 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13660 {
13661 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13662
13663 device_param->skipped = 1;
13664 }
13665
13666 // device_extensions
13667
13668 size_t device_extensions_size;
13669
13670 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13671
13672 char *device_extensions = mymalloc (device_extensions_size + 1);
13673
13674 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13675
13676 if (strstr (device_extensions, "base_atomics") == 0)
13677 {
13678 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13679
13680 device_param->skipped = 1;
13681 }
13682
13683 if (strstr (device_extensions, "byte_addressable_store") == 0)
13684 {
13685 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13686
13687 device_param->skipped = 1;
13688 }
13689
13690 myfree (device_extensions);
13691
13692 // device_local_mem_size
13693
13694 cl_ulong device_local_mem_size;
13695
13696 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13697
13698 if (device_local_mem_size < 32768)
13699 {
13700 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13701
13702 device_param->skipped = 1;
13703 }
13704
13705 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13706 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13707 // This results in both utilizing it for 50%
13708 // However, Intel has much better SIMD control over their own hardware
13709 // It makes sense to give them full control over their own hardware
13710
13711 if (device_type & CL_DEVICE_TYPE_CPU)
13712 {
13713 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13714 {
13715 if (data.force == 0)
13716 {
13717 if (algorithm_pos == 0)
13718 {
13719 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
13720 log_info (" You can use --force to override this but do not post error reports if you do so");
13721 }
13722
13723 device_param->skipped = 1;
13724 }
13725 }
13726 }
13727
13728 // skipped
13729
13730 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13731 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13732
13733 // driver_version
13734
13735 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13736
13737 char *driver_version = (char *) mymalloc (param_value_size);
13738
13739 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13740
13741 device_param->driver_version = driver_version;
13742
13743 // device_name_chksum
13744
13745 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13746
13747 #if __x86_64__
13748 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);
13749 #else
13750 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);
13751 #endif
13752
13753 uint device_name_digest[4] = { 0 };
13754
13755 md5_64 ((uint *) device_name_chksum, device_name_digest);
13756
13757 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13758
13759 device_param->device_name_chksum = device_name_chksum;
13760
13761 // device_processor_cores
13762
13763 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
13764 {
13765 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
13766 {
13767 need_adl = 1;
13768 }
13769
13770 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
13771 {
13772 need_nvml = 1;
13773
13774 #ifdef _WIN
13775 need_nvapi = 1;
13776 #endif
13777 }
13778 }
13779
13780 // device_processor_cores
13781
13782 if (device_type & CL_DEVICE_TYPE_CPU)
13783 {
13784 cl_uint device_processor_cores = 1;
13785
13786 device_param->device_processor_cores = device_processor_cores;
13787 }
13788
13789 if (device_type & CL_DEVICE_TYPE_GPU)
13790 {
13791 if (device_vendor_id == VENDOR_ID_AMD)
13792 {
13793 cl_uint device_processor_cores = 0;
13794
13795 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13796
13797 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13798
13799 device_param->device_processor_cores = device_processor_cores;
13800 }
13801 else if (device_vendor_id == VENDOR_ID_NV)
13802 {
13803 cl_uint kernel_exec_timeout = 0;
13804
13805 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13806
13807 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13808
13809 device_param->kernel_exec_timeout = kernel_exec_timeout;
13810
13811 cl_uint device_processor_cores = 0;
13812
13813 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13814
13815 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13816
13817 device_param->device_processor_cores = device_processor_cores;
13818
13819 cl_uint sm_minor = 0;
13820 cl_uint sm_major = 0;
13821
13822 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13823 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13824
13825 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13826 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13827
13828 device_param->sm_minor = sm_minor;
13829 device_param->sm_major = sm_major;
13830 }
13831 else
13832 {
13833 cl_uint device_processor_cores = 1;
13834
13835 device_param->device_processor_cores = device_processor_cores;
13836 }
13837 }
13838
13839 // display results
13840
13841 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13842 {
13843 if (machine_readable == 0)
13844 {
13845 if (device_param->skipped == 0)
13846 {
13847 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13848 device_id + 1,
13849 device_name,
13850 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13851 (unsigned int) (device_global_mem / 1024 / 1024),
13852 (unsigned int) device_processors);
13853 }
13854 else
13855 {
13856 log_info ("Device #%u: %s, skipped",
13857 device_id + 1,
13858 device_name);
13859 }
13860 }
13861 }
13862
13863 // common driver check
13864
13865 if (device_param->skipped == 0)
13866 {
13867 if (device_type & CL_DEVICE_TYPE_GPU)
13868 {
13869 if (platform_vendor_id == VENDOR_ID_AMD)
13870 {
13871 int catalyst_check = (force == 1) ? 0 : 1;
13872
13873 int catalyst_warn = 0;
13874
13875 int catalyst_broken = 0;
13876
13877 if (catalyst_check == 1)
13878 {
13879 catalyst_warn = 1;
13880
13881 // v14.9 and higher
13882 if (atoi (device_param->driver_version) >= 1573)
13883 {
13884 catalyst_warn = 0;
13885 }
13886
13887 catalyst_check = 0;
13888 }
13889
13890 if (catalyst_broken == 1)
13891 {
13892 log_info ("");
13893 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13894 log_info ("It will pass over cracked hashes and does not report them as cracked");
13895 log_info ("You are STRONGLY encouraged not to use it");
13896 log_info ("You can use --force to override this but do not post error reports if you do so");
13897 log_info ("");
13898
13899 return (-1);
13900 }
13901
13902 if (catalyst_warn == 1)
13903 {
13904 log_info ("");
13905 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13906 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13907 log_info ("See hashcat's homepage for official supported catalyst drivers");
13908 #ifdef _WIN
13909 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13910 #endif
13911 log_info ("You can use --force to override this but do not post error reports if you do so");
13912 log_info ("");
13913
13914 return (-1);
13915 }
13916 }
13917 else if (platform_vendor_id == VENDOR_ID_NV)
13918 {
13919 if (device_param->kernel_exec_timeout != 0)
13920 {
13921 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);
13922 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13923 }
13924 }
13925 }
13926
13927 /* turns out pocl still creates segfaults (because of llvm)
13928 if (device_type & CL_DEVICE_TYPE_CPU)
13929 {
13930 if (platform_vendor_id == VENDOR_ID_AMD)
13931 {
13932 if (force == 0)
13933 {
13934 log_info ("");
13935 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13936 log_info ("You are STRONGLY encouraged not to use it");
13937 log_info ("You can use --force to override this but do not post error reports if you do so");
13938 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13939 log_info ("");
13940
13941 return (-1);
13942 }
13943 }
13944 }
13945 */
13946
13947 /**
13948 * kernel accel and loops tuning db adjustment
13949 */
13950
13951 device_param->kernel_accel_min = 1;
13952 device_param->kernel_accel_max = 1024;
13953
13954 device_param->kernel_loops_min = 1;
13955 device_param->kernel_loops_max = 1024;
13956
13957 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13958
13959 if (tuningdb_entry)
13960 {
13961 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13962 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13963
13964 if (_kernel_accel)
13965 {
13966 device_param->kernel_accel_min = _kernel_accel;
13967 device_param->kernel_accel_max = _kernel_accel;
13968 }
13969
13970 if (_kernel_loops)
13971 {
13972 if (workload_profile == 1)
13973 {
13974 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13975 }
13976 else if (workload_profile == 2)
13977 {
13978 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13979 }
13980
13981 device_param->kernel_loops_min = _kernel_loops;
13982 device_param->kernel_loops_max = _kernel_loops;
13983 }
13984 }
13985
13986 // commandline parameters overwrite tuningdb entries
13987
13988 if (kernel_accel)
13989 {
13990 device_param->kernel_accel_min = kernel_accel;
13991 device_param->kernel_accel_max = kernel_accel;
13992 }
13993
13994 if (kernel_loops)
13995 {
13996 device_param->kernel_loops_min = kernel_loops;
13997 device_param->kernel_loops_max = kernel_loops;
13998 }
13999
14000 /**
14001 * activate device
14002 */
14003
14004 devices_active++;
14005 }
14006
14007 // next please
14008
14009 devices_cnt++;
14010 }
14011 }
14012
14013 if (keyspace == 0 && devices_active == 0)
14014 {
14015 log_error ("ERROR: No devices found/left");
14016
14017 return (-1);
14018 }
14019
14020 // 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)
14021
14022 if (devices_filter != (uint) -1)
14023 {
14024 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14025
14026 if (devices_filter > devices_cnt_mask)
14027 {
14028 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14029
14030 return (-1);
14031 }
14032 }
14033
14034 data.devices_cnt = devices_cnt;
14035
14036 data.devices_active = devices_active;
14037
14038 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14039 {
14040 if (machine_readable == 0)
14041 {
14042 log_info ("");
14043 }
14044 }
14045
14046 /**
14047 * HM devices: init
14048 */
14049
14050 #ifdef HAVE_HWMON
14051 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14052 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14053 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14054
14055 if (gpu_temp_disable == 0)
14056 {
14057 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14058 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14059 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14060
14061 data.hm_adl = NULL;
14062 data.hm_nvapi = NULL;
14063 data.hm_nvml = NULL;
14064
14065 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14066 {
14067 data.hm_nvml = nvml;
14068 }
14069
14070 if (data.hm_nvml)
14071 {
14072 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14073 {
14074 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14075
14076 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14077
14078 int tmp_out = 0;
14079
14080 for (int i = 0; i < tmp_in; i++)
14081 {
14082 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14083 }
14084
14085 for (int i = 0; i < tmp_out; i++)
14086 {
14087 unsigned int speed;
14088
14089 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14090
14091 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14092
14093 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14094 }
14095 }
14096 }
14097
14098 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14099 {
14100 data.hm_nvapi = nvapi;
14101 }
14102
14103 if (data.hm_nvapi)
14104 {
14105 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14106 {
14107 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14108
14109 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14110
14111 int tmp_out = 0;
14112
14113 for (int i = 0; i < tmp_in; i++)
14114 {
14115 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14116 }
14117 }
14118 }
14119
14120 if ((need_adl == 1) && (adl_init (adl) == 0))
14121 {
14122 data.hm_adl = adl;
14123 }
14124
14125 if (data.hm_adl)
14126 {
14127 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14128 {
14129 // total number of adapters
14130
14131 int hm_adapters_num;
14132
14133 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14134
14135 // adapter info
14136
14137 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14138
14139 if (lpAdapterInfo == NULL) return (-1);
14140
14141 // get a list (of ids of) valid/usable adapters
14142
14143 int num_adl_adapters = 0;
14144
14145 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14146
14147 if (num_adl_adapters > 0)
14148 {
14149 hc_thread_mutex_lock (mux_adl);
14150
14151 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14152
14153 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14154
14155 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14156 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14157
14158 hc_thread_mutex_unlock (mux_adl);
14159 }
14160
14161 myfree (valid_adl_device_list);
14162 myfree (lpAdapterInfo);
14163 }
14164 }
14165
14166 if (data.hm_adl == NULL && data.hm_nvml == NULL)
14167 {
14168 gpu_temp_disable = 1;
14169 }
14170 }
14171
14172 /**
14173 * OpenCL devices: allocate buffer for device specific information
14174 */
14175
14176 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14177 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14178
14179 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14180
14181 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14182
14183 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14184
14185 /**
14186 * User-defined GPU temp handling
14187 */
14188
14189 if (gpu_temp_disable == 1)
14190 {
14191 gpu_temp_abort = 0;
14192 gpu_temp_retain = 0;
14193 }
14194
14195 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14196 {
14197 if (gpu_temp_abort < gpu_temp_retain)
14198 {
14199 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14200
14201 return (-1);
14202 }
14203 }
14204
14205 data.gpu_temp_disable = gpu_temp_disable;
14206 data.gpu_temp_abort = gpu_temp_abort;
14207 data.gpu_temp_retain = gpu_temp_retain;
14208 #endif
14209
14210 /**
14211 * enable custom signal handler(s)
14212 */
14213
14214 if (benchmark == 0)
14215 {
14216 hc_signal (sigHandler_default);
14217 }
14218 else
14219 {
14220 hc_signal (sigHandler_benchmark);
14221 }
14222
14223 /**
14224 * inform the user
14225 */
14226
14227 if (data.quiet == 0)
14228 {
14229 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14230
14231 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);
14232
14233 if (attack_mode == ATTACK_MODE_STRAIGHT)
14234 {
14235 log_info ("Rules: %u", kernel_rules_cnt);
14236 }
14237
14238 if (opti_type)
14239 {
14240 log_info ("Applicable Optimizers:");
14241
14242 for (uint i = 0; i < 32; i++)
14243 {
14244 const uint opti_bit = 1u << i;
14245
14246 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14247 }
14248 }
14249
14250 /**
14251 * Watchdog and Temperature balance
14252 */
14253
14254 #ifdef HAVE_HWMON
14255 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
14256 {
14257 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14258 }
14259
14260 if (gpu_temp_abort == 0)
14261 {
14262 log_info ("Watchdog: Temperature abort trigger disabled");
14263 }
14264 else
14265 {
14266 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14267 }
14268
14269 if (gpu_temp_retain == 0)
14270 {
14271 log_info ("Watchdog: Temperature retain trigger disabled");
14272 }
14273 else
14274 {
14275 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14276 }
14277
14278 if (data.quiet == 0) log_info ("");
14279 #endif
14280 }
14281
14282 #ifdef HAVE_HWMON
14283
14284 /**
14285 * HM devices: copy
14286 */
14287
14288 if (gpu_temp_disable == 0)
14289 {
14290 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14291 {
14292 hc_device_param_t *device_param = &data.devices_param[device_id];
14293
14294 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14295
14296 if (device_param->skipped) continue;
14297
14298 const uint platform_devices_id = device_param->platform_devices_id;
14299
14300 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14301 {
14302 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14303 data.hm_device[device_id].nvapi = 0;
14304 data.hm_device[device_id].nvml = 0;
14305 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14306 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14307 data.hm_device[device_id].fan_set_supported = hm_adapters_adl[platform_devices_id].fan_set_supported;
14308 }
14309
14310 if (device_param->device_vendor_id == VENDOR_ID_NV)
14311 {
14312 data.hm_device[device_id].adl = 0;
14313 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14314 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14315 data.hm_device[device_id].od_version = 0;
14316 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14317 data.hm_device[device_id].fan_set_supported = 0;
14318 }
14319 }
14320 }
14321
14322 /**
14323 * powertune on user request
14324 */
14325
14326 if (powertune_enable == 1)
14327 {
14328 hc_thread_mutex_lock (mux_adl);
14329
14330 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14331 {
14332 hc_device_param_t *device_param = &data.devices_param[device_id];
14333
14334 if (device_param->skipped) continue;
14335
14336 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14337 {
14338 /**
14339 * Temporary fix:
14340 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14341 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14342 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14343 * Driver / ADL bug?
14344 */
14345
14346 if (data.hm_device[device_id].od_version == 6)
14347 {
14348 int ADL_rc;
14349
14350 // check powertune capabilities first, if not available then skip device
14351
14352 int powertune_supported = 0;
14353
14354 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14355 {
14356 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14357
14358 return (-1);
14359 }
14360
14361 // first backup current value, we will restore it later
14362
14363 if (powertune_supported != 0)
14364 {
14365 // powercontrol settings
14366
14367 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14368
14369 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14370 {
14371 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14372 }
14373
14374 if (ADL_rc != ADL_OK)
14375 {
14376 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14377
14378 return (-1);
14379 }
14380
14381 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14382 {
14383 log_error ("ERROR: Failed to set new ADL PowerControl values");
14384
14385 return (-1);
14386 }
14387
14388 // clocks
14389
14390 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14391
14392 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14393
14394 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)
14395 {
14396 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14397
14398 return (-1);
14399 }
14400
14401 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14402
14403 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14404
14405 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14406 {
14407 log_error ("ERROR: Failed to get ADL device capabilities");
14408
14409 return (-1);
14410 }
14411
14412 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14413 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14414
14415 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14416 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14417
14418 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14419 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14420
14421 // warning if profile has too low max values
14422
14423 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14424 {
14425 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14426 }
14427
14428 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14429 {
14430 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14431 }
14432
14433 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14434
14435 performance_state->iNumberOfPerformanceLevels = 2;
14436
14437 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14438 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14439 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14440 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14441
14442 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)
14443 {
14444 log_info ("ERROR: Failed to set ADL performance state");
14445
14446 return (-1);
14447 }
14448
14449 local_free (performance_state);
14450 }
14451
14452 // set powertune value only
14453
14454 if (powertune_supported != 0)
14455 {
14456 // powertune set
14457 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14458
14459 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14460 {
14461 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14462
14463 return (-1);
14464 }
14465
14466 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14467 {
14468 log_error ("ERROR: Failed to set new ADL PowerControl values");
14469
14470 return (-1);
14471 }
14472 }
14473 }
14474 }
14475
14476 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14477 {
14478 // first backup current value, we will restore it later
14479
14480 unsigned int limit;
14481
14482 int powertune_supported = 0;
14483
14484 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14485 {
14486 powertune_supported = 1;
14487 }
14488
14489 // if backup worked, activate the maximum allowed
14490
14491 if (powertune_supported != 0)
14492 {
14493 unsigned int minLimit;
14494 unsigned int maxLimit;
14495
14496 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14497 {
14498 if (maxLimit > 0)
14499 {
14500 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14501 {
14502 // now we can be sure we need to reset later
14503
14504 nvml_power_limit[device_id] = limit;
14505 }
14506 }
14507 }
14508 }
14509 }
14510 }
14511
14512 hc_thread_mutex_unlock (mux_adl);
14513 }
14514
14515 #endif // HAVE_HWMON
14516
14517 #ifdef DEBUG
14518 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14519 #endif
14520
14521 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14522
14523 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14524 {
14525 /**
14526 * host buffer
14527 */
14528
14529 hc_device_param_t *device_param = &data.devices_param[device_id];
14530
14531 if (device_param->skipped) continue;
14532
14533 /**
14534 * device properties
14535 */
14536
14537 const char *device_name_chksum = device_param->device_name_chksum;
14538 const u32 device_processors = device_param->device_processors;
14539 const u32 device_processor_cores = device_param->device_processor_cores;
14540
14541 /**
14542 * create context for each device
14543 */
14544
14545 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14546
14547 /**
14548 * create command-queue
14549 */
14550
14551 // not supported with NV
14552 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14553
14554 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14555
14556 /**
14557 * kernel threads: some algorithms need a fixed kernel-threads count
14558 * because of shared memory usage or bitslice
14559 * there needs to be some upper limit, otherwise there's too much overhead
14560 */
14561
14562 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14563
14564 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14565 {
14566 kernel_threads = KERNEL_THREADS_MAX_CPU;
14567 }
14568
14569 if (hash_mode == 1500) kernel_threads = 64; // DES
14570 if (hash_mode == 3000) kernel_threads = 64; // DES
14571 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14572 if (hash_mode == 7500) kernel_threads = 64; // RC4
14573 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14574 if (hash_mode == 9700) kernel_threads = 64; // RC4
14575 if (hash_mode == 9710) kernel_threads = 64; // RC4
14576 if (hash_mode == 9800) kernel_threads = 64; // RC4
14577 if (hash_mode == 9810) kernel_threads = 64; // RC4
14578 if (hash_mode == 10400) kernel_threads = 64; // RC4
14579 if (hash_mode == 10410) kernel_threads = 64; // RC4
14580 if (hash_mode == 10500) kernel_threads = 64; // RC4
14581 if (hash_mode == 13100) kernel_threads = 64; // RC4
14582
14583 device_param->kernel_threads = kernel_threads;
14584
14585 device_param->hardware_power = device_processors * kernel_threads;
14586
14587 /**
14588 * create input buffers on device : calculate size of fixed memory buffers
14589 */
14590
14591 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14592 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14593
14594 device_param->size_root_css = size_root_css;
14595 device_param->size_markov_css = size_markov_css;
14596
14597 size_t size_results = sizeof (uint);
14598
14599 device_param->size_results = size_results;
14600
14601 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14602 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14603
14604 size_t size_plains = digests_cnt * sizeof (plain_t);
14605 size_t size_salts = salts_cnt * sizeof (salt_t);
14606 size_t size_esalts = salts_cnt * esalt_size;
14607
14608 device_param->size_plains = size_plains;
14609 device_param->size_digests = size_digests;
14610 device_param->size_shown = size_shown;
14611 device_param->size_salts = size_salts;
14612
14613 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14614 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14615 size_t size_tm = 32 * sizeof (bs_word_t);
14616
14617 // scryptV stuff
14618
14619 size_t size_scryptV = 1;
14620
14621 if ((hash_mode == 8900) || (hash_mode == 9300))
14622 {
14623 uint tmto_start = 0;
14624 uint tmto_stop = 10;
14625
14626 if (scrypt_tmto)
14627 {
14628 tmto_start = scrypt_tmto;
14629 }
14630 else
14631 {
14632 // in case the user did not specify the tmto manually
14633 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14634 // but set the lower end only in case the user has a device with too less memory
14635
14636 if (hash_mode == 8900)
14637 {
14638 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14639 {
14640 tmto_start = 1;
14641 }
14642 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14643 {
14644 tmto_start = 2;
14645 }
14646 }
14647 else if (hash_mode == 9300)
14648 {
14649 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14650 {
14651 tmto_start = 2;
14652 }
14653 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14654 {
14655 tmto_start = 2;
14656 }
14657 }
14658 }
14659
14660 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14661 {
14662 // TODO: in theory the following calculation needs to be done per salt, not global
14663 // we assume all hashes have the same scrypt settings
14664
14665 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14666
14667 size_scryptV /= 1 << tmto;
14668
14669 size_scryptV *= device_processors * device_processor_cores;
14670
14671 if (size_scryptV > device_param->device_maxmem_alloc)
14672 {
14673 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14674
14675 continue;
14676 }
14677
14678 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14679 {
14680 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14681 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14682 }
14683
14684 break;
14685 }
14686
14687 if (data.salts_buf[0].scrypt_phy == 0)
14688 {
14689 log_error ("ERROR: can't allocate enough device memory");
14690
14691 return -1;
14692 }
14693
14694 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14695 }
14696
14697 /**
14698 * some algorithms need a fixed kernel-loops count
14699 */
14700
14701 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
14702 {
14703 const u32 kernel_loops_fixed = 1024;
14704
14705 device_param->kernel_loops_min = kernel_loops_fixed;
14706 device_param->kernel_loops_max = kernel_loops_fixed;
14707 }
14708
14709 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
14710 {
14711 const u32 kernel_loops_fixed = 1024;
14712
14713 device_param->kernel_loops_min = kernel_loops_fixed;
14714 device_param->kernel_loops_max = kernel_loops_fixed;
14715 }
14716
14717 if (hash_mode == 8900)
14718 {
14719 const u32 kernel_loops_fixed = 1;
14720
14721 device_param->kernel_loops_min = kernel_loops_fixed;
14722 device_param->kernel_loops_max = kernel_loops_fixed;
14723 }
14724
14725 if (hash_mode == 9300)
14726 {
14727 const u32 kernel_loops_fixed = 1;
14728
14729 device_param->kernel_loops_min = kernel_loops_fixed;
14730 device_param->kernel_loops_max = kernel_loops_fixed;
14731 }
14732
14733 if (hash_mode == 12500)
14734 {
14735 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14736
14737 device_param->kernel_loops_min = kernel_loops_fixed;
14738 device_param->kernel_loops_max = kernel_loops_fixed;
14739 }
14740
14741 /**
14742 * some algorithms have a maximum kernel-loops count
14743 */
14744
14745 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14746 {
14747 u32 innerloop_cnt = 0;
14748
14749 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14750 {
14751 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14752 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14753 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14754 }
14755 else
14756 {
14757 innerloop_cnt = data.salts_buf[0].salt_iter;
14758 }
14759
14760 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14761 (innerloop_cnt <= device_param->kernel_loops_max))
14762 {
14763 device_param->kernel_loops_max = innerloop_cnt;
14764 }
14765 }
14766
14767 u32 kernel_accel_min = device_param->kernel_accel_min;
14768 u32 kernel_accel_max = device_param->kernel_accel_max;
14769
14770 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14771
14772 size_t size_pws = 4;
14773 size_t size_tmps = 4;
14774 size_t size_hooks = 4;
14775
14776 while (kernel_accel_max >= kernel_accel_min)
14777 {
14778 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14779
14780 // size_pws
14781
14782 size_pws = kernel_power_max * sizeof (pw_t);
14783
14784 // size_tmps
14785
14786 switch (hash_mode)
14787 {
14788 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14789 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14790 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14791 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14792 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14793 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14794 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14795 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14796 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14797 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14798 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14799 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14800 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14801 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14802 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14803 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14804 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14805 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14806 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14807 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14808 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14809 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14810 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14811 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14812 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14813 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14814 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14815 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14816 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14817 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14818 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14819 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14820 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14821 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14822 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14823 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14824 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14825 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14826 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14827 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14828 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14829 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14830 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14831 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14832 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14833 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14834 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14835 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14836 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14837 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14838 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14839 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14840 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14841 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14842 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14843 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14844 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14845 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14846 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14847 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14848 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14849 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14850 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14851 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14852 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14853 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14854 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14855 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14856 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14857 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14858 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14859 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14860 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14861 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14862 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14863 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14864 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14865 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14866 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14867 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14868 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14869 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14870 };
14871
14872 // size_hooks
14873
14874 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14875 {
14876 // none yet
14877 }
14878
14879 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14880 // if not, decrease amplifier and try again
14881
14882 int skip = 0;
14883
14884 const u64 size_total
14885 = bitmap_size
14886 + bitmap_size
14887 + bitmap_size
14888 + bitmap_size
14889 + bitmap_size
14890 + bitmap_size
14891 + bitmap_size
14892 + bitmap_size
14893 + size_bfs
14894 + size_combs
14895 + size_digests
14896 + size_esalts
14897 + size_hooks
14898 + size_markov_css
14899 + size_plains
14900 + size_pws
14901 + size_pws // not a bug
14902 + size_results
14903 + size_root_css
14904 + size_rules
14905 + size_rules_c
14906 + size_salts
14907 + size_scryptV
14908 + size_shown
14909 + size_tm
14910 + size_tmps;
14911
14912 // Don't ask me, ask AMD!
14913
14914 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14915 if (size_total > device_param->device_global_mem) skip = 1;
14916
14917 if (skip == 1)
14918 {
14919 kernel_accel_max--;
14920
14921 continue;
14922 }
14923
14924 break;
14925 }
14926
14927 /*
14928 if (kernel_accel_max == 0)
14929 {
14930 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14931
14932 return -1;
14933 }
14934 */
14935
14936 device_param->kernel_accel_min = kernel_accel_min;
14937 device_param->kernel_accel_max = kernel_accel_max;
14938
14939 /*
14940 if (kernel_accel_max < kernel_accel)
14941 {
14942 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14943
14944 device_param->kernel_accel = kernel_accel_max;
14945 }
14946 */
14947
14948 device_param->size_bfs = size_bfs;
14949 device_param->size_combs = size_combs;
14950 device_param->size_rules = size_rules;
14951 device_param->size_rules_c = size_rules_c;
14952 device_param->size_pws = size_pws;
14953 device_param->size_tmps = size_tmps;
14954 device_param->size_hooks = size_hooks;
14955
14956 /**
14957 * default building options
14958 */
14959
14960 char build_opts[1024] = { 0 };
14961
14962 // we don't have sm_* on vendors not NV but it doesn't matter
14963
14964 #if _WIN
14965 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);
14966 #else
14967 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);
14968 #endif
14969
14970 char build_opts_new[1024] = { 0 };
14971
14972 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);
14973
14974 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14975
14976 /*
14977 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14978 {
14979 // we do vectorizing much better than the auto-vectorizer
14980
14981 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14982
14983 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14984 }
14985 */
14986
14987 #ifdef DEBUG
14988 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14989 #endif
14990
14991 /**
14992 * main kernel
14993 */
14994
14995 {
14996 /**
14997 * kernel source filename
14998 */
14999
15000 char source_file[256] = { 0 };
15001
15002 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15003
15004 struct stat sst;
15005
15006 if (stat (source_file, &sst) == -1)
15007 {
15008 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15009
15010 return -1;
15011 }
15012
15013 /**
15014 * kernel cached filename
15015 */
15016
15017 char cached_file[256] = { 0 };
15018
15019 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15020
15021 int cached = 1;
15022
15023 struct stat cst;
15024
15025 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15026 {
15027 cached = 0;
15028 }
15029
15030 /**
15031 * kernel compile or load
15032 */
15033
15034 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15035
15036 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15037
15038 if (force_jit_compilation == -1)
15039 {
15040 if (cached == 0)
15041 {
15042 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15043
15044 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15045
15046 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15047
15048 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15049
15050 #ifdef DEBUG
15051 size_t build_log_size = 0;
15052
15053 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15054
15055 if (build_log_size > 1)
15056 {
15057 char *build_log = (char *) malloc (build_log_size + 1);
15058
15059 memset (build_log, 0, build_log_size + 1);
15060
15061 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15062
15063 puts (build_log);
15064
15065 free (build_log);
15066 }
15067 #endif
15068
15069 if (rc != 0)
15070 {
15071 device_param->skipped = true;
15072
15073 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15074
15075 continue;
15076 }
15077
15078 size_t binary_size;
15079
15080 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15081
15082 u8 *binary = (u8 *) mymalloc (binary_size);
15083
15084 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15085
15086 writeProgramBin (cached_file, binary, binary_size);
15087
15088 local_free (binary);
15089 }
15090 else
15091 {
15092 #ifdef DEBUG
15093 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15094 #endif
15095
15096 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15097
15098 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15099
15100 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15101 }
15102 }
15103 else
15104 {
15105 #ifdef DEBUG
15106 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15107 #endif
15108
15109 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15110
15111 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15112
15113 char build_opts_update[1024] = { 0 };
15114
15115 if (force_jit_compilation == 1500)
15116 {
15117 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15118 }
15119 else if (force_jit_compilation == 8900)
15120 {
15121 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);
15122 }
15123 else
15124 {
15125 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15126 }
15127
15128 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15129
15130 #ifdef DEBUG
15131 size_t build_log_size = 0;
15132
15133 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15134
15135 if (build_log_size > 1)
15136 {
15137 char *build_log = (char *) malloc (build_log_size + 1);
15138
15139 memset (build_log, 0, build_log_size + 1);
15140
15141 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15142
15143 puts (build_log);
15144
15145 free (build_log);
15146 }
15147 #endif
15148
15149 if (rc != 0)
15150 {
15151 device_param->skipped = true;
15152
15153 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15154 }
15155 }
15156
15157 local_free (kernel_lengths);
15158 local_free (kernel_sources[0]);
15159 local_free (kernel_sources);
15160 }
15161
15162 /**
15163 * word generator kernel
15164 */
15165
15166 if (attack_mode != ATTACK_MODE_STRAIGHT)
15167 {
15168 /**
15169 * kernel mp source filename
15170 */
15171
15172 char source_file[256] = { 0 };
15173
15174 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15175
15176 struct stat sst;
15177
15178 if (stat (source_file, &sst) == -1)
15179 {
15180 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15181
15182 return -1;
15183 }
15184
15185 /**
15186 * kernel mp cached filename
15187 */
15188
15189 char cached_file[256] = { 0 };
15190
15191 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15192
15193 int cached = 1;
15194
15195 struct stat cst;
15196
15197 if (stat (cached_file, &cst) == -1)
15198 {
15199 cached = 0;
15200 }
15201
15202 /**
15203 * kernel compile or load
15204 */
15205
15206 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15207
15208 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15209
15210 if (cached == 0)
15211 {
15212 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15213 if (quiet == 0) log_info ("");
15214
15215 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15216
15217 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15218
15219 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15220
15221 if (rc != 0)
15222 {
15223 device_param->skipped = true;
15224
15225 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15226
15227 continue;
15228 }
15229
15230 size_t binary_size;
15231
15232 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15233
15234 u8 *binary = (u8 *) mymalloc (binary_size);
15235
15236 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15237
15238 writeProgramBin (cached_file, binary, binary_size);
15239
15240 local_free (binary);
15241 }
15242 else
15243 {
15244 #ifdef DEBUG
15245 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15246 #endif
15247
15248 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15249
15250 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15251
15252 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15253 }
15254
15255 local_free (kernel_lengths);
15256 local_free (kernel_sources[0]);
15257 local_free (kernel_sources);
15258 }
15259
15260 /**
15261 * amplifier kernel
15262 */
15263
15264 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15265 {
15266
15267 }
15268 else
15269 {
15270 /**
15271 * kernel amp source filename
15272 */
15273
15274 char source_file[256] = { 0 };
15275
15276 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15277
15278 struct stat sst;
15279
15280 if (stat (source_file, &sst) == -1)
15281 {
15282 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15283
15284 return -1;
15285 }
15286
15287 /**
15288 * kernel amp cached filename
15289 */
15290
15291 char cached_file[256] = { 0 };
15292
15293 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15294
15295 int cached = 1;
15296
15297 struct stat cst;
15298
15299 if (stat (cached_file, &cst) == -1)
15300 {
15301 cached = 0;
15302 }
15303
15304 /**
15305 * kernel compile or load
15306 */
15307
15308 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15309
15310 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15311
15312 if (cached == 0)
15313 {
15314 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15315 if (quiet == 0) log_info ("");
15316
15317 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15318
15319 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15320
15321 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15322
15323 if (rc != 0)
15324 {
15325 device_param->skipped = true;
15326
15327 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15328
15329 continue;
15330 }
15331
15332 size_t binary_size;
15333
15334 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15335
15336 u8 *binary = (u8 *) mymalloc (binary_size);
15337
15338 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15339
15340 writeProgramBin (cached_file, binary, binary_size);
15341
15342 local_free (binary);
15343 }
15344 else
15345 {
15346 #ifdef DEBUG
15347 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15348 #endif
15349
15350 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15351
15352 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15353
15354 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15355 }
15356
15357 local_free (kernel_lengths);
15358 local_free (kernel_sources[0]);
15359 local_free (kernel_sources);
15360 }
15361
15362 // some algorithm collide too fast, make that impossible
15363
15364 if (benchmark == 1)
15365 {
15366 ((uint *) digests_buf)[0] = -1;
15367 ((uint *) digests_buf)[1] = -1;
15368 ((uint *) digests_buf)[2] = -1;
15369 ((uint *) digests_buf)[3] = -1;
15370 }
15371
15372 /**
15373 * global buffers
15374 */
15375
15376 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15377 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15378 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15379 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15380 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15381 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15382 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15383 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15384 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15385 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15386 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15387 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15388 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15389 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15390 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15391 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15392 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15393 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15394
15395 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);
15396 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);
15397 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);
15398 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);
15399 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);
15400 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);
15401 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);
15402 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);
15403 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15404 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15405 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15406
15407 /**
15408 * special buffers
15409 */
15410
15411 if (attack_kern == ATTACK_KERN_STRAIGHT)
15412 {
15413 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15414 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15415
15416 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15417 }
15418 else if (attack_kern == ATTACK_KERN_COMBI)
15419 {
15420 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15421 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15422 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15423 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15424 }
15425 else if (attack_kern == ATTACK_KERN_BF)
15426 {
15427 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15428 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15429 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15430 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15431 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15432 }
15433
15434 if (size_esalts)
15435 {
15436 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15437
15438 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15439 }
15440
15441 /**
15442 * main host data
15443 */
15444
15445 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15446
15447 device_param->pws_buf = pws_buf;
15448
15449 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15450
15451 device_param->combs_buf = combs_buf;
15452
15453 void *hooks_buf = mymalloc (size_hooks);
15454
15455 device_param->hooks_buf = hooks_buf;
15456
15457 /**
15458 * kernel args
15459 */
15460
15461 device_param->kernel_params_buf32[21] = bitmap_mask;
15462 device_param->kernel_params_buf32[22] = bitmap_shift1;
15463 device_param->kernel_params_buf32[23] = bitmap_shift2;
15464 device_param->kernel_params_buf32[24] = 0; // salt_pos
15465 device_param->kernel_params_buf32[25] = 0; // loop_pos
15466 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15467 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15468 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15469 device_param->kernel_params_buf32[29] = 0; // digests_offset
15470 device_param->kernel_params_buf32[30] = 0; // combs_mode
15471 device_param->kernel_params_buf32[31] = 0; // gid_max
15472
15473 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15474 ? &device_param->d_pws_buf
15475 : &device_param->d_pws_amp_buf;
15476 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15477 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15478 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15479 device_param->kernel_params[ 4] = &device_param->d_tmps;
15480 device_param->kernel_params[ 5] = &device_param->d_hooks;
15481 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15482 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15483 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15484 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15485 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15486 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15487 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15488 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15489 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15490 device_param->kernel_params[15] = &device_param->d_digests_buf;
15491 device_param->kernel_params[16] = &device_param->d_digests_shown;
15492 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15493 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15494 device_param->kernel_params[19] = &device_param->d_result;
15495 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15496 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15497 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15498 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15499 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15500 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15501 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15502 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15503 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15504 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15505 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15506 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15507
15508 device_param->kernel_params_mp_buf64[3] = 0;
15509 device_param->kernel_params_mp_buf32[4] = 0;
15510 device_param->kernel_params_mp_buf32[5] = 0;
15511 device_param->kernel_params_mp_buf32[6] = 0;
15512 device_param->kernel_params_mp_buf32[7] = 0;
15513 device_param->kernel_params_mp_buf32[8] = 0;
15514
15515 device_param->kernel_params_mp[0] = NULL;
15516 device_param->kernel_params_mp[1] = NULL;
15517 device_param->kernel_params_mp[2] = NULL;
15518 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15519 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15520 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15521 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15522 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15523 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15524
15525 device_param->kernel_params_mp_l_buf64[3] = 0;
15526 device_param->kernel_params_mp_l_buf32[4] = 0;
15527 device_param->kernel_params_mp_l_buf32[5] = 0;
15528 device_param->kernel_params_mp_l_buf32[6] = 0;
15529 device_param->kernel_params_mp_l_buf32[7] = 0;
15530 device_param->kernel_params_mp_l_buf32[8] = 0;
15531 device_param->kernel_params_mp_l_buf32[9] = 0;
15532
15533 device_param->kernel_params_mp_l[0] = NULL;
15534 device_param->kernel_params_mp_l[1] = NULL;
15535 device_param->kernel_params_mp_l[2] = NULL;
15536 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15537 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15538 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15539 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15540 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15541 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15542 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15543
15544 device_param->kernel_params_mp_r_buf64[3] = 0;
15545 device_param->kernel_params_mp_r_buf32[4] = 0;
15546 device_param->kernel_params_mp_r_buf32[5] = 0;
15547 device_param->kernel_params_mp_r_buf32[6] = 0;
15548 device_param->kernel_params_mp_r_buf32[7] = 0;
15549 device_param->kernel_params_mp_r_buf32[8] = 0;
15550
15551 device_param->kernel_params_mp_r[0] = NULL;
15552 device_param->kernel_params_mp_r[1] = NULL;
15553 device_param->kernel_params_mp_r[2] = NULL;
15554 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15555 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15556 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15557 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15558 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15559 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15560
15561 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15562 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15563
15564 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15565 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15566 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15567 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15568 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15569 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15570 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15571
15572 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15573 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15574
15575 device_param->kernel_params_memset_buf32[1] = 0; // value
15576 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15577
15578 device_param->kernel_params_memset[0] = NULL;
15579 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15580 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15581
15582 /**
15583 * kernel name
15584 */
15585
15586 size_t kernel_wgs_tmp;
15587
15588 char kernel_name[64] = { 0 };
15589
15590 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15591 {
15592 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15593 {
15594 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15595
15596 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15597
15598 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15599
15600 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15601
15602 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15603
15604 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15605 }
15606 else
15607 {
15608 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15609
15610 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15611
15612 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15613
15614 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15615
15616 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15617
15618 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15619 }
15620
15621 if (data.attack_mode == ATTACK_MODE_BF)
15622 {
15623 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15624 {
15625 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15626
15627 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15628
15629 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);
15630 }
15631 }
15632 }
15633 else
15634 {
15635 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15636
15637 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15638
15639 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15640
15641 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15642
15643 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15644
15645 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15646
15647 if (opts_type & OPTS_TYPE_HOOK12)
15648 {
15649 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15650
15651 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15652
15653 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);
15654 }
15655
15656 if (opts_type & OPTS_TYPE_HOOK23)
15657 {
15658 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15659
15660 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15661
15662 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);
15663 }
15664 }
15665
15666 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);
15667 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);
15668 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);
15669
15670 for (uint i = 0; i <= 20; i++)
15671 {
15672 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15673 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15674 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15675
15676 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15677 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15678 }
15679
15680 for (uint i = 21; i <= 31; i++)
15681 {
15682 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15683 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15684 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15685
15686 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15687 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15688 }
15689
15690 // GPU memset
15691
15692 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15693
15694 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);
15695
15696 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15697 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15698 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15699
15700 // MP start
15701
15702 if (attack_mode == ATTACK_MODE_BF)
15703 {
15704 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15705 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15706
15707 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);
15708 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);
15709
15710 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15711 {
15712 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15713 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15714 }
15715 }
15716 else if (attack_mode == ATTACK_MODE_HYBRID1)
15717 {
15718 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15719
15720 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);
15721 }
15722 else if (attack_mode == ATTACK_MODE_HYBRID2)
15723 {
15724 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15725
15726 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);
15727 }
15728
15729 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15730 {
15731 // nothing to do
15732 }
15733 else
15734 {
15735 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15736
15737 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);
15738 }
15739
15740 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15741 {
15742 // nothing to do
15743 }
15744 else
15745 {
15746 for (uint i = 0; i < 5; i++)
15747 {
15748 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15749 }
15750
15751 for (uint i = 5; i < 7; i++)
15752 {
15753 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15754 }
15755 }
15756
15757 // maybe this has been updated by clGetKernelWorkGroupInfo()
15758 // value can only be decreased, so we don't need to reallocate buffers
15759
15760 device_param->kernel_threads = kernel_threads;
15761
15762 // zero some data buffers
15763
15764 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15765 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15766 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15767 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15768 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15769 run_kernel_bzero (device_param, device_param->d_result, size_results);
15770
15771 /**
15772 * special buffers
15773 */
15774
15775 if (attack_kern == ATTACK_KERN_STRAIGHT)
15776 {
15777 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15778 }
15779 else if (attack_kern == ATTACK_KERN_COMBI)
15780 {
15781 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15782 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15783 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15784 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15785 }
15786 else if (attack_kern == ATTACK_KERN_BF)
15787 {
15788 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15789 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15790 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15791 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15792 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15793 }
15794
15795 #if defined(HAVE_HWMON)
15796
15797 /**
15798 * Store initial fanspeed if gpu_temp_retain is enabled
15799 */
15800
15801 if (gpu_temp_disable == 0)
15802 {
15803 if (gpu_temp_retain != 0)
15804 {
15805 hc_thread_mutex_lock (mux_adl);
15806
15807 if (data.hm_device[device_id].fan_get_supported == 1)
15808 {
15809 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15810 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15811
15812 temp_retain_fanspeed_value[device_id] = fanspeed;
15813 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15814
15815 // we also set it to tell the OS we take control over the fan and it's automatic controller
15816 // if it was set to automatic. we do not control user-defined fanspeeds.
15817
15818 if (fanpolicy == 1)
15819 {
15820 data.hm_device[device_id].fan_set_supported = 1;
15821
15822 int rc = -1;
15823
15824 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15825 {
15826 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
15827 }
15828 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15829 {
15830
15831 }
15832
15833 if (rc == 0)
15834 {
15835 data.hm_device[device_id].fan_set_supported = 1;
15836 }
15837 else
15838 {
15839 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15840
15841 data.hm_device[device_id].fan_set_supported = 0;
15842 }
15843 }
15844 else
15845 {
15846 data.hm_device[device_id].fan_set_supported = 0;
15847 }
15848 }
15849
15850 hc_thread_mutex_unlock (mux_adl);
15851 }
15852 }
15853
15854 #endif // HAVE_HWMON
15855 }
15856
15857 if (data.quiet == 0) log_info_nn ("");
15858
15859 /**
15860 * In benchmark-mode, inform user which algorithm is checked
15861 */
15862
15863 if (benchmark == 1)
15864 {
15865 if (machine_readable == 0)
15866 {
15867 quiet = 0;
15868
15869 data.quiet = quiet;
15870
15871 char *hash_type = strhashtype (data.hash_mode); // not a bug
15872
15873 log_info ("Hashtype: %s", hash_type);
15874 log_info ("");
15875 }
15876 }
15877
15878 /**
15879 * keep track of the progress
15880 */
15881
15882 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15883 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15884 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15885
15886 /**
15887 * open filehandles
15888 */
15889
15890 #if _WIN
15891 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15892 {
15893 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15894
15895 return (-1);
15896 }
15897
15898 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15899 {
15900 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15901
15902 return (-1);
15903 }
15904
15905 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15906 {
15907 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15908
15909 return (-1);
15910 }
15911 #endif
15912
15913 /**
15914 * dictionary pad
15915 */
15916
15917 segment_size *= (1024 * 1024);
15918
15919 data.segment_size = segment_size;
15920
15921 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15922
15923 wl_data->buf = (char *) mymalloc (segment_size);
15924 wl_data->avail = segment_size;
15925 wl_data->incr = segment_size;
15926 wl_data->cnt = 0;
15927 wl_data->pos = 0;
15928
15929 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15930
15931 data.wordlist_mode = wordlist_mode;
15932
15933 cs_t *css_buf = NULL;
15934 uint css_cnt = 0;
15935 uint dictcnt = 0;
15936 uint maskcnt = 1;
15937 char **masks = NULL;
15938 char **dictfiles = NULL;
15939
15940 uint mask_from_file = 0;
15941
15942 if (attack_mode == ATTACK_MODE_STRAIGHT)
15943 {
15944 if (wordlist_mode == WL_MODE_FILE)
15945 {
15946 int wls_left = myargc - (optind + 1);
15947
15948 for (int i = 0; i < wls_left; i++)
15949 {
15950 char *l0_filename = myargv[optind + 1 + i];
15951
15952 struct stat l0_stat;
15953
15954 if (stat (l0_filename, &l0_stat) == -1)
15955 {
15956 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15957
15958 return (-1);
15959 }
15960
15961 uint is_dir = S_ISDIR (l0_stat.st_mode);
15962
15963 if (is_dir == 0)
15964 {
15965 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15966
15967 dictcnt++;
15968
15969 dictfiles[dictcnt - 1] = l0_filename;
15970 }
15971 else
15972 {
15973 // do not allow --keyspace w/ a directory
15974
15975 if (keyspace == 1)
15976 {
15977 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15978
15979 return (-1);
15980 }
15981
15982 char **dictionary_files = NULL;
15983
15984 dictionary_files = scan_directory (l0_filename);
15985
15986 if (dictionary_files != NULL)
15987 {
15988 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15989
15990 for (int d = 0; dictionary_files[d] != NULL; d++)
15991 {
15992 char *l1_filename = dictionary_files[d];
15993
15994 struct stat l1_stat;
15995
15996 if (stat (l1_filename, &l1_stat) == -1)
15997 {
15998 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15999
16000 return (-1);
16001 }
16002
16003 if (S_ISREG (l1_stat.st_mode))
16004 {
16005 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16006
16007 dictcnt++;
16008
16009 dictfiles[dictcnt - 1] = strdup (l1_filename);
16010 }
16011 }
16012 }
16013
16014 local_free (dictionary_files);
16015 }
16016 }
16017
16018 if (dictcnt < 1)
16019 {
16020 log_error ("ERROR: No usable dictionary file found.");
16021
16022 return (-1);
16023 }
16024 }
16025 else if (wordlist_mode == WL_MODE_STDIN)
16026 {
16027 dictcnt = 1;
16028 }
16029 }
16030 else if (attack_mode == ATTACK_MODE_COMBI)
16031 {
16032 // display
16033
16034 char *dictfile1 = myargv[optind + 1 + 0];
16035 char *dictfile2 = myargv[optind + 1 + 1];
16036
16037 // find the bigger dictionary and use as base
16038
16039 FILE *fp1 = NULL;
16040 FILE *fp2 = NULL;
16041
16042 struct stat tmp_stat;
16043
16044 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16045 {
16046 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16047
16048 return (-1);
16049 }
16050
16051 if (stat (dictfile1, &tmp_stat) == -1)
16052 {
16053 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16054
16055 fclose (fp1);
16056
16057 return (-1);
16058 }
16059
16060 if (S_ISDIR (tmp_stat.st_mode))
16061 {
16062 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16063
16064 fclose (fp1);
16065
16066 return (-1);
16067 }
16068
16069 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16070 {
16071 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16072
16073 fclose (fp1);
16074
16075 return (-1);
16076 }
16077
16078 if (stat (dictfile2, &tmp_stat) == -1)
16079 {
16080 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16081
16082 fclose (fp1);
16083 fclose (fp2);
16084
16085 return (-1);
16086 }
16087
16088 if (S_ISDIR (tmp_stat.st_mode))
16089 {
16090 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
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 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16103
16104 data.quiet = quiet;
16105
16106 if (words1_cnt == 0)
16107 {
16108 log_error ("ERROR: %s: empty file", dictfile1);
16109
16110 fclose (fp1);
16111 fclose (fp2);
16112
16113 return (-1);
16114 }
16115
16116 data.combs_cnt = 1;
16117
16118 data.quiet = 1;
16119
16120 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16121
16122 data.quiet = quiet;
16123
16124 if (words2_cnt == 0)
16125 {
16126 log_error ("ERROR: %s: empty file", dictfile2);
16127
16128 fclose (fp1);
16129 fclose (fp2);
16130
16131 return (-1);
16132 }
16133
16134 fclose (fp1);
16135 fclose (fp2);
16136
16137 data.dictfile = dictfile1;
16138 data.dictfile2 = dictfile2;
16139
16140 if (words1_cnt >= words2_cnt)
16141 {
16142 data.combs_cnt = words2_cnt;
16143 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16144
16145 dictfiles = &data.dictfile;
16146
16147 dictcnt = 1;
16148 }
16149 else
16150 {
16151 data.combs_cnt = words1_cnt;
16152 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16153
16154 dictfiles = &data.dictfile2;
16155
16156 dictcnt = 1;
16157
16158 // we also have to switch wordlist related rules!
16159
16160 char *tmpc = data.rule_buf_l;
16161
16162 data.rule_buf_l = data.rule_buf_r;
16163 data.rule_buf_r = tmpc;
16164
16165 int tmpi = data.rule_len_l;
16166
16167 data.rule_len_l = data.rule_len_r;
16168 data.rule_len_r = tmpi;
16169 }
16170 }
16171 else if (attack_mode == ATTACK_MODE_BF)
16172 {
16173 char *mask = NULL;
16174
16175 maskcnt = 0;
16176
16177 if (benchmark == 0)
16178 {
16179 mask = myargv[optind + 1];
16180
16181 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16182
16183 if ((optind + 2) <= myargc)
16184 {
16185 struct stat file_stat;
16186
16187 if (stat (mask, &file_stat) == -1)
16188 {
16189 maskcnt = 1;
16190
16191 masks[maskcnt - 1] = mystrdup (mask);
16192 }
16193 else
16194 {
16195 int wls_left = myargc - (optind + 1);
16196
16197 uint masks_avail = INCR_MASKS;
16198
16199 for (int i = 0; i < wls_left; i++)
16200 {
16201 if (i != 0)
16202 {
16203 mask = myargv[optind + 1 + i];
16204
16205 if (stat (mask, &file_stat) == -1)
16206 {
16207 log_error ("ERROR: %s: %s", mask, strerror (errno));
16208
16209 return (-1);
16210 }
16211 }
16212
16213 uint is_file = S_ISREG (file_stat.st_mode);
16214
16215 if (is_file == 1)
16216 {
16217 FILE *mask_fp;
16218
16219 if ((mask_fp = fopen (mask, "r")) == NULL)
16220 {
16221 log_error ("ERROR: %s: %s", mask, strerror (errno));
16222
16223 return (-1);
16224 }
16225
16226 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16227
16228 while (!feof (mask_fp))
16229 {
16230 memset (line_buf, 0, HCBUFSIZ);
16231
16232 int line_len = fgetl (mask_fp, line_buf);
16233
16234 if (line_len == 0) continue;
16235
16236 if (line_buf[0] == '#') continue;
16237
16238 if (masks_avail == maskcnt)
16239 {
16240 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16241
16242 masks_avail += INCR_MASKS;
16243 }
16244
16245 masks[maskcnt] = mystrdup (line_buf);
16246
16247 maskcnt++;
16248 }
16249
16250 myfree (line_buf);
16251
16252 fclose (mask_fp);
16253 }
16254 else
16255 {
16256 log_error ("ERROR: %s: unsupported file-type", mask);
16257
16258 return (-1);
16259 }
16260 }
16261
16262 mask_from_file = 1;
16263 }
16264 }
16265 else
16266 {
16267 custom_charset_1 = (char *) "?l?d?u";
16268 custom_charset_2 = (char *) "?l?d";
16269 custom_charset_3 = (char *) "?l?d*!$@_";
16270
16271 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16272 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16273 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16274
16275 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16276
16277 wordlist_mode = WL_MODE_MASK;
16278
16279 data.wordlist_mode = wordlist_mode;
16280
16281 increment = 1;
16282
16283 maskcnt = 1;
16284 }
16285 }
16286 else
16287 {
16288 /**
16289 * generate full masks and charsets
16290 */
16291
16292 masks = (char **) mymalloc (sizeof (char *));
16293
16294 switch (hash_mode)
16295 {
16296 case 1731: pw_min = 5;
16297 pw_max = 5;
16298 mask = mystrdup ("?b?b?b?b?b");
16299 break;
16300 case 12500: pw_min = 5;
16301 pw_max = 5;
16302 mask = mystrdup ("?b?b?b?b?b");
16303 break;
16304 default: pw_min = 7;
16305 pw_max = 7;
16306 mask = mystrdup ("?b?b?b?b?b?b?b");
16307 break;
16308 }
16309
16310 maskcnt = 1;
16311
16312 masks[maskcnt - 1] = mystrdup (mask);
16313
16314 wordlist_mode = WL_MODE_MASK;
16315
16316 data.wordlist_mode = wordlist_mode;
16317
16318 increment = 1;
16319 }
16320
16321 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16322
16323 if (increment)
16324 {
16325 if (increment_min > pw_min) pw_min = increment_min;
16326
16327 if (increment_max < pw_max) pw_max = increment_max;
16328 }
16329 }
16330 else if (attack_mode == ATTACK_MODE_HYBRID1)
16331 {
16332 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16333
16334 // display
16335
16336 char *mask = myargv[myargc - 1];
16337
16338 maskcnt = 0;
16339
16340 masks = (char **) mymalloc (1 * sizeof (char *));
16341
16342 // mod
16343
16344 struct stat file_stat;
16345
16346 if (stat (mask, &file_stat) == -1)
16347 {
16348 maskcnt = 1;
16349
16350 masks[maskcnt - 1] = mystrdup (mask);
16351 }
16352 else
16353 {
16354 uint is_file = S_ISREG (file_stat.st_mode);
16355
16356 if (is_file == 1)
16357 {
16358 FILE *mask_fp;
16359
16360 if ((mask_fp = fopen (mask, "r")) == NULL)
16361 {
16362 log_error ("ERROR: %s: %s", mask, strerror (errno));
16363
16364 return (-1);
16365 }
16366
16367 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16368
16369 uint masks_avail = 1;
16370
16371 while (!feof (mask_fp))
16372 {
16373 memset (line_buf, 0, HCBUFSIZ);
16374
16375 int line_len = fgetl (mask_fp, line_buf);
16376
16377 if (line_len == 0) continue;
16378
16379 if (line_buf[0] == '#') continue;
16380
16381 if (masks_avail == maskcnt)
16382 {
16383 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16384
16385 masks_avail += INCR_MASKS;
16386 }
16387
16388 masks[maskcnt] = mystrdup (line_buf);
16389
16390 maskcnt++;
16391 }
16392
16393 myfree (line_buf);
16394
16395 fclose (mask_fp);
16396
16397 mask_from_file = 1;
16398 }
16399 else
16400 {
16401 maskcnt = 1;
16402
16403 masks[maskcnt - 1] = mystrdup (mask);
16404 }
16405 }
16406
16407 // base
16408
16409 int wls_left = myargc - (optind + 2);
16410
16411 for (int i = 0; i < wls_left; i++)
16412 {
16413 char *filename = myargv[optind + 1 + i];
16414
16415 struct stat file_stat;
16416
16417 if (stat (filename, &file_stat) == -1)
16418 {
16419 log_error ("ERROR: %s: %s", filename, strerror (errno));
16420
16421 return (-1);
16422 }
16423
16424 uint is_dir = S_ISDIR (file_stat.st_mode);
16425
16426 if (is_dir == 0)
16427 {
16428 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16429
16430 dictcnt++;
16431
16432 dictfiles[dictcnt - 1] = filename;
16433 }
16434 else
16435 {
16436 // do not allow --keyspace w/ a directory
16437
16438 if (keyspace == 1)
16439 {
16440 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16441
16442 return (-1);
16443 }
16444
16445 char **dictionary_files = NULL;
16446
16447 dictionary_files = scan_directory (filename);
16448
16449 if (dictionary_files != NULL)
16450 {
16451 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16452
16453 for (int d = 0; dictionary_files[d] != NULL; d++)
16454 {
16455 char *l1_filename = dictionary_files[d];
16456
16457 struct stat l1_stat;
16458
16459 if (stat (l1_filename, &l1_stat) == -1)
16460 {
16461 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16462
16463 return (-1);
16464 }
16465
16466 if (S_ISREG (l1_stat.st_mode))
16467 {
16468 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16469
16470 dictcnt++;
16471
16472 dictfiles[dictcnt - 1] = strdup (l1_filename);
16473 }
16474 }
16475 }
16476
16477 local_free (dictionary_files);
16478 }
16479 }
16480
16481 if (dictcnt < 1)
16482 {
16483 log_error ("ERROR: No usable dictionary file found.");
16484
16485 return (-1);
16486 }
16487
16488 if (increment)
16489 {
16490 maskcnt = 0;
16491
16492 uint mask_min = increment_min; // we can't reject smaller masks here
16493 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16494
16495 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16496 {
16497 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16498
16499 if (cur_mask == NULL) break;
16500
16501 masks[maskcnt] = cur_mask;
16502
16503 maskcnt++;
16504
16505 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16506 }
16507 }
16508 }
16509 else if (attack_mode == ATTACK_MODE_HYBRID2)
16510 {
16511 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16512
16513 // display
16514
16515 char *mask = myargv[optind + 1 + 0];
16516
16517 maskcnt = 0;
16518
16519 masks = (char **) mymalloc (1 * sizeof (char *));
16520
16521 // mod
16522
16523 struct stat file_stat;
16524
16525 if (stat (mask, &file_stat) == -1)
16526 {
16527 maskcnt = 1;
16528
16529 masks[maskcnt - 1] = mystrdup (mask);
16530 }
16531 else
16532 {
16533 uint is_file = S_ISREG (file_stat.st_mode);
16534
16535 if (is_file == 1)
16536 {
16537 FILE *mask_fp;
16538
16539 if ((mask_fp = fopen (mask, "r")) == NULL)
16540 {
16541 log_error ("ERROR: %s: %s", mask, strerror (errno));
16542
16543 return (-1);
16544 }
16545
16546 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16547
16548 uint masks_avail = 1;
16549
16550 while (!feof (mask_fp))
16551 {
16552 memset (line_buf, 0, HCBUFSIZ);
16553
16554 int line_len = fgetl (mask_fp, line_buf);
16555
16556 if (line_len == 0) continue;
16557
16558 if (line_buf[0] == '#') continue;
16559
16560 if (masks_avail == maskcnt)
16561 {
16562 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16563
16564 masks_avail += INCR_MASKS;
16565 }
16566
16567 masks[maskcnt] = mystrdup (line_buf);
16568
16569 maskcnt++;
16570 }
16571
16572 myfree (line_buf);
16573
16574 fclose (mask_fp);
16575
16576 mask_from_file = 1;
16577 }
16578 else
16579 {
16580 maskcnt = 1;
16581
16582 masks[maskcnt - 1] = mystrdup (mask);
16583 }
16584 }
16585
16586 // base
16587
16588 int wls_left = myargc - (optind + 2);
16589
16590 for (int i = 0; i < wls_left; i++)
16591 {
16592 char *filename = myargv[optind + 2 + i];
16593
16594 struct stat file_stat;
16595
16596 if (stat (filename, &file_stat) == -1)
16597 {
16598 log_error ("ERROR: %s: %s", filename, strerror (errno));
16599
16600 return (-1);
16601 }
16602
16603 uint is_dir = S_ISDIR (file_stat.st_mode);
16604
16605 if (is_dir == 0)
16606 {
16607 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16608
16609 dictcnt++;
16610
16611 dictfiles[dictcnt - 1] = filename;
16612 }
16613 else
16614 {
16615 // do not allow --keyspace w/ a directory
16616
16617 if (keyspace == 1)
16618 {
16619 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16620
16621 return (-1);
16622 }
16623
16624 char **dictionary_files = NULL;
16625
16626 dictionary_files = scan_directory (filename);
16627
16628 if (dictionary_files != NULL)
16629 {
16630 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16631
16632 for (int d = 0; dictionary_files[d] != NULL; d++)
16633 {
16634 char *l1_filename = dictionary_files[d];
16635
16636 struct stat l1_stat;
16637
16638 if (stat (l1_filename, &l1_stat) == -1)
16639 {
16640 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16641
16642 return (-1);
16643 }
16644
16645 if (S_ISREG (l1_stat.st_mode))
16646 {
16647 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16648
16649 dictcnt++;
16650
16651 dictfiles[dictcnt - 1] = strdup (l1_filename);
16652 }
16653 }
16654 }
16655
16656 local_free (dictionary_files);
16657 }
16658 }
16659
16660 if (dictcnt < 1)
16661 {
16662 log_error ("ERROR: No usable dictionary file found.");
16663
16664 return (-1);
16665 }
16666
16667 if (increment)
16668 {
16669 maskcnt = 0;
16670
16671 uint mask_min = increment_min; // we can't reject smaller masks here
16672 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16673
16674 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16675 {
16676 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16677
16678 if (cur_mask == NULL) break;
16679
16680 masks[maskcnt] = cur_mask;
16681
16682 maskcnt++;
16683
16684 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16685 }
16686 }
16687 }
16688
16689 data.pw_min = pw_min;
16690 data.pw_max = pw_max;
16691
16692 /**
16693 * weak hash check
16694 */
16695
16696 if (weak_hash_threshold >= salts_cnt)
16697 {
16698 hc_device_param_t *device_param = NULL;
16699
16700 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16701 {
16702 device_param = &data.devices_param[device_id];
16703
16704 if (device_param->skipped) continue;
16705
16706 break;
16707 }
16708
16709 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16710
16711 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16712 {
16713 weak_hash_check (device_param, salt_pos);
16714 }
16715
16716 // Display hack, guarantee that there is at least one \r before real start
16717
16718 //if (data.quiet == 0) log_info ("");
16719 }
16720
16721 /**
16722 * status and monitor threads
16723 */
16724
16725 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16726
16727 hc_thread_t i_thread = 0;
16728
16729 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16730 {
16731 hc_thread_create (i_thread, thread_keypress, &benchmark);
16732 }
16733
16734 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16735
16736 uint ni_threads_cnt = 0;
16737
16738 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16739
16740 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16741
16742 ni_threads_cnt++;
16743
16744 /**
16745 * Outfile remove
16746 */
16747
16748 if (keyspace == 0)
16749 {
16750 if (outfile_check_timer != 0)
16751 {
16752 if (data.outfile_check_directory != NULL)
16753 {
16754 if ((hash_mode != 5200) &&
16755 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16756 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16757 (hash_mode != 9000))
16758 {
16759 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16760
16761 ni_threads_cnt++;
16762 }
16763 else
16764 {
16765 outfile_check_timer = 0;
16766 }
16767 }
16768 else
16769 {
16770 outfile_check_timer = 0;
16771 }
16772 }
16773 }
16774
16775 /**
16776 * Inform the user if we got some hashes remove because of the pot file remove feature
16777 */
16778
16779 if (data.quiet == 0)
16780 {
16781 if (potfile_remove_cracks > 0)
16782 {
16783 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16784 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16785 }
16786 }
16787
16788 data.outfile_check_timer = outfile_check_timer;
16789
16790 /**
16791 * main loop
16792 */
16793
16794 char **induction_dictionaries = NULL;
16795
16796 int induction_dictionaries_cnt = 0;
16797
16798 hcstat_table_t *root_table_buf = NULL;
16799 hcstat_table_t *markov_table_buf = NULL;
16800
16801 uint initial_restore_done = 0;
16802
16803 data.maskcnt = maskcnt;
16804
16805 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16806 {
16807 if (data.devices_status == STATUS_CRACKED) break;
16808
16809 data.devices_status = STATUS_INIT;
16810
16811 if (maskpos > rd->maskpos)
16812 {
16813 rd->dictpos = 0;
16814 }
16815
16816 rd->maskpos = maskpos;
16817 data.maskpos = maskpos;
16818
16819 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16820 {
16821 char *mask = masks[maskpos];
16822
16823 if (mask_from_file == 1)
16824 {
16825 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16826
16827 char *str_ptr;
16828 uint str_pos;
16829
16830 uint mask_offset = 0;
16831
16832 uint separator_cnt;
16833
16834 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16835 {
16836 str_ptr = strstr (mask + mask_offset, ",");
16837
16838 if (str_ptr == NULL) break;
16839
16840 str_pos = str_ptr - mask;
16841
16842 // escaped separator, i.e. "\,"
16843
16844 if (str_pos > 0)
16845 {
16846 if (mask[str_pos - 1] == '\\')
16847 {
16848 separator_cnt --;
16849
16850 mask_offset = str_pos + 1;
16851
16852 continue;
16853 }
16854 }
16855
16856 // reset the offset
16857
16858 mask_offset = 0;
16859
16860 mask[str_pos] = '\0';
16861
16862 switch (separator_cnt)
16863 {
16864 case 0:
16865 mp_reset_usr (mp_usr, 0);
16866
16867 custom_charset_1 = mask;
16868 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16869 break;
16870
16871 case 1:
16872 mp_reset_usr (mp_usr, 1);
16873
16874 custom_charset_2 = mask;
16875 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16876 break;
16877
16878 case 2:
16879 mp_reset_usr (mp_usr, 2);
16880
16881 custom_charset_3 = mask;
16882 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16883 break;
16884
16885 case 3:
16886 mp_reset_usr (mp_usr, 3);
16887
16888 custom_charset_4 = mask;
16889 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16890 break;
16891 }
16892
16893 mask = mask + str_pos + 1;
16894 }
16895 }
16896
16897 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16898 {
16899 if (maskpos > 0)
16900 {
16901 local_free (css_buf);
16902 local_free (data.root_css_buf);
16903 local_free (data.markov_css_buf);
16904
16905 local_free (masks[maskpos - 1]);
16906 }
16907
16908 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16909
16910 data.mask = mask;
16911 data.css_cnt = css_cnt;
16912 data.css_buf = css_buf;
16913
16914 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16915
16916 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16917
16918 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16919 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16920
16921 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16922
16923 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16924
16925 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16926 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16927
16928 data.root_css_buf = root_css_buf;
16929 data.markov_css_buf = markov_css_buf;
16930
16931 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16932
16933 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16934
16935 local_free (root_table_buf);
16936 local_free (markov_table_buf);
16937
16938 // args
16939
16940 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16941 {
16942 hc_device_param_t *device_param = &data.devices_param[device_id];
16943
16944 if (device_param->skipped) continue;
16945
16946 device_param->kernel_params_mp[0] = &device_param->d_combs;
16947 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16948 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16949
16950 device_param->kernel_params_mp_buf64[3] = 0;
16951 device_param->kernel_params_mp_buf32[4] = css_cnt;
16952 device_param->kernel_params_mp_buf32[5] = 0;
16953 device_param->kernel_params_mp_buf32[6] = 0;
16954 device_param->kernel_params_mp_buf32[7] = 0;
16955
16956 if (attack_mode == ATTACK_MODE_HYBRID1)
16957 {
16958 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16959 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16960 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16961 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16962 }
16963 else if (attack_mode == ATTACK_MODE_HYBRID2)
16964 {
16965 device_param->kernel_params_mp_buf32[5] = 0;
16966 device_param->kernel_params_mp_buf32[6] = 0;
16967 device_param->kernel_params_mp_buf32[7] = 0;
16968 }
16969
16970 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]);
16971 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]);
16972 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]);
16973
16974 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);
16975 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);
16976 }
16977 }
16978 else if (attack_mode == ATTACK_MODE_BF)
16979 {
16980 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16981
16982 if (increment)
16983 {
16984 for (uint i = 0; i < dictcnt; i++)
16985 {
16986 local_free (dictfiles[i]);
16987 }
16988
16989 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16990 {
16991 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16992
16993 if (l1_filename == NULL) break;
16994
16995 dictcnt++;
16996
16997 dictfiles[dictcnt - 1] = l1_filename;
16998 }
16999 }
17000 else
17001 {
17002 dictcnt++;
17003
17004 dictfiles[dictcnt - 1] = mask;
17005 }
17006
17007 if (dictcnt == 0)
17008 {
17009 log_error ("ERROR: Mask is too small");
17010
17011 return (-1);
17012 }
17013 }
17014 }
17015
17016 free (induction_dictionaries);
17017
17018 // induction_dictionaries_cnt = 0; // implied
17019
17020 if (attack_mode != ATTACK_MODE_BF)
17021 {
17022 if (keyspace == 0)
17023 {
17024 induction_dictionaries = scan_directory (induction_directory);
17025
17026 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17027 }
17028 }
17029
17030 if (induction_dictionaries_cnt)
17031 {
17032 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17033 }
17034
17035 /**
17036 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17037 */
17038 if (keyspace == 1)
17039 {
17040 if ((maskcnt > 1) || (dictcnt > 1))
17041 {
17042 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17043
17044 return (-1);
17045 }
17046 }
17047
17048 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17049 {
17050 char *subid = logfile_generate_subid ();
17051
17052 data.subid = subid;
17053
17054 logfile_sub_msg ("START");
17055
17056 data.devices_status = STATUS_INIT;
17057
17058 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17059 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17060 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17061
17062 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17063
17064 data.cpt_pos = 0;
17065
17066 data.cpt_start = time (NULL);
17067
17068 data.cpt_total = 0;
17069
17070 if (data.restore == 0)
17071 {
17072 rd->words_cur = skip;
17073
17074 skip = 0;
17075
17076 data.skip = 0;
17077 }
17078
17079 data.ms_paused = 0;
17080
17081 data.kernel_power_final = 0;
17082
17083 data.words_cur = rd->words_cur;
17084
17085 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17086 {
17087 hc_device_param_t *device_param = &data.devices_param[device_id];
17088
17089 if (device_param->skipped) continue;
17090
17091 device_param->speed_pos = 0;
17092
17093 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17094 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17095
17096 device_param->exec_pos = 0;
17097
17098 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17099
17100 device_param->outerloop_pos = 0;
17101 device_param->outerloop_left = 0;
17102 device_param->innerloop_pos = 0;
17103 device_param->innerloop_left = 0;
17104
17105 // some more resets:
17106
17107 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17108
17109 device_param->pws_cnt = 0;
17110
17111 device_param->words_off = 0;
17112 device_param->words_done = 0;
17113 }
17114
17115 // figure out some workload
17116
17117 if (attack_mode == ATTACK_MODE_STRAIGHT)
17118 {
17119 if (data.wordlist_mode == WL_MODE_FILE)
17120 {
17121 char *dictfile = NULL;
17122
17123 if (induction_dictionaries_cnt)
17124 {
17125 dictfile = induction_dictionaries[0];
17126 }
17127 else
17128 {
17129 dictfile = dictfiles[dictpos];
17130 }
17131
17132 data.dictfile = dictfile;
17133
17134 logfile_sub_string (dictfile);
17135
17136 for (uint i = 0; i < rp_files_cnt; i++)
17137 {
17138 logfile_sub_var_string ("rulefile", rp_files[i]);
17139 }
17140
17141 FILE *fd2 = fopen (dictfile, "rb");
17142
17143 if (fd2 == NULL)
17144 {
17145 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17146
17147 return (-1);
17148 }
17149
17150 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17151
17152 fclose (fd2);
17153
17154 if (data.words_cnt == 0)
17155 {
17156 if (data.devices_status == STATUS_CRACKED) break;
17157 if (data.devices_status == STATUS_ABORTED) break;
17158
17159 dictpos++;
17160
17161 continue;
17162 }
17163 }
17164 }
17165 else if (attack_mode == ATTACK_MODE_COMBI)
17166 {
17167 char *dictfile = data.dictfile;
17168 char *dictfile2 = data.dictfile2;
17169
17170 logfile_sub_string (dictfile);
17171 logfile_sub_string (dictfile2);
17172
17173 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17174 {
17175 FILE *fd2 = fopen (dictfile, "rb");
17176
17177 if (fd2 == NULL)
17178 {
17179 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17180
17181 return (-1);
17182 }
17183
17184 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17185
17186 fclose (fd2);
17187 }
17188 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17189 {
17190 FILE *fd2 = fopen (dictfile2, "rb");
17191
17192 if (fd2 == NULL)
17193 {
17194 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17195
17196 return (-1);
17197 }
17198
17199 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17200
17201 fclose (fd2);
17202 }
17203
17204 if (data.words_cnt == 0)
17205 {
17206 if (data.devices_status == STATUS_CRACKED) break;
17207 if (data.devices_status == STATUS_ABORTED) break;
17208
17209 dictpos++;
17210
17211 continue;
17212 }
17213 }
17214 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17215 {
17216 char *dictfile = NULL;
17217
17218 if (induction_dictionaries_cnt)
17219 {
17220 dictfile = induction_dictionaries[0];
17221 }
17222 else
17223 {
17224 dictfile = dictfiles[dictpos];
17225 }
17226
17227 data.dictfile = dictfile;
17228
17229 char *mask = data.mask;
17230
17231 logfile_sub_string (dictfile);
17232 logfile_sub_string (mask);
17233
17234 FILE *fd2 = fopen (dictfile, "rb");
17235
17236 if (fd2 == NULL)
17237 {
17238 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17239
17240 return (-1);
17241 }
17242
17243 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17244
17245 fclose (fd2);
17246
17247 if (data.words_cnt == 0)
17248 {
17249 if (data.devices_status == STATUS_CRACKED) break;
17250 if (data.devices_status == STATUS_ABORTED) break;
17251
17252 dictpos++;
17253
17254 continue;
17255 }
17256 }
17257 else if (attack_mode == ATTACK_MODE_BF)
17258 {
17259 local_free (css_buf);
17260 local_free (data.root_css_buf);
17261 local_free (data.markov_css_buf);
17262
17263 char *mask = dictfiles[dictpos];
17264
17265 logfile_sub_string (mask);
17266
17267 // base
17268
17269 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17270
17271 if (opts_type & OPTS_TYPE_PT_UNICODE)
17272 {
17273 uint css_cnt_unicode = css_cnt * 2;
17274
17275 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17276
17277 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17278 {
17279 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17280
17281 css_buf_unicode[j + 1].cs_buf[0] = 0;
17282 css_buf_unicode[j + 1].cs_len = 1;
17283 }
17284
17285 free (css_buf);
17286
17287 css_buf = css_buf_unicode;
17288 css_cnt = css_cnt_unicode;
17289 }
17290
17291 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17292
17293 uint mask_min = pw_min;
17294 uint mask_max = pw_max;
17295
17296 if (opts_type & OPTS_TYPE_PT_UNICODE)
17297 {
17298 mask_min *= 2;
17299 mask_max *= 2;
17300 }
17301
17302 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17303 {
17304 if (css_cnt < mask_min)
17305 {
17306 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17307 }
17308
17309 if (css_cnt > mask_max)
17310 {
17311 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17312 }
17313
17314 // skip to next mask
17315
17316 dictpos++;
17317
17318 rd->dictpos = dictpos;
17319
17320 logfile_sub_msg ("STOP");
17321
17322 continue;
17323 }
17324
17325 uint save_css_cnt = css_cnt;
17326
17327 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17328 {
17329 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17330 {
17331 uint salt_len = (uint) data.salts_buf[0].salt_len;
17332 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17333
17334 uint css_cnt_salt = css_cnt + salt_len;
17335
17336 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17337
17338 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17339
17340 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17341 {
17342 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17343 css_buf_salt[j].cs_len = 1;
17344 }
17345
17346 free (css_buf);
17347
17348 css_buf = css_buf_salt;
17349 css_cnt = css_cnt_salt;
17350 }
17351 }
17352
17353 data.mask = mask;
17354 data.css_cnt = css_cnt;
17355 data.css_buf = css_buf;
17356
17357 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17358
17359 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17360
17361 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17362
17363 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17364 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17365
17366 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17367
17368 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17369
17370 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17371 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17372
17373 data.root_css_buf = root_css_buf;
17374 data.markov_css_buf = markov_css_buf;
17375
17376 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17377
17378 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17379
17380 local_free (root_table_buf);
17381 local_free (markov_table_buf);
17382
17383 // copy + args
17384
17385 uint css_cnt_l = css_cnt;
17386 uint css_cnt_r;
17387
17388 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17389 {
17390 if (save_css_cnt < 6)
17391 {
17392 css_cnt_r = 1;
17393 }
17394 else if (save_css_cnt == 6)
17395 {
17396 css_cnt_r = 2;
17397 }
17398 else
17399 {
17400 if (opts_type & OPTS_TYPE_PT_UNICODE)
17401 {
17402 if (save_css_cnt == 8 || save_css_cnt == 10)
17403 {
17404 css_cnt_r = 2;
17405 }
17406 else
17407 {
17408 css_cnt_r = 4;
17409 }
17410 }
17411 else
17412 {
17413 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17414 {
17415 css_cnt_r = 3;
17416 }
17417 else
17418 {
17419 css_cnt_r = 4;
17420 }
17421 }
17422 }
17423 }
17424 else
17425 {
17426 css_cnt_r = 1;
17427
17428 /* unfinished code?
17429 int sum = css_buf[css_cnt_r - 1].cs_len;
17430
17431 for (uint i = 1; i < 4 && i < css_cnt; i++)
17432 {
17433 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17434
17435 css_cnt_r++;
17436
17437 sum *= css_buf[css_cnt_r - 1].cs_len;
17438 }
17439 */
17440 }
17441
17442 css_cnt_l -= css_cnt_r;
17443
17444 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17445
17446 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17447 {
17448 hc_device_param_t *device_param = &data.devices_param[device_id];
17449
17450 if (device_param->skipped) continue;
17451
17452 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17453 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17454 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17455
17456 device_param->kernel_params_mp_l_buf64[3] = 0;
17457 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17458 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17459 device_param->kernel_params_mp_l_buf32[6] = 0;
17460 device_param->kernel_params_mp_l_buf32[7] = 0;
17461 device_param->kernel_params_mp_l_buf32[8] = 0;
17462
17463 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17464 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17465 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17466 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17467
17468 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17469 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17470 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17471
17472 device_param->kernel_params_mp_r_buf64[3] = 0;
17473 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17474 device_param->kernel_params_mp_r_buf32[5] = 0;
17475 device_param->kernel_params_mp_r_buf32[6] = 0;
17476 device_param->kernel_params_mp_r_buf32[7] = 0;
17477
17478 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]);
17479 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]);
17480 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]);
17481
17482 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]);
17483 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]);
17484 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]);
17485
17486 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);
17487 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);
17488 }
17489 }
17490
17491 u64 words_base = data.words_cnt;
17492
17493 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17494 {
17495 if (data.kernel_rules_cnt)
17496 {
17497 words_base /= data.kernel_rules_cnt;
17498 }
17499 }
17500 else if (data.attack_kern == ATTACK_KERN_COMBI)
17501 {
17502 if (data.combs_cnt)
17503 {
17504 words_base /= data.combs_cnt;
17505 }
17506 }
17507 else if (data.attack_kern == ATTACK_KERN_BF)
17508 {
17509 if (data.bfs_cnt)
17510 {
17511 words_base /= data.bfs_cnt;
17512 }
17513 }
17514
17515 data.words_base = words_base;
17516
17517 if (keyspace == 1)
17518 {
17519 log_info ("%llu", (unsigned long long int) words_base);
17520
17521 return (0);
17522 }
17523
17524 if (data.words_cur > data.words_base)
17525 {
17526 log_error ("ERROR: restore value greater keyspace");
17527
17528 return (-1);
17529 }
17530
17531 if (data.words_cur)
17532 {
17533 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17534 {
17535 for (uint i = 0; i < data.salts_cnt; i++)
17536 {
17537 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17538 }
17539 }
17540 else if (data.attack_kern == ATTACK_KERN_COMBI)
17541 {
17542 for (uint i = 0; i < data.salts_cnt; i++)
17543 {
17544 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17545 }
17546 }
17547 else if (data.attack_kern == ATTACK_KERN_BF)
17548 {
17549 for (uint i = 0; i < data.salts_cnt; i++)
17550 {
17551 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17552 }
17553 }
17554 }
17555
17556 /*
17557 * Update loopback file
17558 */
17559
17560 if (loopback == 1)
17561 {
17562 time_t now;
17563
17564 time (&now);
17565
17566 uint random_num = get_random_num (0, 9999);
17567
17568 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17569
17570 data.loopback_file = loopback_file;
17571 }
17572
17573 /*
17574 * Update dictionary statistic
17575 */
17576
17577 if (keyspace == 0)
17578 {
17579 dictstat_fp = fopen (dictstat, "wb");
17580
17581 if (dictstat_fp)
17582 {
17583 lock_file (dictstat_fp);
17584
17585 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17586
17587 fclose (dictstat_fp);
17588 }
17589 }
17590
17591 /**
17592 * create autotune threads
17593 */
17594
17595 data.devices_status = STATUS_AUTOTUNE;
17596
17597 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17598
17599 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17600 {
17601 hc_device_param_t *device_param = &devices_param[device_id];
17602
17603 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17604 }
17605
17606 hc_thread_wait (data.devices_cnt, c_threads);
17607
17608 /*
17609 * Inform user about possible slow speeds
17610 */
17611
17612 uint hardware_power_all = 0;
17613
17614 uint kernel_power_all = 0;
17615
17616 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17617 {
17618 hc_device_param_t *device_param = &devices_param[device_id];
17619
17620 hardware_power_all += device_param->hardware_power;
17621
17622 kernel_power_all += device_param->kernel_power;
17623 }
17624
17625 data.hardware_power_all = hardware_power_all; // hardware_power_all is the same as kernel_power_all but without the influence of kernel_accel on the devices
17626
17627 data.kernel_power_all = kernel_power_all;
17628
17629 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17630 {
17631 if (data.words_base < kernel_power_all)
17632 {
17633 if (quiet == 0)
17634 {
17635 log_info ("ATTENTION!");
17636 log_info (" The wordlist or mask you are using is too small.");
17637 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17638 log_info (" The cracking speed will drop.");
17639 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17640 log_info ("");
17641 }
17642 }
17643 }
17644
17645 /**
17646 * create cracker threads
17647 */
17648
17649 data.devices_status = STATUS_RUNNING;
17650
17651 if (initial_restore_done == 0)
17652 {
17653 if (data.restore_disable == 0) cycle_restore ();
17654
17655 initial_restore_done = 1;
17656 }
17657
17658 hc_timer_set (&data.timer_running);
17659
17660 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17661 {
17662 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17663 {
17664 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17665 if (quiet == 0) fflush (stdout);
17666 }
17667 }
17668 else if (wordlist_mode == WL_MODE_STDIN)
17669 {
17670 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17671 if (data.quiet == 0) log_info ("");
17672 }
17673
17674 time_t runtime_start;
17675
17676 time (&runtime_start);
17677
17678 data.runtime_start = runtime_start;
17679
17680 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17681 {
17682 hc_device_param_t *device_param = &devices_param[device_id];
17683
17684 if (wordlist_mode == WL_MODE_STDIN)
17685 {
17686 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17687 }
17688 else
17689 {
17690 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17691 }
17692 }
17693
17694 hc_thread_wait (data.devices_cnt, c_threads);
17695
17696 local_free (c_threads);
17697
17698 data.restore = 0;
17699
17700 // finalize task
17701
17702 logfile_sub_var_uint ("status-after-work", data.devices_status);
17703
17704 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17705
17706 if (data.devices_status == STATUS_CRACKED) break;
17707 if (data.devices_status == STATUS_ABORTED) break;
17708
17709 if (data.devices_status == STATUS_BYPASS)
17710 {
17711 data.devices_status = STATUS_RUNNING;
17712 }
17713
17714 if (induction_dictionaries_cnt)
17715 {
17716 unlink (induction_dictionaries[0]);
17717 }
17718
17719 free (induction_dictionaries);
17720
17721 if (attack_mode != ATTACK_MODE_BF)
17722 {
17723 induction_dictionaries = scan_directory (induction_directory);
17724
17725 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17726 }
17727
17728 if (benchmark == 0)
17729 {
17730 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17731 {
17732 if (quiet == 0) clear_prompt ();
17733
17734 if (quiet == 0) log_info ("");
17735
17736 if (status == 1)
17737 {
17738 status_display ();
17739 }
17740 else
17741 {
17742 if (quiet == 0) status_display ();
17743 }
17744
17745 if (quiet == 0) log_info ("");
17746 }
17747 }
17748
17749 if (attack_mode == ATTACK_MODE_BF)
17750 {
17751 dictpos++;
17752
17753 rd->dictpos = dictpos;
17754 }
17755 else
17756 {
17757 if (induction_dictionaries_cnt)
17758 {
17759 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17760 }
17761 else
17762 {
17763 dictpos++;
17764
17765 rd->dictpos = dictpos;
17766 }
17767 }
17768
17769 time_t runtime_stop;
17770
17771 time (&runtime_stop);
17772
17773 data.runtime_stop = runtime_stop;
17774
17775 logfile_sub_uint (runtime_start);
17776 logfile_sub_uint (runtime_stop);
17777
17778 logfile_sub_msg ("STOP");
17779
17780 global_free (subid);
17781 }
17782
17783 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17784
17785 if (data.devices_status == STATUS_CRACKED) break;
17786 if (data.devices_status == STATUS_ABORTED) break;
17787 if (data.devices_status == STATUS_QUIT) break;
17788
17789 if (data.devices_status == STATUS_BYPASS)
17790 {
17791 data.devices_status = STATUS_RUNNING;
17792 }
17793 }
17794
17795 // 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
17796
17797 if (attack_mode == ATTACK_MODE_STRAIGHT)
17798 {
17799 if (data.wordlist_mode == WL_MODE_FILE)
17800 {
17801 if (data.dictfile == NULL)
17802 {
17803 if (dictfiles != NULL)
17804 {
17805 data.dictfile = dictfiles[0];
17806
17807 hc_timer_set (&data.timer_running);
17808 }
17809 }
17810 }
17811 }
17812 // NOTE: combi is okay because it is already set beforehand
17813 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17814 {
17815 if (data.dictfile == NULL)
17816 {
17817 if (dictfiles != NULL)
17818 {
17819 hc_timer_set (&data.timer_running);
17820
17821 data.dictfile = dictfiles[0];
17822 }
17823 }
17824 }
17825 else if (attack_mode == ATTACK_MODE_BF)
17826 {
17827 if (data.mask == NULL)
17828 {
17829 hc_timer_set (&data.timer_running);
17830
17831 data.mask = masks[0];
17832 }
17833 }
17834
17835 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17836 {
17837 data.devices_status = STATUS_EXHAUSTED;
17838 }
17839
17840 // if cracked / aborted remove last induction dictionary
17841
17842 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17843 {
17844 struct stat induct_stat;
17845
17846 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17847 {
17848 unlink (induction_dictionaries[file_pos]);
17849 }
17850 }
17851
17852 // wait for non-interactive threads
17853
17854 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17855 {
17856 hc_thread_wait (1, &ni_threads[thread_idx]);
17857 }
17858
17859 local_free (ni_threads);
17860
17861 // wait for interactive threads
17862
17863 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17864 {
17865 hc_thread_wait (1, &i_thread);
17866 }
17867
17868 // we dont need restore file anymore
17869 if (data.restore_disable == 0)
17870 {
17871 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17872 {
17873 unlink (eff_restore_file);
17874 unlink (new_restore_file);
17875 }
17876 else
17877 {
17878 cycle_restore ();
17879 }
17880 }
17881
17882 // finally save left hashes
17883
17884 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17885 {
17886 save_hash ();
17887 }
17888
17889 /**
17890 * Clean up
17891 */
17892
17893 if (benchmark == 1)
17894 {
17895 status_benchmark ();
17896
17897 if (machine_readable == 0)
17898 {
17899 log_info ("");
17900 }
17901 }
17902 else
17903 {
17904 if (quiet == 0) clear_prompt ();
17905
17906 if (quiet == 0) log_info ("");
17907
17908 if (status == 1)
17909 {
17910 status_display ();
17911 }
17912 else
17913 {
17914 if (quiet == 0) status_display ();
17915 }
17916
17917 if (quiet == 0) log_info ("");
17918 }
17919
17920 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17921 {
17922 hc_device_param_t *device_param = &data.devices_param[device_id];
17923
17924 if (device_param->skipped) continue;
17925
17926 local_free (device_param->combs_buf);
17927
17928 local_free (device_param->hooks_buf);
17929
17930 local_free (device_param->device_name);
17931
17932 local_free (device_param->device_name_chksum);
17933
17934 local_free (device_param->device_version);
17935
17936 local_free (device_param->driver_version);
17937
17938 if (device_param->pws_buf) myfree (device_param->pws_buf);
17939 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17940 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17941 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17942 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17943 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17944 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17945 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17946 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17947 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17948 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17949 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17950 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17951 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17952 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17953 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17954 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17955 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17956 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17957 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17958 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17959 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17960 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17961 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17962 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17963 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17964 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17965 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17966 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17967
17968 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17969 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17970 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17971 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17972 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17973 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17974 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17975 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17976 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17977 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17978 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17979
17980 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17981 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17982 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17983
17984 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17985 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17986 }
17987
17988 // reset default fan speed
17989
17990 #ifdef HAVE_HWMON
17991 if (gpu_temp_disable == 0)
17992 {
17993 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17994 {
17995 hc_thread_mutex_lock (mux_adl);
17996
17997 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17998 {
17999 hc_device_param_t *device_param = &data.devices_param[device_id];
18000
18001 if (device_param->skipped) continue;
18002
18003 if (data.hm_device[device_id].fan_set_supported == 1)
18004 {
18005 int fanspeed = temp_retain_fanspeed_value[device_id];
18006 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18007
18008 if (fanpolicy == 1)
18009 {
18010 int rc = -1;
18011
18012 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18013 {
18014 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18015 }
18016 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18017 {
18018
18019 }
18020
18021 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18022 }
18023 }
18024 }
18025
18026 hc_thread_mutex_unlock (mux_adl);
18027 }
18028 }
18029
18030 // reset power tuning
18031
18032 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18033 {
18034 hc_thread_mutex_lock (mux_adl);
18035
18036 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18037 {
18038 hc_device_param_t *device_param = &data.devices_param[device_id];
18039
18040 if (device_param->skipped) continue;
18041
18042 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18043 {
18044 if (data.hm_device[device_id].od_version == 6)
18045 {
18046 // check powertune capabilities first, if not available then skip device
18047
18048 int powertune_supported = 0;
18049
18050 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18051 {
18052 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18053
18054 return (-1);
18055 }
18056
18057 if (powertune_supported != 0)
18058 {
18059 // powercontrol settings
18060
18061 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18062 {
18063 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18064
18065 return (-1);
18066 }
18067
18068 // clocks
18069
18070 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18071
18072 performance_state->iNumberOfPerformanceLevels = 2;
18073
18074 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18075 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18076 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18077 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18078
18079 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18080 {
18081 log_info ("ERROR: Failed to restore ADL performance state");
18082
18083 return (-1);
18084 }
18085
18086 local_free (performance_state);
18087 }
18088 }
18089 }
18090
18091 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18092 {
18093 unsigned int limit = nvml_power_limit[device_id];
18094
18095 if (limit > 0)
18096 {
18097 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18098 }
18099 }
18100 }
18101
18102 hc_thread_mutex_unlock (mux_adl);
18103 }
18104
18105 if (gpu_temp_disable == 0)
18106 {
18107 if (data.hm_nvml)
18108 {
18109 hm_NVML_nvmlShutdown (data.hm_nvml);
18110
18111 nvml_close (data.hm_nvml);
18112
18113 data.hm_nvml = NULL;
18114 }
18115
18116 if (data.hm_adl)
18117 {
18118 hm_ADL_Main_Control_Destroy (data.hm_adl);
18119
18120 adl_close (data.hm_adl);
18121
18122 data.hm_adl = NULL;
18123 }
18124 }
18125 #endif // HAVE_HWMON
18126
18127 // free memory
18128
18129 local_free (masks);
18130
18131 local_free (dictstat_base);
18132
18133 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18134 {
18135 pot_t *pot_ptr = &pot[pot_pos];
18136
18137 hash_t *hash = &pot_ptr->hash;
18138
18139 local_free (hash->digest);
18140
18141 if (isSalted)
18142 {
18143 local_free (hash->salt);
18144 }
18145 }
18146
18147 local_free (pot);
18148
18149 local_free (all_kernel_rules_cnt);
18150 local_free (all_kernel_rules_buf);
18151
18152 local_free (wl_data->buf);
18153 local_free (wl_data);
18154
18155 local_free (bitmap_s1_a);
18156 local_free (bitmap_s1_b);
18157 local_free (bitmap_s1_c);
18158 local_free (bitmap_s1_d);
18159 local_free (bitmap_s2_a);
18160 local_free (bitmap_s2_b);
18161 local_free (bitmap_s2_c);
18162 local_free (bitmap_s2_d);
18163
18164 #ifdef HAVE_HWMON
18165 local_free (temp_retain_fanspeed_value);
18166 local_free (od_clock_mem_status);
18167 local_free (od_power_control_status);
18168 local_free (nvml_power_limit);
18169 #endif
18170
18171 global_free (devices_param);
18172
18173 global_free (kernel_rules_buf);
18174
18175 global_free (root_css_buf);
18176 global_free (markov_css_buf);
18177
18178 global_free (digests_buf);
18179 global_free (digests_shown);
18180 global_free (digests_shown_tmp);
18181
18182 global_free (salts_buf);
18183 global_free (salts_shown);
18184
18185 global_free (esalts_buf);
18186
18187 global_free (words_progress_done);
18188 global_free (words_progress_rejected);
18189 global_free (words_progress_restored);
18190
18191 if (pot_fp) fclose (pot_fp);
18192
18193 if (data.devices_status == STATUS_QUIT) break;
18194 }
18195
18196 // destroy others mutex
18197
18198 hc_thread_mutex_delete (mux_dispatcher);
18199 hc_thread_mutex_delete (mux_counter);
18200 hc_thread_mutex_delete (mux_display);
18201 hc_thread_mutex_delete (mux_adl);
18202
18203 // free memory
18204
18205 local_free (eff_restore_file);
18206 local_free (new_restore_file);
18207
18208 local_free (rd);
18209
18210 // tuning db
18211
18212 tuning_db_destroy (tuning_db);
18213
18214 // loopback
18215
18216 local_free (loopback_file);
18217
18218 if (loopback == 1) unlink (loopback_file);
18219
18220 // induction directory
18221
18222 if (induction_dir == NULL)
18223 {
18224 if (attack_mode != ATTACK_MODE_BF)
18225 {
18226 if (rmdir (induction_directory) == -1)
18227 {
18228 if (errno == ENOENT)
18229 {
18230 // good, we can ignore
18231 }
18232 else if (errno == ENOTEMPTY)
18233 {
18234 // good, we can ignore
18235 }
18236 else
18237 {
18238 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18239
18240 return (-1);
18241 }
18242 }
18243
18244 local_free (induction_directory);
18245 }
18246 }
18247
18248 // outfile-check directory
18249
18250 if (outfile_check_dir == NULL)
18251 {
18252 if (rmdir (outfile_check_directory) == -1)
18253 {
18254 if (errno == ENOENT)
18255 {
18256 // good, we can ignore
18257 }
18258 else if (errno == ENOTEMPTY)
18259 {
18260 // good, we can ignore
18261 }
18262 else
18263 {
18264 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18265
18266 return (-1);
18267 }
18268 }
18269
18270 local_free (outfile_check_directory);
18271 }
18272
18273 time_t proc_stop;
18274
18275 time (&proc_stop);
18276
18277 logfile_top_uint (proc_start);
18278 logfile_top_uint (proc_stop);
18279
18280 logfile_top_msg ("STOP");
18281
18282 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18283 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18284
18285 if (data.ocl) ocl_close (data.ocl);
18286
18287 if (data.devices_status == STATUS_ABORTED) return 2;
18288 if (data.devices_status == STATUS_QUIT) return 2;
18289 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18290 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18291 if (data.devices_status == STATUS_CRACKED) return 0;
18292
18293 return -1;
18294 }
Hashcat additions to support pwdhash