projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Add PCI-E Lanes to status display, if available
[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 70
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "- [ Options ] -",
353 "",
354 " Options Short / Long | Type | Description | Example",
355 "===============================|======|======================================================|=======================",
356 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
357 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
358 " -V, --version | | Print version |",
359 " -h, --help | | Print help |",
360 " --quiet | | Suppress output |",
361 " --hex-charset | | Assume charset is given in hex |",
362 " --hex-salt | | Assume salt is given in hex |",
363 " --hex-wordlist | | Assume words in wordlist is given in hex |",
364 " --force | | Ignore warnings |",
365 " --status | | Enable automatic update of the status-screen |",
366 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
367 " --machine-readable | | Display the status view in a machine readable format |",
368 " --loopback | | Add new plains to induct directory |",
369 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
370 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
371 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
372 " --markov-classic | | Enables classic markov-chains, no per-position |",
373 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
374 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
375 " --session | Str | Define specific session name | --session=mysession",
376 " --restore | | Restore session from --session |",
377 " --restore-disable | | Do not write restore file |",
378 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
379 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
380 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
381 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
382 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
383 " --show | | Show cracked passwords only |",
384 " --left | | Show un-cracked passwords only |",
385 " --username | | Enable ignoring of usernames in hashfile |",
386 " --remove | | Enable remove of hash once it is cracked |",
387 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
388 " --potfile-disable | | Do not write potfile |",
389 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
390 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
391 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
392 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
393 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
394 " --logfile-disable | | Disable the logfile |",
395 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
396 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
397 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
398 " -b, --benchmark | | Run benchmark |",
399 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
400 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
401 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
402 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
403 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
404 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
405 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
406 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
407 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
408 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
409 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
410 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
411 #ifdef HAVE_HWMON
412 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
413 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
414 #ifdef HAVE_ADL
415 " --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) |",
416 #endif
417 #endif
418 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
419 " -s, --skip | Num | Skip X words from the start | -s 1000000",
420 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
421 " --keyspace | | Show keyspace base:mod values and quit |",
422 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
423 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
424 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
425 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
426 " --generate-rules-func-min | Num | Force min X funcs per rule |",
427 " --generate-rules-func-max | Num | Force max X funcs per rule |",
428 " --generate-rules-seed | Num | Force RNG seed set to X |",
429 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
430 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
431 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
432 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
433 " -i, --increment | | Enable mask increment mode |",
434 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
435 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
436 "",
437 "- [ Hash modes ] -",
438 "",
439 " # | Name | Category",
440 " ======+==================================================+======================================",
441 " 900 | MD4 | Raw Hash",
442 " 0 | MD5 | Raw Hash",
443 " 5100 | Half MD5 | Raw Hash",
444 " 100 | SHA1 | Raw Hash",
445 " 10800 | SHA-384 | Raw Hash",
446 " 1400 | SHA-256 | Raw Hash",
447 " 1700 | SHA-512 | Raw Hash",
448 " 5000 | SHA-3(Keccak) | Raw Hash",
449 " 10100 | SipHash | Raw Hash",
450 " 6000 | RipeMD160 | Raw Hash",
451 " 6100 | Whirlpool | Raw Hash",
452 " 6900 | GOST R 34.11-94 | Raw Hash",
453 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
454 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
455 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
456 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
457 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
458 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
459 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
460 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
461 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
462 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
463 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
464 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
465 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
466 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
467 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
468 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
469 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
470 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
471 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
472 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
473 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
474 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
475 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
476 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
477 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
478 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
479 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
480 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
481 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
482 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
483 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
484 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
485 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
486 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
487 " 400 | phpass | Generic KDF",
488 " 8900 | scrypt | Generic KDF",
489 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
490 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
491 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
492 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
493 " 23 | Skype | Network protocols",
494 " 2500 | WPA/WPA2 | Network protocols",
495 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
496 " 5300 | IKE-PSK MD5 | Network protocols",
497 " 5400 | IKE-PSK SHA1 | Network protocols",
498 " 5500 | NetNTLMv1 | Network protocols",
499 " 5500 | NetNTLMv1 + ESS | Network protocols",
500 " 5600 | NetNTLMv2 | Network protocols",
501 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
502 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
503 " 8300 | DNSSEC (NSEC3) | Network protocols",
504 " 10200 | Cram MD5 | Network protocols",
505 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
506 " 11200 | MySQL CRAM (SHA1) | Network protocols",
507 " 11400 | SIP digest authentication (MD5) | Network protocols",
508 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
509 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
510 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
511 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
512 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
513 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
514 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
515 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
516 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
517 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
518 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
519 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
520 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
521 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
522 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
523 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
524 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
525 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
526 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
527 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
528 " 12 | PostgreSQL | Database Server",
529 " 131 | MSSQL(2000) | Database Server",
530 " 132 | MSSQL(2005) | Database Server",
531 " 1731 | MSSQL(2012) | Database Server",
532 " 1731 | MSSQL(2014) | Database Server",
533 " 200 | MySQL323 | Database Server",
534 " 300 | MySQL4.1/MySQL5 | Database Server",
535 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
536 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
537 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
538 " 8000 | Sybase ASE | Database Server",
539 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
540 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
541 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
542 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
543 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
544 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
545 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
546 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
547 " 11500 | CRC32 | Checksums",
548 " 3000 | LM | Operating-Systems",
549 " 1000 | NTLM | Operating-Systems",
550 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
551 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
552 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
553 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
554 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
555 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
556 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
557 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
558 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
559 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
560 " 1722 | OSX v10.7 | Operating-Systems",
561 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
562 " 6300 | AIX {smd5} | Operating-Systems",
563 " 6700 | AIX {ssha1} | Operating-Systems",
564 " 6400 | AIX {ssha256} | Operating-Systems",
565 " 6500 | AIX {ssha512} | Operating-Systems",
566 " 2400 | Cisco-PIX | Operating-Systems",
567 " 2410 | Cisco-ASA | Operating-Systems",
568 " 500 | Cisco-IOS $1$ | Operating-Systems",
569 " 5700 | Cisco-IOS $4$ | Operating-Systems",
570 " 9200 | Cisco-IOS $8$ | Operating-Systems",
571 " 9300 | Cisco-IOS $9$ | Operating-Systems",
572 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
573 " 501 | Juniper IVE | Operating-Systems",
574 " 5800 | Android PIN | Operating-Systems",
575 " 8100 | Citrix Netscaler | Operating-Systems",
576 " 8500 | RACF | Operating-Systems",
577 " 7200 | GRUB 2 | Operating-Systems",
578 " 9900 | Radmin2 | Operating-Systems",
579 " 125 | ArubaOS | Operating-Systems",
580 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
581 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
582 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
583 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
584 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
585 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
586 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
587 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
588 " 11600 | 7-Zip | Archives",
589 " 12500 | RAR3-hp | Archives",
590 " 13000 | RAR5 | Archives",
591 " 13200 | AxCrypt | Archives",
592 " 13300 | AxCrypt in memory SHA1 | Archives",
593 " 13600 | WinZip | Archives",
594 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
595 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
596 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
597 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
598 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
599 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
600 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
601 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
602 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
603 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
604 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
605 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
606 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
607 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
608 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
609 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
610 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
611 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
612 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
613 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
614 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
615 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
616 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
617 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
618 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
619 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
620 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
621 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
622 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
623 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
624 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
625 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
626 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
627 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
628 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
629 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
630 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
631 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
632 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
633 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
634 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
635 " 9400 | MS Office 2007 | Documents",
636 " 9500 | MS Office 2010 | Documents",
637 " 9600 | MS Office 2013 | Documents",
638 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
639 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
640 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
641 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
642 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
643 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
644 " 9000 | Password Safe v2 | Password Managers",
645 " 5200 | Password Safe v3 | Password Managers",
646 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
647 " 6600 | 1Password, agilekeychain | Password Managers",
648 " 8200 | 1Password, cloudkeychain | Password Managers",
649 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
650 " 12700 | Blockchain, My Wallet | Password Managers",
651 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
652 "",
653 "- [ Outfile Formats ] -",
654 "",
655 " # | Format",
656 " ===+========",
657 " 1 | hash[:salt]",
658 " 2 | plain",
659 " 3 | hash[:salt]:plain",
660 " 4 | hex_plain",
661 " 5 | hash[:salt]:hex_plain",
662 " 6 | plain:hex_plain",
663 " 7 | hash[:salt]:plain:hex_plain",
664 " 8 | crackpos",
665 " 9 | hash[:salt]:crack_pos",
666 " 10 | plain:crack_pos",
667 " 11 | hash[:salt]:plain:crack_pos",
668 " 12 | hex_plain:crack_pos",
669 " 13 | hash[:salt]:hex_plain:crack_pos",
670 " 14 | plain:hex_plain:crack_pos",
671 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
672 "",
673 "- [ Rule Debugging Modes ] -",
674 "",
675 " # | Format",
676 " ===+========",
677 " 1 | Finding-Rule",
678 " 2 | Original-Word",
679 " 3 | Original-Word:Finding-Rule",
680 " 4 | Original-Word:Finding-Rule:Processed-Word",
681 "",
682 "- [ Attack Modes ] -",
683 "",
684 " # | Mode",
685 " ===+======",
686 " 0 | Straight",
687 " 1 | Combination",
688 " 3 | Brute-force",
689 " 6 | Hybrid Wordlist + Mask",
690 " 7 | Hybrid Mask + Wordlist",
691 "",
692 "- [ Built-in Charsets ] -",
693 "",
694 " ? | Charset",
695 " ===+=========",
696 " l | abcdefghijklmnopqrstuvwxyz",
697 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
698 " d | 0123456789",
699 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
700 " a | ?l?u?d?s",
701 " b | 0x00 - 0xff",
702 "",
703 "- [ OpenCL Device Types ] -",
704 "",
705 " # | Device Type",
706 " ===+=============",
707 " 1 | CPU",
708 " 2 | GPU",
709 " 3 | FPGA, DSP, Co-Processor",
710 "",
711 "- [ Workload Profiles ] -",
712 "",
713 " # | Performance | Runtime | Power Consumption | Desktop Impact",
714 " ===+=============+=========+===================+=================",
715 " 1 | Low | 2 ms | Low | Minimal",
716 " 2 | Default | 12 ms | Economic | Noticeable",
717 " 3 | High | 96 ms | High | Unresponsive",
718 " 4 | Nightmare | 480 ms | Insane | Headless",
719 "",
720 "If you have no idea what just happened then visit the following pages:",
721 "",
722 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
723 "* https://hashcat.net/wiki/#frequently_asked_questions",
724 "",
725 NULL
726 };
727
728 /**
729 * hashcat specific functions
730 */
731
732 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
733 {
734 int exec_pos = (int) device_param->exec_pos - last_num_entries;
735
736 if (exec_pos < 0) exec_pos += EXEC_CACHE;
737
738 double exec_ms_sum = 0;
739
740 int exec_ms_cnt = 0;
741
742 for (int i = 0; i < last_num_entries; i++)
743 {
744 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
745
746 if (exec_ms)
747 {
748 exec_ms_sum += exec_ms;
749
750 exec_ms_cnt++;
751 }
752 }
753
754 if (exec_ms_cnt == 0) return 0;
755
756 return exec_ms_sum / exec_ms_cnt;
757 }
758
759 void status_display_machine_readable ()
760 {
761 FILE *out = stdout;
762
763 fprintf (out, "STATUS\t%u\t", data.devices_status);
764
765 /**
766 * speed new
767 */
768
769 fprintf (out, "SPEED\t");
770
771 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
772 {
773 hc_device_param_t *device_param = &data.devices_param[device_id];
774
775 if (device_param->skipped) continue;
776
777 u64 speed_cnt = 0;
778 double speed_ms = 0;
779
780 for (int i = 0; i < SPEED_CACHE; i++)
781 {
782 speed_cnt += device_param->speed_cnt[i];
783 speed_ms += device_param->speed_ms[i];
784 }
785
786 speed_cnt /= SPEED_CACHE;
787 speed_ms /= SPEED_CACHE;
788
789 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
790 }
791
792 /**
793 * exec time
794 */
795
796 fprintf (out, "EXEC_RUNTIME\t");
797
798 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
799 {
800 hc_device_param_t *device_param = &data.devices_param[device_id];
801
802 if (device_param->skipped) continue;
803
804 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
805
806 fprintf (out, "%f\t", exec_ms_avg);
807 }
808
809 /**
810 * words_cur
811 */
812
813 u64 words_cur = get_lowest_words_done ();
814
815 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
816
817 /**
818 * counter
819 */
820
821 u64 progress_total = data.words_cnt * data.salts_cnt;
822
823 u64 all_done = 0;
824 u64 all_rejected = 0;
825 u64 all_restored = 0;
826
827 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
828 {
829 all_done += data.words_progress_done[salt_pos];
830 all_rejected += data.words_progress_rejected[salt_pos];
831 all_restored += data.words_progress_restored[salt_pos];
832 }
833
834 u64 progress_cur = all_restored + all_done + all_rejected;
835 u64 progress_end = progress_total;
836
837 u64 progress_skip = 0;
838
839 if (data.skip)
840 {
841 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
842
843 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
844 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
845 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
846 }
847
848 if (data.limit)
849 {
850 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
851
852 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
853 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
854 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
855 }
856
857 u64 progress_cur_relative_skip = progress_cur - progress_skip;
858 u64 progress_end_relative_skip = progress_end - progress_skip;
859
860 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
861
862 /**
863 * cracks
864 */
865
866 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
867 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
868
869 /**
870 * temperature
871 */
872
873 #ifdef HAVE_HWMON
874 if (data.gpu_temp_disable == 0)
875 {
876 fprintf (out, "TEMP\t");
877
878 hc_thread_mutex_lock (mux_adl);
879
880 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
881 {
882 hc_device_param_t *device_param = &data.devices_param[device_id];
883
884 if (device_param->skipped) continue;
885
886 int temp = hm_get_temperature_with_device_id (device_id);
887
888 fprintf (out, "%d\t", temp);
889 }
890
891 hc_thread_mutex_unlock (mux_adl);
892 }
893 #endif // HAVE_HWMON
894
895 /**
896 * flush
897 */
898
899 #ifdef _WIN
900 fputc ('\r', out);
901 fputc ('\n', out);
902 #endif
903
904 #ifdef _POSIX
905 fputc ('\n', out);
906 #endif
907
908 fflush (out);
909 }
910
911 void status_display ()
912 {
913 if (data.devices_status == STATUS_INIT) return;
914 if (data.devices_status == STATUS_STARTING) return;
915 if (data.devices_status == STATUS_BYPASS) return;
916
917 if (data.machine_readable == 1)
918 {
919 status_display_machine_readable ();
920
921 return;
922 }
923
924 char tmp_buf[1000] = { 0 };
925
926 uint tmp_len = 0;
927
928 log_info ("Session.Name...: %s", data.session);
929
930 char *status_type = strstatus (data.devices_status);
931
932 uint hash_mode = data.hash_mode;
933
934 char *hash_type = strhashtype (hash_mode); // not a bug
935
936 log_info ("Status.........: %s", status_type);
937
938 /**
939 * show rules
940 */
941
942 if (data.rp_files_cnt)
943 {
944 uint i;
945
946 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
947 {
948 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
949 }
950
951 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
952
953 log_info ("Rules.Type.....: %s", tmp_buf);
954
955 tmp_len = 0;
956 }
957
958 if (data.rp_gen)
959 {
960 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
961
962 if (data.rp_gen_seed)
963 {
964 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
965 }
966 }
967
968 /**
969 * show input
970 */
971
972 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
973 {
974 if (data.wordlist_mode == WL_MODE_FILE)
975 {
976 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
977 }
978 else if (data.wordlist_mode == WL_MODE_STDIN)
979 {
980 log_info ("Input.Mode.....: Pipe");
981 }
982 }
983 else if (data.attack_mode == ATTACK_MODE_COMBI)
984 {
985 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
986 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
987 }
988 else if (data.attack_mode == ATTACK_MODE_BF)
989 {
990 char *mask = data.mask;
991
992 if (mask != NULL)
993 {
994 uint mask_len = data.css_cnt;
995
996 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
997
998 if (mask_len > 0)
999 {
1000 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1001 {
1002 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1003 {
1004 mask_len -= data.salts_buf[0].salt_len;
1005 }
1006 }
1007
1008 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1009
1010 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1011 }
1012
1013 if (data.maskcnt > 1)
1014 {
1015 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1016
1017 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1018 }
1019
1020 log_info ("Input.Mode.....: %s", tmp_buf);
1021 }
1022
1023 tmp_len = 0;
1024 }
1025 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1026 {
1027 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1028 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1029 }
1030 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1031 {
1032 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1033 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1034 }
1035
1036 if (data.digests_cnt == 1)
1037 {
1038 if (data.hash_mode == 2500)
1039 {
1040 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1041
1042 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1043 (char *) data.salts_buf[0].salt_buf,
1044 wpa->orig_mac1[0],
1045 wpa->orig_mac1[1],
1046 wpa->orig_mac1[2],
1047 wpa->orig_mac1[3],
1048 wpa->orig_mac1[4],
1049 wpa->orig_mac1[5],
1050 wpa->orig_mac2[0],
1051 wpa->orig_mac2[1],
1052 wpa->orig_mac2[2],
1053 wpa->orig_mac2[3],
1054 wpa->orig_mac2[4],
1055 wpa->orig_mac2[5]);
1056 }
1057 else if (data.hash_mode == 5200)
1058 {
1059 log_info ("Hash.Target....: File (%s)", data.hashfile);
1060 }
1061 else if (data.hash_mode == 9000)
1062 {
1063 log_info ("Hash.Target....: File (%s)", data.hashfile);
1064 }
1065 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1066 {
1067 log_info ("Hash.Target....: File (%s)", data.hashfile);
1068 }
1069 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1070 {
1071 log_info ("Hash.Target....: File (%s)", data.hashfile);
1072 }
1073 else
1074 {
1075 char out_buf[HCBUFSIZ] = { 0 };
1076
1077 ascii_digest (out_buf, 0, 0);
1078
1079 // limit length
1080 if (strlen (out_buf) > 40)
1081 {
1082 out_buf[41] = '.';
1083 out_buf[42] = '.';
1084 out_buf[43] = '.';
1085 out_buf[44] = 0;
1086 }
1087
1088 log_info ("Hash.Target....: %s", out_buf);
1089 }
1090 }
1091 else
1092 {
1093 if (data.hash_mode == 3000)
1094 {
1095 char out_buf1[32] = { 0 };
1096 char out_buf2[32] = { 0 };
1097
1098 ascii_digest (out_buf1, 0, 0);
1099 ascii_digest (out_buf2, 0, 1);
1100
1101 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1102 }
1103 else
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 }
1108
1109 log_info ("Hash.Type......: %s", hash_type);
1110
1111 /**
1112 * speed new
1113 */
1114
1115 u64 speed_cnt[DEVICES_MAX] = { 0 };
1116 double speed_ms[DEVICES_MAX] = { 0 };
1117
1118 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1119 {
1120 hc_device_param_t *device_param = &data.devices_param[device_id];
1121
1122 if (device_param->skipped) continue;
1123
1124 speed_cnt[device_id] = 0;
1125 speed_ms[device_id] = 0;
1126
1127 for (int i = 0; i < SPEED_CACHE; i++)
1128 {
1129 speed_cnt[device_id] += device_param->speed_cnt[i];
1130 speed_ms[device_id] += device_param->speed_ms[i];
1131 }
1132
1133 speed_cnt[device_id] /= SPEED_CACHE;
1134 speed_ms[device_id] /= SPEED_CACHE;
1135 }
1136
1137 double hashes_all_ms = 0;
1138
1139 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1140
1141 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1142 {
1143 hc_device_param_t *device_param = &data.devices_param[device_id];
1144
1145 if (device_param->skipped) continue;
1146
1147 hashes_dev_ms[device_id] = 0;
1148
1149 if (speed_ms[device_id])
1150 {
1151 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1152
1153 hashes_all_ms += hashes_dev_ms[device_id];
1154 }
1155 }
1156
1157 /**
1158 * exec time
1159 */
1160
1161 double exec_all_ms[DEVICES_MAX] = { 0 };
1162
1163 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1164 {
1165 hc_device_param_t *device_param = &data.devices_param[device_id];
1166
1167 if (device_param->skipped) continue;
1168
1169 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1170
1171 exec_all_ms[device_id] = exec_ms_avg;
1172 }
1173
1174 /**
1175 * timers
1176 */
1177
1178 double ms_running = 0;
1179
1180 hc_timer_get (data.timer_running, ms_running);
1181
1182 double ms_paused = data.ms_paused;
1183
1184 if (data.devices_status == STATUS_PAUSED)
1185 {
1186 double ms_paused_tmp = 0;
1187
1188 hc_timer_get (data.timer_paused, ms_paused_tmp);
1189
1190 ms_paused += ms_paused_tmp;
1191 }
1192
1193 #ifdef WIN
1194
1195 __time64_t sec_run = ms_running / 1000;
1196
1197 #else
1198
1199 time_t sec_run = ms_running / 1000;
1200
1201 #endif
1202
1203 if (sec_run)
1204 {
1205 char display_run[32] = { 0 };
1206
1207 struct tm tm_run;
1208
1209 struct tm *tmp = NULL;
1210
1211 #ifdef WIN
1212
1213 tmp = _gmtime64 (&sec_run);
1214
1215 #else
1216
1217 tmp = gmtime (&sec_run);
1218
1219 #endif
1220
1221 if (tmp != NULL)
1222 {
1223 memset (&tm_run, 0, sizeof (tm_run));
1224
1225 memcpy (&tm_run, tmp, sizeof (tm_run));
1226
1227 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1228
1229 char *start = ctime (&data.proc_start);
1230
1231 size_t start_len = strlen (start);
1232
1233 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1234 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1235
1236 log_info ("Time.Started...: %s (%s)", start, display_run);
1237 }
1238 }
1239 else
1240 {
1241 log_info ("Time.Started...: 0 secs");
1242 }
1243
1244 /**
1245 * counters
1246 */
1247
1248 u64 progress_total = data.words_cnt * data.salts_cnt;
1249
1250 u64 all_done = 0;
1251 u64 all_rejected = 0;
1252 u64 all_restored = 0;
1253
1254 u64 progress_noneed = 0;
1255
1256 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1257 {
1258 all_done += data.words_progress_done[salt_pos];
1259 all_rejected += data.words_progress_rejected[salt_pos];
1260 all_restored += data.words_progress_restored[salt_pos];
1261
1262 // Important for ETA only
1263
1264 if (data.salts_shown[salt_pos] == 1)
1265 {
1266 const u64 all = data.words_progress_done[salt_pos]
1267 + data.words_progress_rejected[salt_pos]
1268 + data.words_progress_restored[salt_pos];
1269
1270 const u64 left = data.words_cnt - all;
1271
1272 progress_noneed += left;
1273 }
1274 }
1275
1276 u64 progress_cur = all_restored + all_done + all_rejected;
1277 u64 progress_end = progress_total;
1278
1279 u64 progress_skip = 0;
1280
1281 if (data.skip)
1282 {
1283 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1284
1285 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1286 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1287 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1288 }
1289
1290 if (data.limit)
1291 {
1292 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1293
1294 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1295 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1296 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1297 }
1298
1299 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1300 u64 progress_end_relative_skip = progress_end - progress_skip;
1301
1302 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1303 {
1304 if (data.devices_status != STATUS_CRACKED)
1305 {
1306 #ifdef WIN
1307 __time64_t sec_etc = 0;
1308 #else
1309 time_t sec_etc = 0;
1310 #endif
1311
1312 if (hashes_all_ms)
1313 {
1314 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1315
1316 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1317
1318 sec_etc = ms_left / 1000;
1319 }
1320
1321 if (sec_etc == 0)
1322 {
1323 //log_info ("Time.Estimated.: 0 secs");
1324 }
1325 else if ((u64) sec_etc > ETC_MAX)
1326 {
1327 log_info ("Time.Estimated.: > 10 Years");
1328 }
1329 else
1330 {
1331 char display_etc[32] = { 0 };
1332
1333 struct tm tm_etc;
1334
1335 struct tm *tmp = NULL;
1336
1337 #ifdef WIN
1338
1339 tmp = _gmtime64 (&sec_etc);
1340
1341 #else
1342
1343 tmp = gmtime (&sec_etc);
1344
1345 #endif
1346
1347 if (tmp != NULL)
1348 {
1349 memset (&tm_etc, 0, sizeof (tm_etc));
1350
1351 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1352
1353 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1354
1355 time_t now;
1356
1357 time (&now);
1358
1359 now += sec_etc;
1360
1361 char *etc = ctime (&now);
1362
1363 size_t etc_len = strlen (etc);
1364
1365 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1366 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1367
1368 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1369 }
1370 }
1371 }
1372 }
1373
1374 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1375 {
1376 hc_device_param_t *device_param = &data.devices_param[device_id];
1377
1378 if (device_param->skipped) continue;
1379
1380 char display_dev_cur[16] = { 0 };
1381
1382 strncpy (display_dev_cur, "0.00", 4);
1383
1384 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1385
1386 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1387 }
1388
1389 char display_all_cur[16] = { 0 };
1390
1391 strncpy (display_all_cur, "0.00", 4);
1392
1393 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1394
1395 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1396
1397 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1398 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1399
1400 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);
1401
1402 // crack-per-time
1403
1404 if (data.digests_cnt > 100)
1405 {
1406 time_t now = time (NULL);
1407
1408 int cpt_cur_min = 0;
1409 int cpt_cur_hour = 0;
1410 int cpt_cur_day = 0;
1411
1412 for (int i = 0; i < CPT_BUF; i++)
1413 {
1414 const uint cracked = data.cpt_buf[i].cracked;
1415 const time_t timestamp = data.cpt_buf[i].timestamp;
1416
1417 if ((timestamp + 60) > now)
1418 {
1419 cpt_cur_min += cracked;
1420 }
1421
1422 if ((timestamp + 3600) > now)
1423 {
1424 cpt_cur_hour += cracked;
1425 }
1426
1427 if ((timestamp + 86400) > now)
1428 {
1429 cpt_cur_day += cracked;
1430 }
1431 }
1432
1433 double ms_real = ms_running - ms_paused;
1434
1435 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1436 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1437 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1438
1439 if ((data.cpt_start + 86400) < now)
1440 {
1441 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1442 cpt_cur_min,
1443 cpt_cur_hour,
1444 cpt_cur_day,
1445 cpt_avg_min,
1446 cpt_avg_hour,
1447 cpt_avg_day);
1448 }
1449 else if ((data.cpt_start + 3600) < now)
1450 {
1451 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1452 cpt_cur_min,
1453 cpt_cur_hour,
1454 cpt_avg_min,
1455 cpt_avg_hour,
1456 cpt_avg_day);
1457 }
1458 else if ((data.cpt_start + 60) < now)
1459 {
1460 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1461 cpt_cur_min,
1462 cpt_avg_min,
1463 cpt_avg_hour,
1464 cpt_avg_day);
1465 }
1466 else
1467 {
1468 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1469 cpt_avg_min,
1470 cpt_avg_hour,
1471 cpt_avg_day);
1472 }
1473 }
1474
1475 // Restore point
1476
1477 u64 restore_point = get_lowest_words_done ();
1478
1479 u64 restore_total = data.words_base;
1480
1481 float percent_restore = 0;
1482
1483 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1484
1485 if (progress_end_relative_skip)
1486 {
1487 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1488 {
1489 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1490 float percent_rejected = 0.0;
1491
1492 if (progress_cur)
1493 {
1494 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1495 }
1496
1497 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);
1498 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1499
1500 if (data.restore_disable == 0)
1501 {
1502 if (percent_finished != 1)
1503 {
1504 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1505 }
1506 }
1507 }
1508 }
1509 else
1510 {
1511 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1512 {
1513 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1514 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1515
1516 if (data.restore_disable == 0)
1517 {
1518 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1519 }
1520 }
1521 else
1522 {
1523 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1524 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1525
1526 // --restore not allowed if stdin is used -- really? why?
1527
1528 //if (data.restore_disable == 0)
1529 //{
1530 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1531 //}
1532 }
1533 }
1534
1535 #ifdef HAVE_HWMON
1536 if (data.gpu_temp_disable == 0)
1537 {
1538 hc_thread_mutex_lock (mux_adl);
1539
1540 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1541 {
1542 hc_device_param_t *device_param = &data.devices_param[device_id];
1543
1544 if (device_param->skipped) continue;
1545
1546 #define HM_STR_BUF_SIZE 255
1547
1548 char utilization[HM_STR_BUF_SIZE] = { 0 };
1549 char temperature[HM_STR_BUF_SIZE] = { 0 };
1550 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1551 char corespeed[HM_STR_BUF_SIZE] = { 0 };
1552 char memoryspeed[HM_STR_BUF_SIZE] = { 0 };
1553 char currentbuslanes[HM_STR_BUF_SIZE] = { 0 };
1554 char maxbuslanes[HM_STR_BUF_SIZE] = { 0 };
1555
1556 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1557 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1558 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1559 hm_device_val_to_str ((char *) corespeed, HM_STR_BUF_SIZE, "Mhz", hm_get_corespeed_with_device_id (device_id));
1560 hm_device_val_to_str ((char *) memoryspeed, HM_STR_BUF_SIZE, "Mhz", hm_get_memoryspeed_with_device_id (device_id));
1561 hm_device_val_to_str ((char *) currentbuslanes, HM_STR_BUF_SIZE, "", hm_get_currentbuslanes_with_device_id (device_id));
1562 hm_device_val_to_str ((char *) maxbuslanes, HM_STR_BUF_SIZE, "", hm_get_maxbuslanes_with_device_id (device_id));
1563
1564 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan, %s Core, %s Mem, %s/%s Lanes", device_id + 1, utilization, temperature, fanspeed, corespeed, memoryspeed, currentbuslanes, maxbuslanes);
1565 }
1566
1567 hc_thread_mutex_unlock (mux_adl);
1568 }
1569 #endif // HAVE_HWMON
1570 }
1571
1572 static void status_benchmark_automate ()
1573 {
1574 u64 speed_cnt[DEVICES_MAX] = { 0 };
1575 double speed_ms[DEVICES_MAX] = { 0 };
1576
1577 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1578 {
1579 hc_device_param_t *device_param = &data.devices_param[device_id];
1580
1581 if (device_param->skipped) continue;
1582
1583 speed_cnt[device_id] = device_param->speed_cnt[0];
1584 speed_ms[device_id] = device_param->speed_ms[0];
1585 }
1586
1587 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1588
1589 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1590 {
1591 hc_device_param_t *device_param = &data.devices_param[device_id];
1592
1593 if (device_param->skipped) continue;
1594
1595 hashes_dev_ms[device_id] = 0;
1596
1597 if (speed_ms[device_id])
1598 {
1599 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1600 }
1601 }
1602
1603 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1604 {
1605 hc_device_param_t *device_param = &data.devices_param[device_id];
1606
1607 if (device_param->skipped) continue;
1608
1609 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1610 }
1611 }
1612
1613 static void status_benchmark ()
1614 {
1615 if (data.devices_status == STATUS_INIT) return;
1616 if (data.devices_status == STATUS_STARTING) return;
1617 if (data.devices_status == STATUS_BYPASS) return;
1618
1619 if (data.machine_readable == 1)
1620 {
1621 status_benchmark_automate ();
1622
1623 return;
1624 }
1625
1626 u64 speed_cnt[DEVICES_MAX] = { 0 };
1627 double speed_ms[DEVICES_MAX] = { 0 };
1628
1629 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1630 {
1631 hc_device_param_t *device_param = &data.devices_param[device_id];
1632
1633 if (device_param->skipped) continue;
1634
1635 speed_cnt[device_id] = device_param->speed_cnt[0];
1636 speed_ms[device_id] = device_param->speed_ms[0];
1637 }
1638
1639 double hashes_all_ms = 0;
1640
1641 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1642
1643 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1644 {
1645 hc_device_param_t *device_param = &data.devices_param[device_id];
1646
1647 if (device_param->skipped) continue;
1648
1649 hashes_dev_ms[device_id] = 0;
1650
1651 if (speed_ms[device_id])
1652 {
1653 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1654
1655 hashes_all_ms += hashes_dev_ms[device_id];
1656 }
1657 }
1658
1659 /**
1660 * exec time
1661 */
1662
1663 double exec_all_ms[DEVICES_MAX] = { 0 };
1664
1665 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1666 {
1667 hc_device_param_t *device_param = &data.devices_param[device_id];
1668
1669 if (device_param->skipped) continue;
1670
1671 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1672
1673 exec_all_ms[device_id] = exec_ms_avg;
1674 }
1675
1676 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1677 {
1678 hc_device_param_t *device_param = &data.devices_param[device_id];
1679
1680 if (device_param->skipped) continue;
1681
1682 char display_dev_cur[16] = { 0 };
1683
1684 strncpy (display_dev_cur, "0.00", 4);
1685
1686 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1687
1688 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1689 }
1690
1691 char display_all_cur[16] = { 0 };
1692
1693 strncpy (display_all_cur, "0.00", 4);
1694
1695 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1696
1697 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1698 }
1699
1700 /**
1701 * hashcat -only- functions
1702 */
1703
1704 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1705 {
1706 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1707 {
1708 if (attack_kern == ATTACK_KERN_STRAIGHT)
1709 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1710 else if (attack_kern == ATTACK_KERN_COMBI)
1711 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1712 else if (attack_kern == ATTACK_KERN_BF)
1713 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1714 }
1715 else
1716 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1717 }
1718
1719 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)
1720 {
1721 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1722 {
1723 if (attack_kern == ATTACK_KERN_STRAIGHT)
1724 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1725 else if (attack_kern == ATTACK_KERN_COMBI)
1726 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1727 else if (attack_kern == ATTACK_KERN_BF)
1728 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1729 }
1730 else
1731 {
1732 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1733 }
1734 }
1735
1736 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1737 {
1738 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1739 {
1740 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1741 }
1742 else
1743 {
1744 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1745 }
1746 }
1747
1748 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)
1749 {
1750 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1751 {
1752 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1753 }
1754 else
1755 {
1756 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1757 }
1758 }
1759
1760 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1761 {
1762 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1763 }
1764
1765 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1766 {
1767 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1768 }
1769
1770 static uint convert_from_hex (char *line_buf, const uint line_len)
1771 {
1772 if (line_len & 1) return (line_len); // not in hex
1773
1774 if (data.hex_wordlist == 1)
1775 {
1776 uint i;
1777 uint j;
1778
1779 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1780 {
1781 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1782 }
1783
1784 memset (line_buf + i, 0, line_len - i);
1785
1786 return (i);
1787 }
1788 else if (line_len >= 6) // $HEX[] = 6
1789 {
1790 if (line_buf[0] != '$') return (line_len);
1791 if (line_buf[1] != 'H') return (line_len);
1792 if (line_buf[2] != 'E') return (line_len);
1793 if (line_buf[3] != 'X') return (line_len);
1794 if (line_buf[4] != '[') return (line_len);
1795 if (line_buf[line_len - 1] != ']') return (line_len);
1796
1797 uint i;
1798 uint j;
1799
1800 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1801 {
1802 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1803 }
1804
1805 memset (line_buf + i, 0, line_len - i);
1806
1807 return (i);
1808 }
1809
1810 return (line_len);
1811 }
1812
1813 static void clear_prompt ()
1814 {
1815 fputc ('\r', stdout);
1816
1817 for (size_t i = 0; i < strlen (PROMPT); i++)
1818 {
1819 fputc (' ', stdout);
1820 }
1821
1822 fputc ('\r', stdout);
1823
1824 fflush (stdout);
1825 }
1826
1827 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1828 {
1829 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);
1830 }
1831
1832 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1833 {
1834 char *outfile = data.outfile;
1835 uint quiet = data.quiet;
1836 FILE *pot_fp = data.pot_fp;
1837 uint loopback = data.loopback;
1838 uint debug_mode = data.debug_mode;
1839 char *debug_file = data.debug_file;
1840
1841 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1842 int debug_rule_len = 0; // -1 error
1843 uint debug_plain_len = 0;
1844
1845 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1846
1847 // hash
1848
1849 char out_buf[HCBUFSIZ] = { 0 };
1850
1851 const u32 salt_pos = plain->salt_pos;
1852 const u32 digest_pos = plain->digest_pos; // relative
1853 const u32 gidvid = plain->gidvid;
1854 const u32 il_pos = plain->il_pos;
1855
1856 ascii_digest (out_buf, salt_pos, digest_pos);
1857
1858 // plain
1859
1860 u64 crackpos = device_param->words_off;
1861
1862 uint plain_buf[16] = { 0 };
1863
1864 u8 *plain_ptr = (u8 *) plain_buf;
1865
1866 unsigned int plain_len = 0;
1867
1868 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1869 {
1870 pw_t pw;
1871
1872 gidd_to_pw_t (device_param, gidvid, &pw);
1873
1874 for (int i = 0; i < 16; i++)
1875 {
1876 plain_buf[i] = pw.i[i];
1877 }
1878
1879 plain_len = pw.pw_len;
1880
1881 const uint off = device_param->innerloop_pos + il_pos;
1882
1883 if (debug_mode > 0)
1884 {
1885 debug_rule_len = 0;
1886
1887 // save rule
1888 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1889 {
1890 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1891
1892 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1893 }
1894
1895 // save plain
1896 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1897 {
1898 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1899
1900 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1901
1902 debug_plain_len = plain_len;
1903 }
1904 }
1905
1906 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1907
1908 crackpos += gidvid;
1909 crackpos *= data.kernel_rules_cnt;
1910 crackpos += device_param->innerloop_pos + il_pos;
1911
1912 if (plain_len > data.pw_max) plain_len = data.pw_max;
1913 }
1914 else if (data.attack_mode == ATTACK_MODE_COMBI)
1915 {
1916 pw_t pw;
1917
1918 gidd_to_pw_t (device_param, gidvid, &pw);
1919
1920 for (int i = 0; i < 16; i++)
1921 {
1922 plain_buf[i] = pw.i[i];
1923 }
1924
1925 plain_len = pw.pw_len;
1926
1927 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1928 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1929
1930 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1931 {
1932 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1933 }
1934 else
1935 {
1936 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1937
1938 memcpy (plain_ptr, comb_buf, comb_len);
1939 }
1940
1941 plain_len += comb_len;
1942
1943 crackpos += gidvid;
1944 crackpos *= data.combs_cnt;
1945 crackpos += device_param->innerloop_pos + il_pos;
1946
1947 if (data.pw_max != PW_DICTMAX1)
1948 {
1949 if (plain_len > data.pw_max) plain_len = data.pw_max;
1950 }
1951 }
1952 else if (data.attack_mode == ATTACK_MODE_BF)
1953 {
1954 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1955 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1956
1957 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1958 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1959
1960 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1961 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1962
1963 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1964 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1965
1966 plain_len = data.css_cnt;
1967
1968 crackpos += gidvid;
1969 crackpos *= data.bfs_cnt;
1970 crackpos += device_param->innerloop_pos + il_pos;
1971 }
1972 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1973 {
1974 pw_t pw;
1975
1976 gidd_to_pw_t (device_param, gidvid, &pw);
1977
1978 for (int i = 0; i < 16; i++)
1979 {
1980 plain_buf[i] = pw.i[i];
1981 }
1982
1983 plain_len = pw.pw_len;
1984
1985 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1986
1987 uint start = 0;
1988 uint stop = device_param->kernel_params_mp_buf32[4];
1989
1990 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1991
1992 plain_len += start + stop;
1993
1994 crackpos += gidvid;
1995 crackpos *= data.combs_cnt;
1996 crackpos += device_param->innerloop_pos + il_pos;
1997
1998 if (data.pw_max != PW_DICTMAX1)
1999 {
2000 if (plain_len > data.pw_max) plain_len = data.pw_max;
2001 }
2002 }
2003 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2004 {
2005 pw_t pw;
2006
2007 gidd_to_pw_t (device_param, gidvid, &pw);
2008
2009 for (int i = 0; i < 16; i++)
2010 {
2011 plain_buf[i] = pw.i[i];
2012 }
2013
2014 plain_len = pw.pw_len;
2015
2016 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2017
2018 uint start = 0;
2019 uint stop = device_param->kernel_params_mp_buf32[4];
2020
2021 memmove (plain_ptr + stop, plain_ptr, plain_len);
2022
2023 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2024
2025 plain_len += start + stop;
2026
2027 crackpos += gidvid;
2028 crackpos *= data.combs_cnt;
2029 crackpos += device_param->innerloop_pos + il_pos;
2030
2031 if (data.pw_max != PW_DICTMAX1)
2032 {
2033 if (plain_len > data.pw_max) plain_len = data.pw_max;
2034 }
2035 }
2036
2037 if (data.attack_mode == ATTACK_MODE_BF)
2038 {
2039 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2040 {
2041 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2042 {
2043 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2044 {
2045 plain_len = plain_len - data.salts_buf[0].salt_len;
2046 }
2047 }
2048
2049 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2050 {
2051 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2052 {
2053 plain_ptr[j] = plain_ptr[i];
2054 }
2055
2056 plain_len = plain_len / 2;
2057 }
2058 }
2059 }
2060
2061 // if enabled, update also the potfile
2062
2063 if (pot_fp)
2064 {
2065 lock_file (pot_fp);
2066
2067 fprintf (pot_fp, "%s:", out_buf);
2068
2069 format_plain (pot_fp, plain_ptr, plain_len, 1);
2070
2071 fputc ('\n', pot_fp);
2072
2073 fflush (pot_fp);
2074
2075 unlock_file (pot_fp);
2076 }
2077
2078 // outfile
2079
2080 FILE *out_fp = NULL;
2081
2082 if (outfile != NULL)
2083 {
2084 if ((out_fp = fopen (outfile, "ab")) == NULL)
2085 {
2086 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2087
2088 out_fp = stdout;
2089 }
2090
2091 lock_file (out_fp);
2092 }
2093 else
2094 {
2095 out_fp = stdout;
2096
2097 if (quiet == 0) clear_prompt ();
2098 }
2099
2100 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2101
2102 if (outfile != NULL)
2103 {
2104 if (out_fp != stdout)
2105 {
2106 fclose (out_fp);
2107 }
2108 }
2109 else
2110 {
2111 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2112 {
2113 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2114 {
2115 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2116 if (quiet == 0) fflush (stdout);
2117 }
2118 }
2119 }
2120
2121 // loopback
2122
2123 if (loopback)
2124 {
2125 char *loopback_file = data.loopback_file;
2126
2127 FILE *fb_fp = NULL;
2128
2129 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2130 {
2131 lock_file (fb_fp);
2132
2133 format_plain (fb_fp, plain_ptr, plain_len, 1);
2134
2135 fputc ('\n', fb_fp);
2136
2137 fclose (fb_fp);
2138 }
2139 }
2140
2141 // (rule) debug mode
2142
2143 // the next check implies that:
2144 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2145 // - debug_mode > 0
2146
2147 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2148 {
2149 if (debug_rule_len < 0) debug_rule_len = 0;
2150
2151 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2152
2153 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2154
2155 if ((quiet == 0) && (debug_file == NULL))
2156 {
2157 fprintf (stdout, "%s", PROMPT);
2158
2159 fflush (stdout);
2160 }
2161 }
2162 }
2163
2164 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2165 {
2166 salt_t *salt_buf = &data.salts_buf[salt_pos];
2167
2168 u32 num_cracked;
2169
2170 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2171
2172 if (num_cracked)
2173 {
2174 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2175
2176 log_info_nn ("");
2177
2178 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2179
2180 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);
2181
2182 uint cpt_cracked = 0;
2183
2184 for (uint i = 0; i < num_cracked; i++)
2185 {
2186 const uint hash_pos = cracked[i].hash_pos;
2187
2188 if (data.digests_shown[hash_pos] == 1) continue;
2189
2190 hc_thread_mutex_lock (mux_display);
2191
2192 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2193 {
2194 data.digests_shown[hash_pos] = 1;
2195
2196 data.digests_done++;
2197
2198 cpt_cracked++;
2199
2200 salt_buf->digests_done++;
2201
2202 if (salt_buf->digests_done == salt_buf->digests_cnt)
2203 {
2204 data.salts_shown[salt_pos] = 1;
2205
2206 data.salts_done++;
2207 }
2208 }
2209
2210 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2211
2212 hc_thread_mutex_unlock (mux_display);
2213
2214 check_hash (device_param, &cracked[i]);
2215 }
2216
2217 myfree (cracked);
2218
2219 if (cpt_cracked > 0)
2220 {
2221 hc_thread_mutex_lock (mux_display);
2222
2223 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2224 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2225
2226 data.cpt_pos++;
2227
2228 data.cpt_total += cpt_cracked;
2229
2230 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2231
2232 hc_thread_mutex_unlock (mux_display);
2233 }
2234
2235 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2236 {
2237 // we need to reset cracked state on the device
2238 // otherwise host thinks again and again the hash was cracked
2239 // and returns invalid password each time
2240
2241 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2242
2243 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);
2244 }
2245
2246 num_cracked = 0;
2247
2248 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2249 }
2250 }
2251
2252 static void save_hash ()
2253 {
2254 char *hashfile = data.hashfile;
2255
2256 char new_hashfile[256] = { 0 };
2257 char old_hashfile[256] = { 0 };
2258
2259 snprintf (new_hashfile, 255, "%s.new", hashfile);
2260 snprintf (old_hashfile, 255, "%s.old", hashfile);
2261
2262 unlink (new_hashfile);
2263
2264 char separator = data.separator;
2265
2266 FILE *fp = fopen (new_hashfile, "wb");
2267
2268 if (fp == NULL)
2269 {
2270 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2271
2272 exit (-1);
2273 }
2274
2275 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2276 {
2277 if (data.salts_shown[salt_pos] == 1) continue;
2278
2279 salt_t *salt_buf = &data.salts_buf[salt_pos];
2280
2281 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2282 {
2283 uint idx = salt_buf->digests_offset + digest_pos;
2284
2285 if (data.digests_shown[idx] == 1) continue;
2286
2287 if (data.hash_mode != 2500)
2288 {
2289 char out_buf[HCBUFSIZ] = { 0 };
2290
2291 if (data.username == 1)
2292 {
2293 user_t *user = data.hash_info[idx]->user;
2294
2295 uint i;
2296
2297 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2298
2299 fputc (separator, fp);
2300 }
2301
2302 ascii_digest (out_buf, salt_pos, digest_pos);
2303
2304 fputs (out_buf, fp);
2305
2306 log_out (fp, "");
2307 }
2308 else
2309 {
2310 hccap_t hccap;
2311
2312 to_hccap_t (&hccap, salt_pos, digest_pos);
2313
2314 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2315 }
2316 }
2317 }
2318
2319 fflush (fp);
2320
2321 fclose (fp);
2322
2323 unlink (old_hashfile);
2324
2325 if (rename (hashfile, old_hashfile) != 0)
2326 {
2327 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2328
2329 exit (-1);
2330 }
2331
2332 unlink (hashfile);
2333
2334 if (rename (new_hashfile, hashfile) != 0)
2335 {
2336 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2337
2338 exit (-1);
2339 }
2340
2341 unlink (old_hashfile);
2342 }
2343
2344 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2345 {
2346 // function called only in case kernel_power_all > words_left
2347
2348 float kernel_power_div = (float) (total_left) / kernel_power_all;
2349
2350 kernel_power_div += kernel_power_div / 100;
2351
2352 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2353
2354 while (kernel_power_new < total_left)
2355 {
2356 kernel_power_div += kernel_power_div / 100;
2357
2358 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2359 }
2360
2361 if (data.quiet == 0)
2362 {
2363 clear_prompt ();
2364
2365 //log_info ("");
2366
2367 log_info ("INFO: approaching final keyspace, workload adjusted");
2368 log_info ("");
2369
2370 fprintf (stdout, "%s", PROMPT);
2371
2372 fflush (stdout);
2373 }
2374
2375 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2376
2377 return kernel_power_div;
2378 }
2379
2380 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2381 {
2382 uint num_elements = num;
2383
2384 device_param->kernel_params_buf32[30] = data.combs_mode;
2385 device_param->kernel_params_buf32[31] = num;
2386
2387 uint kernel_threads = device_param->kernel_threads;
2388
2389 while (num_elements % kernel_threads) num_elements++;
2390
2391 cl_kernel kernel = NULL;
2392
2393 switch (kern_run)
2394 {
2395 case KERN_RUN_1: kernel = device_param->kernel1; break;
2396 case KERN_RUN_12: kernel = device_param->kernel12; break;
2397 case KERN_RUN_2: kernel = device_param->kernel2; break;
2398 case KERN_RUN_23: kernel = device_param->kernel23; break;
2399 case KERN_RUN_3: kernel = device_param->kernel3; break;
2400 }
2401
2402 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2403 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2404 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2405 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2406 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2407 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2408 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2409 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2410 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2411 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2412 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2413
2414 cl_event event;
2415
2416 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2417 {
2418 const size_t global_work_size[3] = { num_elements, 32, 1 };
2419 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2420
2421 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2422 }
2423 else
2424 {
2425 if (kern_run == KERN_RUN_2)
2426 {
2427 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2428 {
2429 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2430 }
2431 }
2432
2433 while (num_elements % kernel_threads) num_elements++;
2434
2435 const size_t global_work_size[3] = { num_elements, 1, 1 };
2436 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2437
2438 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2439 }
2440
2441 hc_clFlush (data.ocl, device_param->command_queue);
2442
2443 hc_clWaitForEvents (data.ocl, 1, &event);
2444
2445 if (event_update)
2446 {
2447 cl_ulong time_start;
2448 cl_ulong time_end;
2449
2450 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2451 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2452
2453 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2454
2455 uint exec_pos = device_param->exec_pos;
2456
2457 device_param->exec_ms[exec_pos] = exec_time;
2458
2459 exec_pos++;
2460
2461 if (exec_pos == EXEC_CACHE)
2462 {
2463 exec_pos = 0;
2464 }
2465
2466 device_param->exec_pos = exec_pos;
2467 }
2468
2469 hc_clReleaseEvent (data.ocl, event);
2470
2471 hc_clFinish (data.ocl, device_param->command_queue);
2472 }
2473
2474 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2475 {
2476 uint num_elements = num;
2477
2478 switch (kern_run)
2479 {
2480 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2481 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2482 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2483 }
2484
2485 // causes problems with special threads like in bcrypt
2486 // const uint kernel_threads = device_param->kernel_threads;
2487
2488 uint kernel_threads = device_param->kernel_threads;
2489
2490 while (num_elements % kernel_threads) num_elements++;
2491
2492 cl_kernel kernel = NULL;
2493
2494 switch (kern_run)
2495 {
2496 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2497 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2498 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2499 }
2500
2501 switch (kern_run)
2502 {
2503 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2504 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2505 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2506 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2507 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2508 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2509 break;
2510 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2511 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2512 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2513 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2514 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2515 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2516 break;
2517 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2518 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2519 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2520 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2521 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2522 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2523 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2524 break;
2525 }
2526
2527 const size_t global_work_size[3] = { num_elements, 1, 1 };
2528 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2529
2530 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2531
2532 hc_clFlush (data.ocl, device_param->command_queue);
2533
2534 hc_clFinish (data.ocl, device_param->command_queue);
2535 }
2536
2537 static void run_kernel_tm (hc_device_param_t *device_param)
2538 {
2539 const uint num_elements = 1024; // fixed
2540
2541 uint kernel_threads = 32;
2542
2543 cl_kernel kernel = device_param->kernel_tm;
2544
2545 const size_t global_work_size[3] = { num_elements, 1, 1 };
2546 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2547
2548 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2549
2550 hc_clFlush (data.ocl, device_param->command_queue);
2551
2552 hc_clFinish (data.ocl, device_param->command_queue);
2553 }
2554
2555 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2556 {
2557 uint num_elements = num;
2558
2559 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2560 device_param->kernel_params_amp_buf32[6] = num_elements;
2561
2562 // causes problems with special threads like in bcrypt
2563 // const uint kernel_threads = device_param->kernel_threads;
2564
2565 uint kernel_threads = device_param->kernel_threads;
2566
2567 while (num_elements % kernel_threads) num_elements++;
2568
2569 cl_kernel kernel = device_param->kernel_amp;
2570
2571 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2572 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2573
2574 const size_t global_work_size[3] = { num_elements, 1, 1 };
2575 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2576
2577 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2578
2579 hc_clFlush (data.ocl, device_param->command_queue);
2580
2581 hc_clFinish (data.ocl, device_param->command_queue);
2582 }
2583
2584 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2585 {
2586 const u32 num16d = num / 16;
2587 const u32 num16m = num % 16;
2588
2589 if (num16d)
2590 {
2591 device_param->kernel_params_memset_buf32[1] = value;
2592 device_param->kernel_params_memset_buf32[2] = num16d;
2593
2594 uint kernel_threads = device_param->kernel_threads;
2595
2596 uint num_elements = num16d;
2597
2598 while (num_elements % kernel_threads) num_elements++;
2599
2600 cl_kernel kernel = device_param->kernel_memset;
2601
2602 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2603 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2604 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2605
2606 const size_t global_work_size[3] = { num_elements, 1, 1 };
2607 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2608
2609 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2610
2611 hc_clFlush (data.ocl, device_param->command_queue);
2612
2613 hc_clFinish (data.ocl, device_param->command_queue);
2614 }
2615
2616 if (num16m)
2617 {
2618 u32 tmp[4];
2619
2620 tmp[0] = value;
2621 tmp[1] = value;
2622 tmp[2] = value;
2623 tmp[3] = value;
2624
2625 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2626 }
2627 }
2628
2629 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2630 {
2631 run_kernel_memset (device_param, buf, 0, size);
2632
2633 /*
2634 int rc = -1;
2635
2636 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2637 {
2638 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2639
2640 const cl_uchar zero = 0;
2641
2642 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2643 }
2644
2645 if (rc != 0)
2646 {
2647 // NOTE: clEnqueueFillBuffer () always fails with -59
2648 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2649 // How's that possible, OpenCL 1.2 support is advertised??
2650 // We need to workaround...
2651
2652 #define FILLSZ 0x100000
2653
2654 char *tmp = (char *) mymalloc (FILLSZ);
2655
2656 for (size_t i = 0; i < size; i += FILLSZ)
2657 {
2658 const size_t left = size - i;
2659
2660 const size_t fillsz = MIN (FILLSZ, left);
2661
2662 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2663 }
2664
2665 myfree (tmp);
2666 }
2667 */
2668 }
2669
2670 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)
2671 {
2672 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2673 {
2674 if (attack_mode == ATTACK_MODE_BF)
2675 {
2676 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2677 {
2678 const uint size_tm = 32 * sizeof (bs_word_t);
2679
2680 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2681
2682 run_kernel_tm (device_param);
2683
2684 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);
2685 }
2686 }
2687
2688 if (highest_pw_len < 16)
2689 {
2690 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2691 }
2692 else if (highest_pw_len < 32)
2693 {
2694 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2695 }
2696 else
2697 {
2698 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2699 }
2700 }
2701 else
2702 {
2703 run_kernel_amp (device_param, pws_cnt);
2704
2705 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2706
2707 if (opts_type & OPTS_TYPE_HOOK12)
2708 {
2709 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2710 }
2711
2712 uint iter = salt_buf->salt_iter;
2713
2714 uint loop_step = device_param->kernel_loops;
2715
2716 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2717 {
2718 uint loop_left = iter - loop_pos;
2719
2720 loop_left = MIN (loop_left, loop_step);
2721
2722 device_param->kernel_params_buf32[25] = loop_pos;
2723 device_param->kernel_params_buf32[26] = loop_left;
2724
2725 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2726
2727 if (data.devices_status == STATUS_CRACKED) break;
2728 if (data.devices_status == STATUS_ABORTED) break;
2729 if (data.devices_status == STATUS_QUIT) break;
2730
2731 /**
2732 * speed
2733 */
2734
2735 const float iter_part = (float) (loop_pos + loop_left) / iter;
2736
2737 const u64 perf_sum_all = pws_cnt * iter_part;
2738
2739 double speed_ms;
2740
2741 hc_timer_get (device_param->timer_speed, speed_ms);
2742
2743 const u32 speed_pos = device_param->speed_pos;
2744
2745 device_param->speed_cnt[speed_pos] = perf_sum_all;
2746
2747 device_param->speed_ms[speed_pos] = speed_ms;
2748
2749 if (data.benchmark == 1)
2750 {
2751 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2752 }
2753 }
2754
2755 if (opts_type & OPTS_TYPE_HOOK23)
2756 {
2757 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2758
2759 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);
2760
2761 // do something with data
2762
2763 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);
2764 }
2765
2766 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2767 }
2768 }
2769
2770 static int run_rule_engine (const int rule_len, const char *rule_buf)
2771 {
2772 if (rule_len == 0)
2773 {
2774 return 0;
2775 }
2776 else if (rule_len == 1)
2777 {
2778 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2779 }
2780
2781 return 1;
2782 }
2783
2784 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2785 {
2786 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2787 {
2788 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);
2789 }
2790 else if (data.attack_kern == ATTACK_KERN_COMBI)
2791 {
2792 if (data.attack_mode == ATTACK_MODE_COMBI)
2793 {
2794 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2795 {
2796 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2797 {
2798 for (u32 i = 0; i < pws_cnt; i++)
2799 {
2800 const u32 pw_len = device_param->pws_buf[i].pw_len;
2801
2802 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2803
2804 ptr[pw_len] = 0x01;
2805 }
2806 }
2807 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2808 {
2809 for (u32 i = 0; i < pws_cnt; i++)
2810 {
2811 const u32 pw_len = device_param->pws_buf[i].pw_len;
2812
2813 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2814
2815 ptr[pw_len] = 0x80;
2816 }
2817 }
2818 }
2819 }
2820 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2821 {
2822 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2823 {
2824 for (u32 i = 0; i < pws_cnt; i++)
2825 {
2826 const u32 pw_len = device_param->pws_buf[i].pw_len;
2827
2828 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2829
2830 ptr[pw_len] = 0x01;
2831 }
2832 }
2833 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2834 {
2835 for (u32 i = 0; i < pws_cnt; i++)
2836 {
2837 const u32 pw_len = device_param->pws_buf[i].pw_len;
2838
2839 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2840
2841 ptr[pw_len] = 0x80;
2842 }
2843 }
2844 }
2845
2846 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);
2847 }
2848 else if (data.attack_kern == ATTACK_KERN_BF)
2849 {
2850 const u64 off = device_param->words_off;
2851
2852 device_param->kernel_params_mp_l_buf64[3] = off;
2853
2854 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2855 }
2856 }
2857
2858 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2859 {
2860 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2861
2862 device_param->kernel_params_buf32[25] = 0;
2863 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2864 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2865
2866 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2867 {
2868 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2869 }
2870 else
2871 {
2872 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2873 }
2874
2875 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2876
2877 return exec_ms_prev;
2878 }
2879
2880 static void autotune (hc_device_param_t *device_param)
2881 {
2882 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2883
2884 const u32 kernel_accel_min = device_param->kernel_accel_min;
2885 const u32 kernel_accel_max = device_param->kernel_accel_max;
2886
2887 const u32 kernel_loops_min = device_param->kernel_loops_min;
2888 const u32 kernel_loops_max = device_param->kernel_loops_max;
2889
2890 u32 kernel_accel = kernel_accel_min;
2891 u32 kernel_loops = kernel_loops_min;
2892
2893 // in this case the user specified a fixed -u and -n on the commandline
2894 // no way to tune anything
2895 // but we need to run a few caching rounds
2896
2897 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2898 {
2899 try_run (device_param, kernel_accel, kernel_loops);
2900 try_run (device_param, kernel_accel, kernel_loops);
2901 try_run (device_param, kernel_accel, kernel_loops);
2902 try_run (device_param, kernel_accel, kernel_loops);
2903
2904 device_param->kernel_accel = kernel_accel;
2905 device_param->kernel_loops = kernel_loops;
2906
2907 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2908
2909 device_param->kernel_power = kernel_power;
2910
2911 return;
2912 }
2913
2914 // from here it's clear we are allowed to autotune
2915 // so let's init some fake words
2916
2917 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2918
2919 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2920
2921 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2922 {
2923 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 7, kernel_power_max * sizeof (pw_t));
2924 }
2925
2926 /*
2927 for (u32 i = 0; i < kernel_power_max; i++)
2928 {
2929 device_param->pws_buf[i].i[0] = i;
2930 device_param->pws_buf[i].i[1] = 0x01234567;
2931 device_param->pws_buf[i].pw_len = 7;
2932 }
2933
2934 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);
2935
2936 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2937 {
2938 run_kernel_amp (device_param, kernel_power_max);
2939 }
2940 */
2941
2942 #define VERIFIER_CNT 1
2943
2944 // first find out highest kernel-loops that stays below target_ms
2945
2946 if (kernel_loops_min < kernel_loops_max)
2947 {
2948 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2949 {
2950 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2951
2952 for (int i = 0; i < VERIFIER_CNT; i++)
2953 {
2954 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2955
2956 exec_ms = MIN (exec_ms, exec_ms_v);
2957 }
2958
2959 if (exec_ms < target_ms) break;
2960 }
2961 }
2962
2963 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2964
2965 #define STEPS_CNT 10
2966
2967 if (kernel_accel_min < kernel_accel_max)
2968 {
2969 for (int i = 0; i < STEPS_CNT; i++)
2970 {
2971 const u32 kernel_accel_try = 1 << i;
2972
2973 if (kernel_accel_try < kernel_accel_min) continue;
2974 if (kernel_accel_try > kernel_accel_max) break;
2975
2976 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2977
2978 for (int i = 0; i < VERIFIER_CNT; i++)
2979 {
2980 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
2981
2982 exec_ms = MIN (exec_ms, exec_ms_v);
2983 }
2984
2985 if (exec_ms > target_ms) break;
2986
2987 kernel_accel = kernel_accel_try;
2988 }
2989 }
2990
2991 // at this point we want to know the actual runtime for the following reason:
2992 // we need a reference for the balancing loop following up, and this
2993 // the balancing loop can have an effect that the creates a new opportunity, for example:
2994 // if the target is 95 ms and the current runtime is 48ms the above loop
2995 // stopped the execution because the previous exec_ms was > 95ms
2996 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
2997 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
2998
2999 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3000
3001 for (int i = 0; i < VERIFIER_CNT; i++)
3002 {
3003 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3004
3005 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3006 }
3007
3008 u32 diff = kernel_loops - kernel_accel;
3009
3010 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3011 {
3012 u32 kernel_accel_orig = kernel_accel;
3013 u32 kernel_loops_orig = kernel_loops;
3014
3015 for (u32 f = 1; f < 1024; f++)
3016 {
3017 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3018 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3019
3020 if (kernel_accel_try > kernel_accel_max) break;
3021 if (kernel_loops_try < kernel_loops_min) break;
3022
3023 u32 diff_new = kernel_loops_try - kernel_accel_try;
3024
3025 if (diff_new > diff) break;
3026
3027 diff_new = diff;
3028
3029 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3030
3031 for (int i = 0; i < VERIFIER_CNT; i++)
3032 {
3033 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3034
3035 exec_ms = MIN (exec_ms, exec_ms_v);
3036 }
3037
3038 if (exec_ms < exec_ms_pre_final)
3039 {
3040 exec_ms_pre_final = exec_ms;
3041
3042 kernel_accel = kernel_accel_try;
3043 kernel_loops = kernel_loops_try;
3044 }
3045 }
3046 }
3047
3048 const double exec_left = target_ms / exec_ms_pre_final;
3049
3050 const double accel_left = kernel_accel_max / kernel_accel;
3051
3052 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3053
3054 if (exec_accel_min >= 1.0)
3055 {
3056 // this is safe to not overflow kernel_accel_max because of accel_left
3057
3058 kernel_accel = (double) kernel_accel * exec_accel_min;
3059 }
3060
3061 // reset them fake words
3062
3063 /*
3064 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3065
3066 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);
3067 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);
3068 */
3069
3070 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3071
3072 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3073 {
3074 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3075 }
3076
3077 // reset timer
3078
3079 device_param->exec_pos = 0;
3080
3081 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3082
3083 // store
3084
3085 device_param->kernel_accel = kernel_accel;
3086 device_param->kernel_loops = kernel_loops;
3087
3088 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3089
3090 device_param->kernel_power = kernel_power;
3091
3092 #ifdef DEBUG
3093
3094 if (data.quiet == 0)
3095 {
3096 clear_prompt ();
3097
3098 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3099 "Device #%u: autotuned kernel-loops to %u\n",
3100 device_param->device_id + 1, kernel_accel,
3101 device_param->device_id + 1, kernel_loops);
3102
3103 fprintf (stdout, "%s", PROMPT);
3104
3105 fflush (stdout);
3106 }
3107
3108 #endif
3109 }
3110
3111 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3112 {
3113 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3114
3115 // init speed timer
3116
3117 uint speed_pos = device_param->speed_pos;
3118
3119 #ifdef _POSIX
3120 if (device_param->timer_speed.tv_sec == 0)
3121 {
3122 hc_timer_set (&device_param->timer_speed);
3123 }
3124 #endif
3125
3126 #ifdef _WIN
3127 if (device_param->timer_speed.QuadPart == 0)
3128 {
3129 hc_timer_set (&device_param->timer_speed);
3130 }
3131 #endif
3132
3133 // find higest password length, this is for optimization stuff
3134
3135 uint highest_pw_len = 0;
3136
3137 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3138 {
3139 }
3140 else if (data.attack_kern == ATTACK_KERN_COMBI)
3141 {
3142 }
3143 else if (data.attack_kern == ATTACK_KERN_BF)
3144 {
3145 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3146 + device_param->kernel_params_mp_l_buf32[5];
3147 }
3148
3149 // iteration type
3150
3151 uint innerloop_step = 0;
3152 uint innerloop_cnt = 0;
3153
3154 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3155 else innerloop_step = 1;
3156
3157 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3158 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3159 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3160
3161 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3162
3163 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3164 {
3165 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3166
3167 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3168
3169 if (data.devices_status == STATUS_CRACKED) break;
3170 if (data.devices_status == STATUS_ABORTED) break;
3171 if (data.devices_status == STATUS_QUIT) break;
3172 if (data.devices_status == STATUS_BYPASS) break;
3173
3174 salt_t *salt_buf = &data.salts_buf[salt_pos];
3175
3176 device_param->kernel_params_buf32[24] = salt_pos;
3177 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3178 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3179
3180 FILE *combs_fp = device_param->combs_fp;
3181
3182 if (data.attack_mode == ATTACK_MODE_COMBI)
3183 {
3184 rewind (combs_fp);
3185 }
3186
3187 // innerloops
3188
3189 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3190 {
3191 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3192
3193 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3194
3195 if (data.devices_status == STATUS_CRACKED) break;
3196 if (data.devices_status == STATUS_ABORTED) break;
3197 if (data.devices_status == STATUS_QUIT) break;
3198 if (data.devices_status == STATUS_BYPASS) break;
3199
3200 uint innerloop_left = innerloop_cnt - innerloop_pos;
3201
3202 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3203
3204 device_param->innerloop_pos = innerloop_pos;
3205 device_param->innerloop_left = innerloop_left;
3206
3207 device_param->kernel_params_buf32[27] = innerloop_left;
3208
3209 // i think we can get rid of this
3210 if (innerloop_left == 0)
3211 {
3212 puts ("bug, how should this happen????\n");
3213
3214 continue;
3215 }
3216
3217 if (data.salts_shown[salt_pos] == 1)
3218 {
3219 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3220
3221 continue;
3222 }
3223
3224 // initialize amplifiers
3225
3226 if (data.attack_mode == ATTACK_MODE_COMBI)
3227 {
3228 uint i = 0;
3229
3230 while (i < innerloop_left)
3231 {
3232 if (feof (combs_fp)) break;
3233
3234 int line_len = fgetl (combs_fp, line_buf);
3235
3236 if (line_len >= PW_MAX1) continue;
3237
3238 line_len = convert_from_hex (line_buf, line_len);
3239
3240 char *line_buf_new = line_buf;
3241
3242 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3243 {
3244 char rule_buf_out[BLOCK_SIZE] = { 0 };
3245
3246 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3247
3248 if (rule_len_out < 0)
3249 {
3250 data.words_progress_rejected[salt_pos] += pws_cnt;
3251
3252 continue;
3253 }
3254
3255 line_len = rule_len_out;
3256
3257 line_buf_new = rule_buf_out;
3258 }
3259
3260 line_len = MIN (line_len, PW_DICTMAX);
3261
3262 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3263
3264 memcpy (ptr, line_buf_new, line_len);
3265
3266 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3267
3268 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3269 {
3270 uppercase (ptr, line_len);
3271 }
3272
3273 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3274 {
3275 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3276 {
3277 ptr[line_len] = 0x80;
3278 }
3279
3280 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3281 {
3282 ptr[line_len] = 0x01;
3283 }
3284 }
3285
3286 device_param->combs_buf[i].pw_len = line_len;
3287
3288 i++;
3289 }
3290
3291 for (uint j = i; j < innerloop_left; j++)
3292 {
3293 device_param->combs_buf[j].i[0] = 0;
3294 device_param->combs_buf[j].i[1] = 0;
3295 device_param->combs_buf[j].i[2] = 0;
3296 device_param->combs_buf[j].i[3] = 0;
3297 device_param->combs_buf[j].i[4] = 0;
3298 device_param->combs_buf[j].i[5] = 0;
3299 device_param->combs_buf[j].i[6] = 0;
3300 device_param->combs_buf[j].i[7] = 0;
3301
3302 device_param->combs_buf[j].pw_len = 0;
3303 }
3304
3305 innerloop_left = i;
3306 }
3307 else if (data.attack_mode == ATTACK_MODE_BF)
3308 {
3309 u64 off = innerloop_pos;
3310
3311 device_param->kernel_params_mp_r_buf64[3] = off;
3312
3313 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3314 }
3315 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3316 {
3317 u64 off = innerloop_pos;
3318
3319 device_param->kernel_params_mp_buf64[3] = off;
3320
3321 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3322 }
3323 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3324 {
3325 u64 off = innerloop_pos;
3326
3327 device_param->kernel_params_mp_buf64[3] = off;
3328
3329 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3330 }
3331
3332 // copy amplifiers
3333
3334 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3335 {
3336 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);
3337 }
3338 else if (data.attack_mode == ATTACK_MODE_COMBI)
3339 {
3340 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);
3341 }
3342 else if (data.attack_mode == ATTACK_MODE_BF)
3343 {
3344 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);
3345 }
3346 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3347 {
3348 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);
3349 }
3350 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3351 {
3352 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);
3353 }
3354
3355 if (data.benchmark == 1)
3356 {
3357 hc_timer_set (&device_param->timer_speed);
3358 }
3359
3360 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3361
3362 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3363
3364 if (data.devices_status == STATUS_CRACKED) break;
3365 if (data.devices_status == STATUS_ABORTED) break;
3366 if (data.devices_status == STATUS_QUIT) break;
3367
3368 /**
3369 * result
3370 */
3371
3372 check_cracked (device_param, salt_pos);
3373
3374 /**
3375 * progress
3376 */
3377
3378 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3379
3380 hc_thread_mutex_lock (mux_counter);
3381
3382 data.words_progress_done[salt_pos] += perf_sum_all;
3383
3384 hc_thread_mutex_unlock (mux_counter);
3385
3386 /**
3387 * speed
3388 */
3389
3390 double speed_ms;
3391
3392 hc_timer_get (device_param->timer_speed, speed_ms);
3393
3394 hc_timer_set (&device_param->timer_speed);
3395
3396 // current speed
3397
3398 //hc_thread_mutex_lock (mux_display);
3399
3400 device_param->speed_cnt[speed_pos] = perf_sum_all;
3401
3402 device_param->speed_ms[speed_pos] = speed_ms;
3403
3404 //hc_thread_mutex_unlock (mux_display);
3405
3406 speed_pos++;
3407
3408 if (speed_pos == SPEED_CACHE)
3409 {
3410 speed_pos = 0;
3411 }
3412
3413 /**
3414 * benchmark
3415 */
3416
3417 if (data.benchmark == 1) break;
3418 }
3419 }
3420
3421 device_param->speed_pos = speed_pos;
3422
3423 myfree (line_buf);
3424 }
3425
3426 static void load_segment (wl_data_t *wl_data, FILE *fd)
3427 {
3428 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3429
3430 wl_data->pos = 0;
3431
3432 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3433
3434 wl_data->buf[wl_data->cnt] = 0;
3435
3436 if (wl_data->cnt == 0) return;
3437
3438 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3439
3440 while (!feof (fd))
3441 {
3442 if (wl_data->cnt == wl_data->avail)
3443 {
3444 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3445
3446 wl_data->avail += wl_data->incr;
3447 }
3448
3449 const int c = fgetc (fd);
3450
3451 if (c == EOF) break;
3452
3453 wl_data->buf[wl_data->cnt] = (char) c;
3454
3455 wl_data->cnt++;
3456
3457 if (c == '\n') break;
3458 }
3459
3460 // ensure stream ends with a newline
3461
3462 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3463 {
3464 wl_data->cnt++;
3465
3466 wl_data->buf[wl_data->cnt - 1] = '\n';
3467 }
3468
3469 return;
3470 }
3471
3472 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3473 {
3474 char *ptr = buf;
3475
3476 for (u32 i = 0; i < sz; i++, ptr++)
3477 {
3478 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3479
3480 if (i == 7)
3481 {
3482 *off = i;
3483 *len = i;
3484
3485 return;
3486 }
3487
3488 if (*ptr != '\n') continue;
3489
3490 *off = i + 1;
3491
3492 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3493
3494 *len = i;
3495
3496 return;
3497 }
3498
3499 *off = sz;
3500 *len = sz;
3501 }
3502
3503 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3504 {
3505 char *ptr = buf;
3506
3507 for (u32 i = 0; i < sz; i++, ptr++)
3508 {
3509 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3510
3511 if (*ptr != '\n') continue;
3512
3513 *off = i + 1;
3514
3515 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3516
3517 *len = i;
3518
3519 return;
3520 }
3521
3522 *off = sz;
3523 *len = sz;
3524 }
3525
3526 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3527 {
3528 char *ptr = buf;
3529
3530 for (u32 i = 0; i < sz; i++, ptr++)
3531 {
3532 if (*ptr != '\n') continue;
3533
3534 *off = i + 1;
3535
3536 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3537
3538 *len = i;
3539
3540 return;
3541 }
3542
3543 *off = sz;
3544 *len = sz;
3545 }
3546
3547 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3548 {
3549 while (wl_data->pos < wl_data->cnt)
3550 {
3551 uint off;
3552 uint len;
3553
3554 char *ptr = wl_data->buf + wl_data->pos;
3555
3556 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3557
3558 wl_data->pos += off;
3559
3560 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3561 {
3562 char rule_buf_out[BLOCK_SIZE] = { 0 };
3563
3564 int rule_len_out = -1;
3565
3566 if (len < BLOCK_SIZE)
3567 {
3568 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3569 }
3570
3571 if (rule_len_out < 0)
3572 {
3573 continue;
3574 }
3575
3576 if (rule_len_out > PW_MAX)
3577 {
3578 continue;
3579 }
3580 }
3581 else
3582 {
3583 if (len > PW_MAX)
3584 {
3585 continue;
3586 }
3587 }
3588
3589 *out_buf = ptr;
3590 *out_len = len;
3591
3592 return;
3593 }
3594
3595 if (feof (fd))
3596 {
3597 fprintf (stderr, "BUG feof()!!\n");
3598
3599 return;
3600 }
3601
3602 load_segment (wl_data, fd);
3603
3604 get_next_word (wl_data, fd, out_buf, out_len);
3605 }
3606
3607 #ifdef _POSIX
3608 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3609 #endif
3610
3611 #ifdef _WIN
3612 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3613 #endif
3614 {
3615 hc_signal (NULL);
3616
3617 dictstat_t d;
3618
3619 d.cnt = 0;
3620
3621 #ifdef _POSIX
3622 fstat (fileno (fd), &d.stat);
3623 #endif
3624
3625 #ifdef _WIN
3626 _fstat64 (fileno (fd), &d.stat);
3627 #endif
3628
3629 d.stat.st_mode = 0;
3630 d.stat.st_nlink = 0;
3631 d.stat.st_uid = 0;
3632 d.stat.st_gid = 0;
3633 d.stat.st_rdev = 0;
3634 d.stat.st_atime = 0;
3635
3636 #ifdef _POSIX
3637 d.stat.st_blksize = 0;
3638 d.stat.st_blocks = 0;
3639 #endif
3640
3641 if (d.stat.st_size == 0) return 0;
3642
3643 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3644
3645 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3646 {
3647 if (d_cache)
3648 {
3649 u64 cnt = d_cache->cnt;
3650
3651 u64 keyspace = cnt;
3652
3653 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3654 {
3655 keyspace *= data.kernel_rules_cnt;
3656 }
3657 else if (data.attack_kern == ATTACK_KERN_COMBI)
3658 {
3659 keyspace *= data.combs_cnt;
3660 }
3661
3662 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);
3663 if (data.quiet == 0) log_info ("");
3664
3665 hc_signal (sigHandler_default);
3666
3667 return (keyspace);
3668 }
3669 }
3670
3671 time_t now = 0;
3672 time_t prev = 0;
3673
3674 u64 comp = 0;
3675 u64 cnt = 0;
3676 u64 cnt2 = 0;
3677
3678 while (!feof (fd))
3679 {
3680 load_segment (wl_data, fd);
3681
3682 comp += wl_data->cnt;
3683
3684 u32 i = 0;
3685
3686 while (i < wl_data->cnt)
3687 {
3688 u32 len;
3689 u32 off;
3690
3691 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3692
3693 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3694 {
3695 char rule_buf_out[BLOCK_SIZE] = { 0 };
3696
3697 int rule_len_out = -1;
3698
3699 if (len < BLOCK_SIZE)
3700 {
3701 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3702 }
3703
3704 if (rule_len_out < 0)
3705 {
3706 len = PW_MAX1;
3707 }
3708 else
3709 {
3710 len = rule_len_out;
3711 }
3712 }
3713
3714 if (len < PW_MAX1)
3715 {
3716 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3717 {
3718 cnt += data.kernel_rules_cnt;
3719 }
3720 else if (data.attack_kern == ATTACK_KERN_COMBI)
3721 {
3722 cnt += data.combs_cnt;
3723 }
3724
3725 d.cnt++;
3726 }
3727
3728 i += off;
3729
3730 cnt2++;
3731 }
3732
3733 time (&now);
3734
3735 if ((now - prev) == 0) continue;
3736
3737 float percent = (float) comp / (float) d.stat.st_size;
3738
3739 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);
3740
3741 time (&prev);
3742 }
3743
3744 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);
3745 if (data.quiet == 0) log_info ("");
3746
3747 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3748
3749 hc_signal (sigHandler_default);
3750
3751 return (cnt);
3752 }
3753
3754 static void *thread_monitor (void *p)
3755 {
3756 uint runtime_check = 0;
3757 uint remove_check = 0;
3758 uint status_check = 0;
3759 uint restore_check = 0;
3760
3761 uint restore_left = data.restore_timer;
3762 uint remove_left = data.remove_timer;
3763 uint status_left = data.status_timer;
3764
3765 #ifdef HAVE_HWMON
3766 uint hwmon_check = 0;
3767
3768 int slowdown_warnings = 0;
3769
3770 // these variables are mainly used for fan control (AMD only)
3771
3772 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3773
3774 // temperature controller "loopback" values
3775
3776 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3777 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3778
3779 #ifdef HAVE_ADL
3780 int temp_threshold = 1; // degrees celcius
3781
3782 int fan_speed_min = 15; // in percentage
3783 int fan_speed_max = 100;
3784 #endif // HAVE_ADL
3785
3786 time_t last_temp_check_time;
3787 #endif // HAVE_HWMON
3788
3789 uint sleep_time = 1;
3790
3791 if (data.runtime)
3792 {
3793 runtime_check = 1;
3794 }
3795
3796 if (data.restore_timer)
3797 {
3798 restore_check = 1;
3799 }
3800
3801 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3802 {
3803 remove_check = 1;
3804 }
3805
3806 if (data.status == 1)
3807 {
3808 status_check = 1;
3809 }
3810
3811 #ifdef HAVE_HWMON
3812 if (data.gpu_temp_disable == 0)
3813 {
3814 time (&last_temp_check_time);
3815
3816 hwmon_check = 1;
3817 }
3818 #endif
3819
3820 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3821 {
3822 #ifdef HAVE_HWMON
3823 if (hwmon_check == 0)
3824 #endif
3825 return (p);
3826 }
3827
3828 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3829 {
3830 hc_sleep (sleep_time);
3831
3832 if (data.devices_status != STATUS_RUNNING) continue;
3833
3834 #ifdef HAVE_HWMON
3835
3836 if (1)
3837 {
3838 hc_thread_mutex_lock (mux_adl);
3839
3840 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3841 {
3842 hc_device_param_t *device_param = &data.devices_param[device_id];
3843
3844 if (device_param->skipped) continue;
3845
3846 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3847
3848 const int temperature = hm_get_temperature_with_device_id (device_id);
3849
3850 const int threshold = data.hm_device[device_id].gpu_temp_threshold_slowdown;
3851
3852 if (temperature >= threshold)
3853 {
3854 if (slowdown_warnings < 3)
3855 {
3856 if (data.quiet == 0) clear_prompt ();
3857
3858 log_info ("WARNING: Drivers temperature threshold (%dc) hit on GPU #%d, expect performance to drop...", threshold, device_id + 1);
3859
3860 if (slowdown_warnings == 2)
3861 {
3862 log_info ("");
3863 }
3864
3865 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3866 if (data.quiet == 0) fflush (stdout);
3867
3868 slowdown_warnings++;
3869 }
3870 }
3871 else
3872 {
3873 slowdown_warnings = 0;
3874 }
3875 }
3876
3877 hc_thread_mutex_unlock (mux_adl);
3878 }
3879
3880 if (hwmon_check == 1)
3881 {
3882 hc_thread_mutex_lock (mux_adl);
3883
3884 time_t temp_check_time;
3885
3886 time (&temp_check_time);
3887
3888 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3889
3890 if (Ta == 0) Ta = 1;
3891
3892 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3893 {
3894 hc_device_param_t *device_param = &data.devices_param[device_id];
3895
3896 if (device_param->skipped) continue;
3897
3898 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3899
3900 const int temperature = hm_get_temperature_with_device_id (device_id);
3901
3902 if (temperature > (int) data.gpu_temp_abort)
3903 {
3904 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3905
3906 if (data.devices_status != STATUS_QUIT) myabort ();
3907
3908 break;
3909 }
3910
3911 #ifdef HAVE_ADL
3912 const int gpu_temp_retain = data.gpu_temp_retain;
3913
3914 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3915 {
3916 if (data.hm_device[device_id].fan_supported == 1)
3917 {
3918 int temp_cur = temperature;
3919
3920 int temp_diff_new = gpu_temp_retain - temp_cur;
3921
3922 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3923
3924 // calculate Ta value (time difference in seconds between the last check and this check)
3925
3926 last_temp_check_time = temp_check_time;
3927
3928 float Kp = 1.8;
3929 float Ki = 0.005;
3930 float Kd = 6;
3931
3932 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3933
3934 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);
3935
3936 if (abs (fan_diff_required) >= temp_threshold)
3937 {
3938 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3939
3940 int fan_speed_level = fan_speed_cur;
3941
3942 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3943
3944 int fan_speed_new = fan_speed_level - fan_diff_required;
3945
3946 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3947 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3948
3949 if (fan_speed_new != fan_speed_cur)
3950 {
3951 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3952 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3953
3954 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3955 {
3956 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3957
3958 fan_speed_chgd[device_id] = 1;
3959 }
3960
3961 temp_diff_old[device_id] = temp_diff_new;
3962 }
3963 }
3964 }
3965 }
3966 #endif // HAVE_ADL
3967 }
3968
3969 hc_thread_mutex_unlock (mux_adl);
3970 }
3971 #endif // HAVE_HWMON
3972
3973 if (restore_check == 1)
3974 {
3975 restore_left--;
3976
3977 if (restore_left == 0)
3978 {
3979 if (data.restore_disable == 0) cycle_restore ();
3980
3981 restore_left = data.restore_timer;
3982 }
3983 }
3984
3985 if ((runtime_check == 1) && (data.runtime_start > 0))
3986 {
3987 time_t runtime_cur;
3988
3989 time (&runtime_cur);
3990
3991 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3992
3993 if (runtime_left <= 0)
3994 {
3995 if (data.benchmark == 0)
3996 {
3997 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3998 }
3999
4000 if (data.devices_status != STATUS_QUIT) myabort ();
4001 }
4002 }
4003
4004 if (remove_check == 1)
4005 {
4006 remove_left--;
4007
4008 if (remove_left == 0)
4009 {
4010 if (data.digests_saved != data.digests_done)
4011 {
4012 data.digests_saved = data.digests_done;
4013
4014 save_hash ();
4015 }
4016
4017 remove_left = data.remove_timer;
4018 }
4019 }
4020
4021 if (status_check == 1)
4022 {
4023 status_left--;
4024
4025 if (status_left == 0)
4026 {
4027 //hc_thread_mutex_lock (mux_display);
4028
4029 if (data.quiet == 0) clear_prompt ();
4030
4031 if (data.quiet == 0) log_info ("");
4032
4033 status_display ();
4034
4035 if (data.quiet == 0) log_info ("");
4036
4037 //hc_thread_mutex_unlock (mux_display);
4038
4039 status_left = data.status_timer;
4040 }
4041 }
4042 }
4043
4044 #ifdef HAVE_HWMON
4045 myfree (fan_speed_chgd);
4046
4047 myfree (temp_diff_old);
4048 myfree (temp_diff_sum);
4049 #endif
4050
4051 p = NULL;
4052
4053 return (p);
4054 }
4055
4056 static void *thread_outfile_remove (void *p)
4057 {
4058 // some hash-dependent constants
4059 char *outfile_dir = data.outfile_check_directory;
4060 uint dgst_size = data.dgst_size;
4061 uint isSalted = data.isSalted;
4062 uint esalt_size = data.esalt_size;
4063 uint hash_mode = data.hash_mode;
4064
4065 uint outfile_check_timer = data.outfile_check_timer;
4066
4067 char separator = data.separator;
4068
4069 // some hash-dependent functions
4070 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4071 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4072
4073 // buffers
4074 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4075
4076 hash_buf.digest = mymalloc (dgst_size);
4077
4078 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4079
4080 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4081
4082 uint digest_buf[64] = { 0 };
4083
4084 outfile_data_t *out_info = NULL;
4085
4086 char **out_files = NULL;
4087
4088 time_t folder_mtime = 0;
4089
4090 int out_cnt = 0;
4091
4092 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4093
4094 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4095 {
4096 hc_sleep (1);
4097
4098 if (data.devices_status != STATUS_RUNNING) continue;
4099
4100 check_left--;
4101
4102 if (check_left == 0)
4103 {
4104 struct stat outfile_check_stat;
4105
4106 if (stat (outfile_dir, &outfile_check_stat) == 0)
4107 {
4108 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4109
4110 if (is_dir == 1)
4111 {
4112 if (outfile_check_stat.st_mtime > folder_mtime)
4113 {
4114 char **out_files_new = scan_directory (outfile_dir);
4115
4116 int out_cnt_new = count_dictionaries (out_files_new);
4117
4118 outfile_data_t *out_info_new = NULL;
4119
4120 if (out_cnt_new > 0)
4121 {
4122 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4123
4124 for (int i = 0; i < out_cnt_new; i++)
4125 {
4126 out_info_new[i].file_name = out_files_new[i];
4127
4128 // check if there are files that we have seen/checked before (and not changed)
4129
4130 for (int j = 0; j < out_cnt; j++)
4131 {
4132 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4133 {
4134 struct stat outfile_stat;
4135
4136 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4137 {
4138 if (outfile_stat.st_ctime == out_info[j].ctime)
4139 {
4140 out_info_new[i].ctime = out_info[j].ctime;
4141 out_info_new[i].seek = out_info[j].seek;
4142 }
4143 }
4144 }
4145 }
4146 }
4147 }
4148
4149 local_free (out_info);
4150 local_free (out_files);
4151
4152 out_files = out_files_new;
4153 out_cnt = out_cnt_new;
4154 out_info = out_info_new;
4155
4156 folder_mtime = outfile_check_stat.st_mtime;
4157 }
4158
4159 for (int j = 0; j < out_cnt; j++)
4160 {
4161 FILE *fp = fopen (out_info[j].file_name, "rb");
4162
4163 if (fp != NULL)
4164 {
4165 //hc_thread_mutex_lock (mux_display);
4166
4167 #ifdef _POSIX
4168 struct stat outfile_stat;
4169
4170 fstat (fileno (fp), &outfile_stat);
4171 #endif
4172
4173 #ifdef _WIN
4174 struct stat64 outfile_stat;
4175
4176 _fstat64 (fileno (fp), &outfile_stat);
4177 #endif
4178
4179 if (outfile_stat.st_ctime > out_info[j].ctime)
4180 {
4181 out_info[j].ctime = outfile_stat.st_ctime;
4182 out_info[j].seek = 0;
4183 }
4184
4185 fseek (fp, out_info[j].seek, SEEK_SET);
4186
4187 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4188
4189 while (!feof (fp))
4190 {
4191 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4192
4193 if (ptr == NULL) break;
4194
4195 int line_len = strlen (line_buf);
4196
4197 if (line_len <= 0) continue;
4198
4199 int iter = MAX_CUT_TRIES;
4200
4201 for (uint i = line_len - 1; i && iter; i--, line_len--)
4202 {
4203 if (line_buf[i] != separator) continue;
4204
4205 int parser_status = PARSER_OK;
4206
4207 if ((hash_mode != 2500) && (hash_mode != 6800))
4208 {
4209 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4210 }
4211
4212 uint found = 0;
4213
4214 if (parser_status == PARSER_OK)
4215 {
4216 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4217 {
4218 if (data.salts_shown[salt_pos] == 1) continue;
4219
4220 salt_t *salt_buf = &data.salts_buf[salt_pos];
4221
4222 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4223 {
4224 uint idx = salt_buf->digests_offset + digest_pos;
4225
4226 if (data.digests_shown[idx] == 1) continue;
4227
4228 uint cracked = 0;
4229
4230 if (hash_mode == 6800)
4231 {
4232 if (i == salt_buf->salt_len)
4233 {
4234 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4235 }
4236 }
4237 else if (hash_mode == 2500)
4238 {
4239 // BSSID : MAC1 : MAC2 (:plain)
4240 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4241 {
4242 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4243
4244 if (!cracked) continue;
4245
4246 // now compare MAC1 and MAC2 too, since we have this additional info
4247 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4248 char *mac2_pos = mac1_pos + 12 + 1;
4249
4250 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4251 wpa_t *wpa = &wpas[salt_pos];
4252
4253 // compare hex string(s) vs binary MAC address(es)
4254
4255 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4256 {
4257 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4258 {
4259 cracked = 0;
4260
4261 break;
4262 }
4263 }
4264
4265 // early skip ;)
4266 if (!cracked) continue;
4267
4268 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4269 {
4270 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4271 {
4272 cracked = 0;
4273
4274 break;
4275 }
4276 }
4277 }
4278 }
4279 else
4280 {
4281 char *digests_buf_ptr = (char *) data.digests_buf;
4282
4283 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4284
4285 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4286 }
4287
4288 if (cracked == 1)
4289 {
4290 found = 1;
4291
4292 data.digests_shown[idx] = 1;
4293
4294 data.digests_done++;
4295
4296 salt_buf->digests_done++;
4297
4298 if (salt_buf->digests_done == salt_buf->digests_cnt)
4299 {
4300 data.salts_shown[salt_pos] = 1;
4301
4302 data.salts_done++;
4303
4304 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4305 }
4306 }
4307 }
4308
4309 if (data.devices_status == STATUS_CRACKED) break;
4310 }
4311 }
4312
4313 if (found) break;
4314
4315 if (data.devices_status == STATUS_CRACKED) break;
4316
4317 iter--;
4318 }
4319
4320 if (data.devices_status == STATUS_CRACKED) break;
4321 }
4322
4323 myfree (line_buf);
4324
4325 out_info[j].seek = ftell (fp);
4326
4327 //hc_thread_mutex_unlock (mux_display);
4328
4329 fclose (fp);
4330 }
4331 }
4332 }
4333 }
4334
4335 check_left = outfile_check_timer;
4336 }
4337 }
4338
4339 if (esalt_size) local_free (hash_buf.esalt);
4340
4341 if (isSalted) local_free (hash_buf.salt);
4342
4343 local_free (hash_buf.digest);
4344
4345 local_free (out_info);
4346
4347 local_free (out_files);
4348
4349 p = NULL;
4350
4351 return (p);
4352 }
4353
4354 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4355 {
4356 if (device_param->pws_cnt < device_param->kernel_power)
4357 {
4358 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4359
4360 u8 *ptr = (u8 *) pw->i;
4361
4362 memcpy (ptr, pw_buf, pw_len);
4363
4364 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4365
4366 pw->pw_len = pw_len;
4367
4368 device_param->pws_cnt++;
4369 }
4370 else
4371 {
4372 fprintf (stderr, "BUG pw_add()!!\n");
4373
4374 return;
4375 }
4376 }
4377
4378 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4379 {
4380 hc_thread_mutex_lock (mux_dispatcher);
4381
4382 const u64 words_cur = data.words_cur;
4383 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4384
4385 device_param->words_off = words_cur;
4386
4387 const u64 words_left = words_base - words_cur;
4388
4389 if (allow_div)
4390 {
4391 if (data.kernel_power_all > words_left)
4392 {
4393 if (data.kernel_power_div == 0)
4394 {
4395 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4396 }
4397 }
4398
4399 if (data.kernel_power_div)
4400 {
4401 if (device_param->kernel_power == device_param->kernel_power_user)
4402 {
4403 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4404
4405 if (kernel_power_new < device_param->kernel_power)
4406 {
4407 device_param->kernel_power = kernel_power_new;
4408 }
4409 }
4410 }
4411 }
4412
4413 const uint kernel_power = device_param->kernel_power;
4414
4415 uint work = MIN (words_left, kernel_power);
4416
4417 work = MIN (work, max);
4418
4419 data.words_cur += work;
4420
4421 hc_thread_mutex_unlock (mux_dispatcher);
4422
4423 return work;
4424 }
4425
4426 static void *thread_calc_stdin (void *p)
4427 {
4428 hc_device_param_t *device_param = (hc_device_param_t *) p;
4429
4430 if (device_param->skipped) return NULL;
4431
4432 autotune (device_param);
4433
4434 char *buf = (char *) mymalloc (HCBUFSIZ);
4435
4436 const uint attack_kern = data.attack_kern;
4437
4438 const uint kernel_power = device_param->kernel_power;
4439
4440 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4441 {
4442 hc_thread_mutex_lock (mux_dispatcher);
4443
4444 if (feof (stdin) != 0)
4445 {
4446 hc_thread_mutex_unlock (mux_dispatcher);
4447
4448 break;
4449 }
4450
4451 uint words_cur = 0;
4452
4453 while (words_cur < kernel_power)
4454 {
4455 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4456
4457 if (line_buf == NULL) break;
4458
4459 uint line_len = in_superchop (line_buf);
4460
4461 line_len = convert_from_hex (line_buf, line_len);
4462
4463 // post-process rule engine
4464
4465 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4466 {
4467 char rule_buf_out[BLOCK_SIZE] = { 0 };
4468
4469 int rule_len_out = -1;
4470
4471 if (line_len < BLOCK_SIZE)
4472 {
4473 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4474 }
4475
4476 if (rule_len_out < 0) continue;
4477
4478 line_buf = rule_buf_out;
4479 line_len = rule_len_out;
4480 }
4481
4482 if (line_len > PW_MAX)
4483 {
4484 continue;
4485 }
4486
4487 if (attack_kern == ATTACK_KERN_STRAIGHT)
4488 {
4489 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4490 {
4491 hc_thread_mutex_lock (mux_counter);
4492
4493 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4494 {
4495 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4496 }
4497
4498 hc_thread_mutex_unlock (mux_counter);
4499
4500 continue;
4501 }
4502 }
4503 else if (attack_kern == ATTACK_KERN_COMBI)
4504 {
4505 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4506 // since we still need to combine the plains
4507
4508 if (line_len > data.pw_max)
4509 {
4510 hc_thread_mutex_lock (mux_counter);
4511
4512 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4513 {
4514 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4515 }
4516
4517 hc_thread_mutex_unlock (mux_counter);
4518
4519 continue;
4520 }
4521 }
4522
4523 pw_add (device_param, (u8 *) line_buf, line_len);
4524
4525 words_cur++;
4526
4527 if (data.devices_status == STATUS_CRACKED) break;
4528 if (data.devices_status == STATUS_ABORTED) break;
4529 if (data.devices_status == STATUS_QUIT) break;
4530 if (data.devices_status == STATUS_BYPASS) break;
4531 }
4532
4533 hc_thread_mutex_unlock (mux_dispatcher);
4534
4535 if (data.devices_status == STATUS_CRACKED) break;
4536 if (data.devices_status == STATUS_ABORTED) break;
4537 if (data.devices_status == STATUS_QUIT) break;
4538 if (data.devices_status == STATUS_BYPASS) break;
4539
4540 // flush
4541
4542 const uint pws_cnt = device_param->pws_cnt;
4543
4544 if (pws_cnt)
4545 {
4546 run_copy (device_param, pws_cnt);
4547
4548 run_cracker (device_param, pws_cnt);
4549
4550 device_param->pws_cnt = 0;
4551
4552 /*
4553 still required?
4554 if (attack_kern == ATTACK_KERN_STRAIGHT)
4555 {
4556 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4557 }
4558 else if (attack_kern == ATTACK_KERN_COMBI)
4559 {
4560 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4561 }
4562 */
4563 }
4564 }
4565
4566 device_param->kernel_accel = 0;
4567 device_param->kernel_loops = 0;
4568
4569 myfree (buf);
4570
4571 return NULL;
4572 }
4573
4574 static void *thread_calc (void *p)
4575 {
4576 hc_device_param_t *device_param = (hc_device_param_t *) p;
4577
4578 if (device_param->skipped) return NULL;
4579
4580 autotune (device_param);
4581
4582 const uint attack_mode = data.attack_mode;
4583 const uint attack_kern = data.attack_kern;
4584
4585 if (attack_mode == ATTACK_MODE_BF)
4586 {
4587 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4588 {
4589 const uint work = get_work (device_param, -1, true);
4590
4591 if (work == 0) break;
4592
4593 const u64 words_off = device_param->words_off;
4594 const u64 words_fin = words_off + work;
4595
4596 const uint pws_cnt = work;
4597
4598 device_param->pws_cnt = pws_cnt;
4599
4600 if (pws_cnt)
4601 {
4602 run_copy (device_param, pws_cnt);
4603
4604 run_cracker (device_param, pws_cnt);
4605
4606 device_param->pws_cnt = 0;
4607
4608 /*
4609 still required?
4610 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4611 */
4612 }
4613
4614 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4615
4616 if (data.devices_status == STATUS_CRACKED) break;
4617 if (data.devices_status == STATUS_ABORTED) break;
4618 if (data.devices_status == STATUS_QUIT) break;
4619 if (data.devices_status == STATUS_BYPASS) break;
4620
4621 if (data.benchmark == 1) break;
4622
4623 device_param->words_done = words_fin;
4624 }
4625 }
4626 else
4627 {
4628 const uint segment_size = data.segment_size;
4629
4630 char *dictfile = data.dictfile;
4631
4632 if (attack_mode == ATTACK_MODE_COMBI)
4633 {
4634 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4635 {
4636 dictfile = data.dictfile2;
4637 }
4638 }
4639
4640 FILE *fd = fopen (dictfile, "rb");
4641
4642 if (fd == NULL)
4643 {
4644 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4645
4646 return NULL;
4647 }
4648
4649 if (attack_mode == ATTACK_MODE_COMBI)
4650 {
4651 const uint combs_mode = data.combs_mode;
4652
4653 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4654 {
4655 const char *dictfilec = data.dictfile2;
4656
4657 FILE *combs_fp = fopen (dictfilec, "rb");
4658
4659 if (combs_fp == NULL)
4660 {
4661 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4662
4663 fclose (fd);
4664
4665 return NULL;
4666 }
4667
4668 device_param->combs_fp = combs_fp;
4669 }
4670 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4671 {
4672 const char *dictfilec = data.dictfile;
4673
4674 FILE *combs_fp = fopen (dictfilec, "rb");
4675
4676 if (combs_fp == NULL)
4677 {
4678 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4679
4680 fclose (fd);
4681
4682 return NULL;
4683 }
4684
4685 device_param->combs_fp = combs_fp;
4686 }
4687 }
4688
4689 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4690
4691 wl_data->buf = (char *) mymalloc (segment_size);
4692 wl_data->avail = segment_size;
4693 wl_data->incr = segment_size;
4694 wl_data->cnt = 0;
4695 wl_data->pos = 0;
4696
4697 u64 words_cur = 0;
4698
4699 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4700 {
4701 u64 words_off = 0;
4702 u64 words_fin = 0;
4703
4704 bool allow_div = true;
4705
4706 u64 max = -1;
4707
4708 while (max)
4709 {
4710 const uint work = get_work (device_param, max, allow_div);
4711
4712 allow_div = false;
4713
4714 if (work == 0) break;
4715
4716 words_off = device_param->words_off;
4717 words_fin = words_off + work;
4718
4719 char *line_buf;
4720 uint line_len;
4721
4722 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4723
4724 max = 0;
4725
4726 for ( ; words_cur < words_fin; words_cur++)
4727 {
4728 get_next_word (wl_data, fd, &line_buf, &line_len);
4729
4730 line_len = convert_from_hex (line_buf, line_len);
4731
4732 // post-process rule engine
4733
4734 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4735 {
4736 char rule_buf_out[BLOCK_SIZE] = { 0 };
4737
4738 int rule_len_out = -1;
4739
4740 if (line_len < BLOCK_SIZE)
4741 {
4742 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4743 }
4744
4745 if (rule_len_out < 0) continue;
4746
4747 line_buf = rule_buf_out;
4748 line_len = rule_len_out;
4749 }
4750
4751 if (attack_kern == ATTACK_KERN_STRAIGHT)
4752 {
4753 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4754 {
4755 max++;
4756
4757 hc_thread_mutex_lock (mux_counter);
4758
4759 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4760 {
4761 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4762 }
4763
4764 hc_thread_mutex_unlock (mux_counter);
4765
4766 continue;
4767 }
4768 }
4769 else if (attack_kern == ATTACK_KERN_COMBI)
4770 {
4771 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4772 // since we still need to combine the plains
4773
4774 if (line_len > data.pw_max)
4775 {
4776 max++;
4777
4778 hc_thread_mutex_lock (mux_counter);
4779
4780 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4781 {
4782 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4783 }
4784
4785 hc_thread_mutex_unlock (mux_counter);
4786
4787 continue;
4788 }
4789 }
4790
4791 pw_add (device_param, (u8 *) line_buf, line_len);
4792
4793 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4794
4795 if (data.devices_status == STATUS_CRACKED) break;
4796 if (data.devices_status == STATUS_ABORTED) break;
4797 if (data.devices_status == STATUS_QUIT) break;
4798 if (data.devices_status == STATUS_BYPASS) break;
4799 }
4800
4801 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4802
4803 if (data.devices_status == STATUS_CRACKED) break;
4804 if (data.devices_status == STATUS_ABORTED) break;
4805 if (data.devices_status == STATUS_QUIT) break;
4806 if (data.devices_status == STATUS_BYPASS) break;
4807 }
4808
4809 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4810
4811 if (data.devices_status == STATUS_CRACKED) break;
4812 if (data.devices_status == STATUS_ABORTED) break;
4813 if (data.devices_status == STATUS_QUIT) break;
4814 if (data.devices_status == STATUS_BYPASS) break;
4815
4816 //
4817 // flush
4818 //
4819
4820 const uint pws_cnt = device_param->pws_cnt;
4821
4822 if (pws_cnt)
4823 {
4824 run_copy (device_param, pws_cnt);
4825
4826 run_cracker (device_param, pws_cnt);
4827
4828 device_param->pws_cnt = 0;
4829
4830 /*
4831 still required?
4832 if (attack_kern == ATTACK_KERN_STRAIGHT)
4833 {
4834 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4835 }
4836 else if (attack_kern == ATTACK_KERN_COMBI)
4837 {
4838 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4839 }
4840 */
4841 }
4842
4843 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4844
4845 if (data.devices_status == STATUS_CRACKED) break;
4846 if (data.devices_status == STATUS_ABORTED) break;
4847 if (data.devices_status == STATUS_QUIT) break;
4848 if (data.devices_status == STATUS_BYPASS) break;
4849
4850 if (words_fin == 0) break;
4851
4852 device_param->words_done = words_fin;
4853 }
4854
4855 if (attack_mode == ATTACK_MODE_COMBI)
4856 {
4857 fclose (device_param->combs_fp);
4858 }
4859
4860 free (wl_data->buf);
4861 free (wl_data);
4862
4863 fclose (fd);
4864 }
4865
4866 device_param->kernel_accel = 0;
4867 device_param->kernel_loops = 0;
4868
4869 return NULL;
4870 }
4871
4872 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4873 {
4874 if (!device_param)
4875 {
4876 log_error ("ERROR: %s : Invalid argument", __func__);
4877
4878 exit (-1);
4879 }
4880
4881 salt_t *salt_buf = &data.salts_buf[salt_pos];
4882
4883 device_param->kernel_params_buf32[24] = salt_pos;
4884 device_param->kernel_params_buf32[27] = 1;
4885 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4886 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4887 device_param->kernel_params_buf32[30] = 0;
4888 device_param->kernel_params_buf32[31] = 1;
4889
4890 char *dictfile_old = data.dictfile;
4891
4892 const char *weak_hash_check = "weak-hash-check";
4893
4894 data.dictfile = (char *) weak_hash_check;
4895
4896 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4897
4898 data.kernel_rules_buf[0].cmds[0] = 0;
4899
4900 /**
4901 * run the kernel
4902 */
4903
4904 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4905 {
4906 run_kernel (KERN_RUN_1, device_param, 1, false);
4907 }
4908 else
4909 {
4910 run_kernel (KERN_RUN_1, device_param, 1, false);
4911
4912 uint loop_step = 16;
4913
4914 const uint iter = salt_buf->salt_iter;
4915
4916 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4917 {
4918 uint loop_left = iter - loop_pos;
4919
4920 loop_left = MIN (loop_left, loop_step);
4921
4922 device_param->kernel_params_buf32[25] = loop_pos;
4923 device_param->kernel_params_buf32[26] = loop_left;
4924
4925 run_kernel (KERN_RUN_2, device_param, 1, false);
4926 }
4927
4928 run_kernel (KERN_RUN_3, device_param, 1, false);
4929 }
4930
4931 /**
4932 * result
4933 */
4934
4935 check_cracked (device_param, salt_pos);
4936
4937 /**
4938 * cleanup
4939 */
4940
4941 device_param->kernel_params_buf32[24] = 0;
4942 device_param->kernel_params_buf32[25] = 0;
4943 device_param->kernel_params_buf32[26] = 0;
4944 device_param->kernel_params_buf32[27] = 0;
4945 device_param->kernel_params_buf32[28] = 0;
4946 device_param->kernel_params_buf32[29] = 0;
4947 device_param->kernel_params_buf32[30] = 0;
4948 device_param->kernel_params_buf32[31] = 0;
4949
4950 data.dictfile = dictfile_old;
4951
4952 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4953 }
4954
4955 // hlfmt hashcat
4956
4957 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4958 {
4959 if (data.username == 0)
4960 {
4961 *hashbuf_pos = line_buf;
4962 *hashbuf_len = line_len;
4963 }
4964 else
4965 {
4966 char *pos = line_buf;
4967 int len = line_len;
4968
4969 for (int i = 0; i < line_len; i++, pos++, len--)
4970 {
4971 if (line_buf[i] == data.separator)
4972 {
4973 pos++;
4974
4975 len--;
4976
4977 break;
4978 }
4979 }
4980
4981 *hashbuf_pos = pos;
4982 *hashbuf_len = len;
4983 }
4984 }
4985
4986 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4987 {
4988 char *pos = NULL;
4989 int len = 0;
4990
4991 int sep_cnt = 0;
4992
4993 for (int i = 0; i < line_len; i++)
4994 {
4995 if (line_buf[i] == data.separator)
4996 {
4997 sep_cnt++;
4998
4999 continue;
5000 }
5001
5002 if (sep_cnt == 0)
5003 {
5004 if (pos == NULL) pos = line_buf + i;
5005
5006 len++;
5007 }
5008 }
5009
5010 *userbuf_pos = pos;
5011 *userbuf_len = len;
5012 }
5013
5014 // hlfmt pwdump
5015
5016 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5017 {
5018 int sep_cnt = 0;
5019
5020 int sep2_len = 0;
5021 int sep3_len = 0;
5022
5023 for (int i = 0; i < line_len; i++)
5024 {
5025 if (line_buf[i] == ':')
5026 {
5027 sep_cnt++;
5028
5029 continue;
5030 }
5031
5032 if (sep_cnt == 2) sep2_len++;
5033 if (sep_cnt == 3) sep3_len++;
5034 }
5035
5036 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5037
5038 return 0;
5039 }
5040
5041 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5042 {
5043 char *pos = NULL;
5044 int len = 0;
5045
5046 int sep_cnt = 0;
5047
5048 for (int i = 0; i < line_len; i++)
5049 {
5050 if (line_buf[i] == ':')
5051 {
5052 sep_cnt++;
5053
5054 continue;
5055 }
5056
5057 if (data.hash_mode == 1000)
5058 {
5059 if (sep_cnt == 3)
5060 {
5061 if (pos == NULL) pos = line_buf + i;
5062
5063 len++;
5064 }
5065 }
5066 else if (data.hash_mode == 3000)
5067 {
5068 if (sep_cnt == 2)
5069 {
5070 if (pos == NULL) pos = line_buf + i;
5071
5072 len++;
5073 }
5074 }
5075 }
5076
5077 *hashbuf_pos = pos;
5078 *hashbuf_len = len;
5079 }
5080
5081 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5082 {
5083 char *pos = NULL;
5084 int len = 0;
5085
5086 int sep_cnt = 0;
5087
5088 for (int i = 0; i < line_len; i++)
5089 {
5090 if (line_buf[i] == ':')
5091 {
5092 sep_cnt++;
5093
5094 continue;
5095 }
5096
5097 if (sep_cnt == 0)
5098 {
5099 if (pos == NULL) pos = line_buf + i;
5100
5101 len++;
5102 }
5103 }
5104
5105 *userbuf_pos = pos;
5106 *userbuf_len = len;
5107 }
5108
5109 // hlfmt passwd
5110
5111 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5112 {
5113 int sep_cnt = 0;
5114
5115 char sep5_first = 0;
5116 char sep6_first = 0;
5117
5118 for (int i = 0; i < line_len; i++)
5119 {
5120 if (line_buf[i] == ':')
5121 {
5122 sep_cnt++;
5123
5124 continue;
5125 }
5126
5127 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5128 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5129 }
5130
5131 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5132
5133 return 0;
5134 }
5135
5136 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5137 {
5138 char *pos = NULL;
5139 int len = 0;
5140
5141 int sep_cnt = 0;
5142
5143 for (int i = 0; i < line_len; i++)
5144 {
5145 if (line_buf[i] == ':')
5146 {
5147 sep_cnt++;
5148
5149 continue;
5150 }
5151
5152 if (sep_cnt == 1)
5153 {
5154 if (pos == NULL) pos = line_buf + i;
5155
5156 len++;
5157 }
5158 }
5159
5160 *hashbuf_pos = pos;
5161 *hashbuf_len = len;
5162 }
5163
5164 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5165 {
5166 char *pos = NULL;
5167 int len = 0;
5168
5169 int sep_cnt = 0;
5170
5171 for (int i = 0; i < line_len; i++)
5172 {
5173 if (line_buf[i] == ':')
5174 {
5175 sep_cnt++;
5176
5177 continue;
5178 }
5179
5180 if (sep_cnt == 0)
5181 {
5182 if (pos == NULL) pos = line_buf + i;
5183
5184 len++;
5185 }
5186 }
5187
5188 *userbuf_pos = pos;
5189 *userbuf_len = len;
5190 }
5191
5192 // hlfmt shadow
5193
5194 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5195 {
5196 int sep_cnt = 0;
5197
5198 for (int i = 0; i < line_len; i++)
5199 {
5200 if (line_buf[i] == ':') sep_cnt++;
5201 }
5202
5203 if (sep_cnt == 8) return 1;
5204
5205 return 0;
5206 }
5207
5208 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5209 {
5210 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5211 }
5212
5213 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5214 {
5215 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5216 }
5217
5218 // hlfmt main
5219
5220 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5221 {
5222 switch (hashfile_format)
5223 {
5224 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5225 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5226 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5227 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5228 }
5229 }
5230
5231 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5232 {
5233 switch (hashfile_format)
5234 {
5235 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5236 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5237 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5238 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5239 }
5240 }
5241
5242 char *strhlfmt (const uint hashfile_format)
5243 {
5244 switch (hashfile_format)
5245 {
5246 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5247 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5248 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5249 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5250 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5251 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5252 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5253 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5254 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5255 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5256 }
5257
5258 return ((char *) "Unknown");
5259 }
5260
5261 static uint hlfmt_detect (FILE *fp, uint max_check)
5262 {
5263 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5264
5265 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5266 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5267
5268 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5269
5270 uint num_check = 0;
5271
5272 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5273
5274 while (!feof (fp))
5275 {
5276 int line_len = fgetl (fp, line_buf);
5277
5278 if (line_len == 0) continue;
5279
5280 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5281 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5282 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5283
5284 if (num_check == max_check) break;
5285
5286 num_check++;
5287 }
5288
5289 myfree (line_buf);
5290
5291 uint hashlist_format = HLFMT_HASHCAT;
5292
5293 for (int i = 1; i < HLFMTS_CNT; i++)
5294 {
5295 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5296
5297 hashlist_format = i;
5298 }
5299
5300 free (formats_cnt);
5301
5302 return hashlist_format;
5303 }
5304
5305 /**
5306 * some further helper function
5307 */
5308
5309 // wrapper around mymalloc for ADL
5310
5311 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5312 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5313 {
5314 return mymalloc (iSize);
5315 }
5316 #endif
5317
5318 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)
5319 {
5320 u64 collisions = 0;
5321
5322 const uint dgst_pos0 = data.dgst_pos0;
5323 const uint dgst_pos1 = data.dgst_pos1;
5324 const uint dgst_pos2 = data.dgst_pos2;
5325 const uint dgst_pos3 = data.dgst_pos3;
5326
5327 memset (bitmap_a, 0, bitmap_size);
5328 memset (bitmap_b, 0, bitmap_size);
5329 memset (bitmap_c, 0, bitmap_size);
5330 memset (bitmap_d, 0, bitmap_size);
5331
5332 for (uint i = 0; i < digests_cnt; i++)
5333 {
5334 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5335
5336 uint *digest_ptr = (uint *) digests_buf_ptr;
5337
5338 digests_buf_ptr += dgst_size;
5339
5340 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5341 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5342 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5343 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5344
5345 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5346 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5347 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5348 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5349
5350 if (bitmap_a[idx0] & val0) collisions++;
5351 if (bitmap_b[idx1] & val1) collisions++;
5352 if (bitmap_c[idx2] & val2) collisions++;
5353 if (bitmap_d[idx3] & val3) collisions++;
5354
5355 bitmap_a[idx0] |= val0;
5356 bitmap_b[idx1] |= val1;
5357 bitmap_c[idx2] |= val2;
5358 bitmap_d[idx3] |= val3;
5359
5360 if (collisions >= collisions_max) return 0x7fffffff;
5361 }
5362
5363 return collisions;
5364 }
5365
5366 /**
5367 * main
5368 */
5369
5370 #ifdef _WIN
5371 void SetConsoleWindowSize (const int x)
5372 {
5373 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5374
5375 if (h == INVALID_HANDLE_VALUE) return;
5376
5377 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5378
5379 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5380
5381 SMALL_RECT *sr = &bufferInfo.srWindow;
5382
5383 sr->Right = MAX (sr->Right, x - 1);
5384
5385 COORD co;
5386
5387 co.X = sr->Right + 1;
5388 co.Y = sr->Bottom + 1;
5389
5390 if (!SetConsoleScreenBufferSize (h, co)) return;
5391
5392 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5393 }
5394 #endif
5395
5396 int main (int argc, char **argv)
5397 {
5398 #ifdef _WIN
5399 SetConsoleWindowSize (132);
5400 #endif
5401
5402 /**
5403 * To help users a bit
5404 */
5405
5406 char *compute = getenv ("COMPUTE");
5407
5408 if (compute)
5409 {
5410 static char display[100];
5411
5412 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5413
5414 putenv (display);
5415 }
5416 else
5417 {
5418 if (getenv ("DISPLAY") == NULL)
5419 putenv ((char *) "DISPLAY=:0");
5420 }
5421
5422 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5423 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5424
5425 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5426 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5427
5428 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5429 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5430
5431 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5432 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5433
5434 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5435 putenv ((char *) "POCL_KERNEL_CACHE=0");
5436
5437 umask (077);
5438
5439 /**
5440 * Real init
5441 */
5442
5443 memset (&data, 0, sizeof (hc_global_data_t));
5444
5445 time_t proc_start;
5446
5447 time (&proc_start);
5448
5449 data.proc_start = proc_start;
5450
5451 int myargc = argc;
5452 char **myargv = argv;
5453
5454 hc_thread_mutex_init (mux_dispatcher);
5455 hc_thread_mutex_init (mux_counter);
5456 hc_thread_mutex_init (mux_display);
5457 hc_thread_mutex_init (mux_adl);
5458
5459 /**
5460 * commandline parameters
5461 */
5462
5463 uint usage = USAGE;
5464 uint version = VERSION;
5465 uint quiet = QUIET;
5466 uint benchmark = BENCHMARK;
5467 uint show = SHOW;
5468 uint left = LEFT;
5469 uint username = USERNAME;
5470 uint remove = REMOVE;
5471 uint remove_timer = REMOVE_TIMER;
5472 u64 skip = SKIP;
5473 u64 limit = LIMIT;
5474 uint keyspace = KEYSPACE;
5475 uint potfile_disable = POTFILE_DISABLE;
5476 char *potfile_path = NULL;
5477 uint debug_mode = DEBUG_MODE;
5478 char *debug_file = NULL;
5479 char *induction_dir = NULL;
5480 char *outfile_check_dir = NULL;
5481 uint force = FORCE;
5482 uint runtime = RUNTIME;
5483 uint hash_mode = HASH_MODE;
5484 uint attack_mode = ATTACK_MODE;
5485 uint markov_disable = MARKOV_DISABLE;
5486 uint markov_classic = MARKOV_CLASSIC;
5487 uint markov_threshold = MARKOV_THRESHOLD;
5488 char *markov_hcstat = NULL;
5489 char *outfile = NULL;
5490 uint outfile_format = OUTFILE_FORMAT;
5491 uint outfile_autohex = OUTFILE_AUTOHEX;
5492 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5493 uint restore = RESTORE;
5494 uint restore_timer = RESTORE_TIMER;
5495 uint restore_disable = RESTORE_DISABLE;
5496 uint status = STATUS;
5497 uint status_timer = STATUS_TIMER;
5498 uint machine_readable = MACHINE_READABLE;
5499 uint loopback = LOOPBACK;
5500 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5501 char *session = NULL;
5502 uint hex_charset = HEX_CHARSET;
5503 uint hex_salt = HEX_SALT;
5504 uint hex_wordlist = HEX_WORDLIST;
5505 uint rp_gen = RP_GEN;
5506 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5507 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5508 uint rp_gen_seed = RP_GEN_SEED;
5509 char *rule_buf_l = (char *) RULE_BUF_L;
5510 char *rule_buf_r = (char *) RULE_BUF_R;
5511 uint increment = INCREMENT;
5512 uint increment_min = INCREMENT_MIN;
5513 uint increment_max = INCREMENT_MAX;
5514 char *cpu_affinity = NULL;
5515 OCL_PTR *ocl = NULL;
5516 char *opencl_devices = NULL;
5517 char *opencl_platforms = NULL;
5518 char *opencl_device_types = NULL;
5519 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5520 char *truecrypt_keyfiles = NULL;
5521 char *veracrypt_keyfiles = NULL;
5522 uint veracrypt_pim = 0;
5523 uint workload_profile = WORKLOAD_PROFILE;
5524 uint kernel_accel = KERNEL_ACCEL;
5525 uint kernel_loops = KERNEL_LOOPS;
5526 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5527 #ifdef HAVE_HWMON
5528 uint gpu_temp_abort = GPU_TEMP_ABORT;
5529 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5530 #ifdef HAVE_ADL
5531 uint powertune_enable = POWERTUNE_ENABLE;
5532 #endif
5533 #endif
5534 uint logfile_disable = LOGFILE_DISABLE;
5535 uint segment_size = SEGMENT_SIZE;
5536 uint scrypt_tmto = SCRYPT_TMTO;
5537 char separator = SEPARATOR;
5538 uint bitmap_min = BITMAP_MIN;
5539 uint bitmap_max = BITMAP_MAX;
5540 char *custom_charset_1 = NULL;
5541 char *custom_charset_2 = NULL;
5542 char *custom_charset_3 = NULL;
5543 char *custom_charset_4 = NULL;
5544
5545 #define IDX_HELP 'h'
5546 #define IDX_VERSION 'V'
5547 #define IDX_VERSION_LOWER 'v'
5548 #define IDX_QUIET 0xff02
5549 #define IDX_SHOW 0xff03
5550 #define IDX_LEFT 0xff04
5551 #define IDX_REMOVE 0xff05
5552 #define IDX_REMOVE_TIMER 0xff37
5553 #define IDX_SKIP 's'
5554 #define IDX_LIMIT 'l'
5555 #define IDX_KEYSPACE 0xff35
5556 #define IDX_POTFILE_DISABLE 0xff06
5557 #define IDX_POTFILE_PATH 0xffe0
5558 #define IDX_DEBUG_MODE 0xff43
5559 #define IDX_DEBUG_FILE 0xff44
5560 #define IDX_INDUCTION_DIR 0xff46
5561 #define IDX_OUTFILE_CHECK_DIR 0xff47
5562 #define IDX_USERNAME 0xff07
5563 #define IDX_FORCE 0xff08
5564 #define IDX_RUNTIME 0xff09
5565 #define IDX_BENCHMARK 'b'
5566 #define IDX_HASH_MODE 'm'
5567 #define IDX_ATTACK_MODE 'a'
5568 #define IDX_RP_FILE 'r'
5569 #define IDX_RP_GEN 'g'
5570 #define IDX_RP_GEN_FUNC_MIN 0xff10
5571 #define IDX_RP_GEN_FUNC_MAX 0xff11
5572 #define IDX_RP_GEN_SEED 0xff34
5573 #define IDX_RULE_BUF_L 'j'
5574 #define IDX_RULE_BUF_R 'k'
5575 #define IDX_INCREMENT 'i'
5576 #define IDX_INCREMENT_MIN 0xff12
5577 #define IDX_INCREMENT_MAX 0xff13
5578 #define IDX_OUTFILE 'o'
5579 #define IDX_OUTFILE_FORMAT 0xff14
5580 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5581 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5582 #define IDX_RESTORE 0xff15
5583 #define IDX_RESTORE_DISABLE 0xff27
5584 #define IDX_STATUS 0xff17
5585 #define IDX_STATUS_TIMER 0xff18
5586 #define IDX_MACHINE_READABLE 0xff50
5587 #define IDX_LOOPBACK 0xff38
5588 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5589 #define IDX_SESSION 0xff19
5590 #define IDX_HEX_CHARSET 0xff20
5591 #define IDX_HEX_SALT 0xff21
5592 #define IDX_HEX_WORDLIST 0xff40
5593 #define IDX_MARKOV_DISABLE 0xff22
5594 #define IDX_MARKOV_CLASSIC 0xff23
5595 #define IDX_MARKOV_THRESHOLD 't'
5596 #define IDX_MARKOV_HCSTAT 0xff24
5597 #define IDX_CPU_AFFINITY 0xff25
5598 #define IDX_OPENCL_DEVICES 'd'
5599 #define IDX_OPENCL_PLATFORMS 0xff72
5600 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5601 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5602 #define IDX_WORKLOAD_PROFILE 'w'
5603 #define IDX_KERNEL_ACCEL 'n'
5604 #define IDX_KERNEL_LOOPS 'u'
5605 #define IDX_GPU_TEMP_DISABLE 0xff29
5606 #define IDX_GPU_TEMP_ABORT 0xff30
5607 #define IDX_GPU_TEMP_RETAIN 0xff31
5608 #define IDX_POWERTUNE_ENABLE 0xff41
5609 #define IDX_LOGFILE_DISABLE 0xff51
5610 #define IDX_TRUECRYPT_KEYFILES 0xff52
5611 #define IDX_VERACRYPT_KEYFILES 0xff53
5612 #define IDX_VERACRYPT_PIM 0xff54
5613 #define IDX_SCRYPT_TMTO 0xff61
5614 #define IDX_SEGMENT_SIZE 'c'
5615 #define IDX_SEPARATOR 'p'
5616 #define IDX_BITMAP_MIN 0xff70
5617 #define IDX_BITMAP_MAX 0xff71
5618 #define IDX_CUSTOM_CHARSET_1 '1'
5619 #define IDX_CUSTOM_CHARSET_2 '2'
5620 #define IDX_CUSTOM_CHARSET_3 '3'
5621 #define IDX_CUSTOM_CHARSET_4 '4'
5622
5623 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5624
5625 struct option long_options[] =
5626 {
5627 {"help", no_argument, 0, IDX_HELP},
5628 {"version", no_argument, 0, IDX_VERSION},
5629 {"quiet", no_argument, 0, IDX_QUIET},
5630 {"show", no_argument, 0, IDX_SHOW},
5631 {"left", no_argument, 0, IDX_LEFT},
5632 {"username", no_argument, 0, IDX_USERNAME},
5633 {"remove", no_argument, 0, IDX_REMOVE},
5634 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5635 {"skip", required_argument, 0, IDX_SKIP},
5636 {"limit", required_argument, 0, IDX_LIMIT},
5637 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5638 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5639 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5640 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5641 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5642 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5643 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5644 {"force", no_argument, 0, IDX_FORCE},
5645 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5646 {"restore", no_argument, 0, IDX_RESTORE},
5647 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5648 {"status", no_argument, 0, IDX_STATUS},
5649 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5650 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5651 {"loopback", no_argument, 0, IDX_LOOPBACK},
5652 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5653 {"session", required_argument, 0, IDX_SESSION},
5654 {"runtime", required_argument, 0, IDX_RUNTIME},
5655 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5656 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5657 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5658 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5659 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5660 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5661 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5662 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5663 {"rules-file", required_argument, 0, IDX_RP_FILE},
5664 {"outfile", required_argument, 0, IDX_OUTFILE},
5665 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5666 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5667 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5668 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5669 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5670 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5671 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5672 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5673 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5674 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5675 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5676 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5677 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5678 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5679 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5680 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5681 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5682 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5683 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5684 #ifdef HAVE_HWMON
5685 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5686 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5687 #ifdef HAVE_ADL
5688 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5689 #endif
5690 #endif // HAVE_HWMON
5691 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5692 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5693 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5694 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5695 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5696 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5697 {"seperator", required_argument, 0, IDX_SEPARATOR},
5698 {"separator", required_argument, 0, IDX_SEPARATOR},
5699 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5700 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5701 {"increment", no_argument, 0, IDX_INCREMENT},
5702 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5703 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5704 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5705 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5706 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5707 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5708 {0, 0, 0, 0}
5709 };
5710
5711 uint rp_files_cnt = 0;
5712
5713 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5714
5715 int option_index = 0;
5716 int c = -1;
5717
5718 optind = 1;
5719 optopt = 0;
5720
5721 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5722 {
5723 switch (c)
5724 {
5725 case IDX_HELP: usage = 1; break;
5726 case IDX_VERSION:
5727 case IDX_VERSION_LOWER: version = 1; break;
5728 case IDX_RESTORE: restore = 1; break;
5729 case IDX_SESSION: session = optarg; break;
5730 case IDX_SHOW: show = 1; break;
5731 case IDX_LEFT: left = 1; break;
5732 case '?': return (-1);
5733 }
5734 }
5735
5736 if (optopt != 0)
5737 {
5738 log_error ("ERROR: Invalid argument specified");
5739
5740 return (-1);
5741 }
5742
5743 /**
5744 * exit functions
5745 */
5746
5747 if (version)
5748 {
5749 log_info ("%s", VERSION_TAG);
5750
5751 return (0);
5752 }
5753
5754 if (usage)
5755 {
5756 usage_big_print (PROGNAME);
5757
5758 return (0);
5759 }
5760
5761 /**
5762 * session needs to be set, always!
5763 */
5764
5765 if (session == NULL) session = (char *) PROGNAME;
5766
5767 /**
5768 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5769 */
5770
5771 char *exec_path = get_exec_path ();
5772
5773 #ifdef LINUX
5774
5775 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5776 char *resolved_exec_path = realpath (exec_path, NULL);
5777
5778 char *install_dir = get_install_dir (resolved_exec_path);
5779 char *profile_dir = NULL;
5780 char *session_dir = NULL;
5781 char *shared_dir = NULL;
5782
5783 if (strcmp (install_dir, resolved_install_folder) == 0)
5784 {
5785 struct passwd *pw = getpwuid (getuid ());
5786
5787 const char *homedir = pw->pw_dir;
5788
5789 profile_dir = get_profile_dir (homedir);
5790 session_dir = get_session_dir (profile_dir);
5791 shared_dir = strdup (SHARED_FOLDER);
5792
5793 mkdir (profile_dir, 0700);
5794 mkdir (session_dir, 0700);
5795 }
5796 else
5797 {
5798 profile_dir = install_dir;
5799 session_dir = install_dir;
5800 shared_dir = install_dir;
5801 }
5802
5803 myfree (resolved_install_folder);
5804 myfree (resolved_exec_path);
5805
5806 #else
5807
5808 char *install_dir = get_install_dir (exec_path);
5809 char *profile_dir = install_dir;
5810 char *session_dir = install_dir;
5811 char *shared_dir = install_dir;
5812
5813 #endif
5814
5815 data.install_dir = install_dir;
5816 data.profile_dir = profile_dir;
5817 data.session_dir = session_dir;
5818 data.shared_dir = shared_dir;
5819
5820 myfree (exec_path);
5821
5822 /**
5823 * kernel cache, we need to make sure folder exist
5824 */
5825
5826 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5827
5828 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5829
5830 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5831
5832 mkdir (kernels_folder, 0700);
5833
5834 myfree (kernels_folder);
5835
5836 /**
5837 * session
5838 */
5839
5840 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5841
5842 data.session = session;
5843
5844 char *eff_restore_file = (char *) mymalloc (session_size);
5845 char *new_restore_file = (char *) mymalloc (session_size);
5846
5847 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5848 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5849
5850 data.eff_restore_file = eff_restore_file;
5851 data.new_restore_file = new_restore_file;
5852
5853 if (((show == 1) || (left == 1)) && (restore == 1))
5854 {
5855 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5856 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5857
5858 return (-1);
5859 }
5860
5861 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5862 if ((show == 1) || (left == 1))
5863 {
5864 restore_disable = 1;
5865
5866 restore = 0;
5867 }
5868
5869 data.restore_disable = restore_disable;
5870
5871 restore_data_t *rd = init_restore (argc, argv);
5872
5873 data.rd = rd;
5874
5875 /**
5876 * restore file
5877 */
5878
5879 if (restore == 1)
5880 {
5881 read_restore (eff_restore_file, rd);
5882
5883 if (rd->version_bin < RESTORE_MIN)
5884 {
5885 log_error ("ERROR: Incompatible restore-file version");
5886
5887 return (-1);
5888 }
5889
5890 myargc = rd->argc;
5891 myargv = rd->argv;
5892
5893 #ifdef _POSIX
5894 rd->pid = getpid ();
5895 #elif _WIN
5896 rd->pid = GetCurrentProcessId ();
5897 #endif
5898 }
5899
5900 uint hash_mode_chgd = 0;
5901 uint runtime_chgd = 0;
5902 uint kernel_loops_chgd = 0;
5903 uint kernel_accel_chgd = 0;
5904 uint attack_mode_chgd = 0;
5905 uint outfile_format_chgd = 0;
5906 uint rp_gen_seed_chgd = 0;
5907 uint remove_timer_chgd = 0;
5908 uint increment_min_chgd = 0;
5909 uint increment_max_chgd = 0;
5910 uint workload_profile_chgd = 0;
5911 uint opencl_vector_width_chgd = 0;
5912
5913 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5914 uint gpu_temp_retain_chgd = 0;
5915 uint gpu_temp_abort_chgd = 0;
5916 #endif
5917
5918 optind = 1;
5919 optopt = 0;
5920 option_index = 0;
5921
5922 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5923 {
5924 switch (c)
5925 {
5926 //case IDX_HELP: usage = 1; break;
5927 //case IDX_VERSION: version = 1; break;
5928 //case IDX_RESTORE: restore = 1; break;
5929 case IDX_QUIET: quiet = 1; break;
5930 //case IDX_SHOW: show = 1; break;
5931 case IDX_SHOW: break;
5932 //case IDX_LEFT: left = 1; break;
5933 case IDX_LEFT: break;
5934 case IDX_USERNAME: username = 1; break;
5935 case IDX_REMOVE: remove = 1; break;
5936 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5937 remove_timer_chgd = 1; break;
5938 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5939 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5940 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5941 case IDX_DEBUG_FILE: debug_file = optarg; break;
5942 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5943 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5944 case IDX_FORCE: force = 1; break;
5945 case IDX_SKIP: skip = atoll (optarg); break;
5946 case IDX_LIMIT: limit = atoll (optarg); break;
5947 case IDX_KEYSPACE: keyspace = 1; break;
5948 case IDX_BENCHMARK: benchmark = 1; break;
5949 case IDX_RESTORE: break;
5950 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5951 case IDX_STATUS: status = 1; break;
5952 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5953 case IDX_MACHINE_READABLE: machine_readable = 1; break;
5954 case IDX_LOOPBACK: loopback = 1; break;
5955 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5956 //case IDX_SESSION: session = optarg; break;
5957 case IDX_SESSION: break;
5958 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5959 hash_mode_chgd = 1; break;
5960 case IDX_RUNTIME: runtime = atoi (optarg);
5961 runtime_chgd = 1; break;
5962 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5963 attack_mode_chgd = 1; break;
5964 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5965 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5966 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5967 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5968 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5969 rp_gen_seed_chgd = 1; break;
5970 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5971 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5972 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5973 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5974 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5975 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5976 case IDX_OUTFILE: outfile = optarg; break;
5977 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5978 outfile_format_chgd = 1; break;
5979 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
5980 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
5981 case IDX_HEX_CHARSET: hex_charset = 1; break;
5982 case IDX_HEX_SALT: hex_salt = 1; break;
5983 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5984 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5985 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5986 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5987 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
5988 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
5989 opencl_vector_width_chgd = 1; break;
5990 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5991 workload_profile_chgd = 1; break;
5992 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5993 kernel_accel_chgd = 1; break;
5994 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5995 kernel_loops_chgd = 1; break;
5996 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5997 #ifdef HAVE_HWMON
5998 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5999 #ifdef HAVE_ADL
6000 gpu_temp_abort_chgd = 1;
6001 #endif
6002 break;
6003 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
6004 #ifdef HAVE_ADL
6005 gpu_temp_retain_chgd = 1;
6006 #endif
6007 break;
6008 #ifdef HAVE_ADL
6009 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6010 #endif
6011 #endif // HAVE_HWMON
6012 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6013 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6014 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6015 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6016 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6017 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6018 case IDX_SEPARATOR: separator = optarg[0]; break;
6019 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6020 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6021 case IDX_INCREMENT: increment = 1; break;
6022 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6023 increment_min_chgd = 1; break;
6024 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6025 increment_max_chgd = 1; break;
6026 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6027 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6028 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6029 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6030
6031 default:
6032 log_error ("ERROR: Invalid argument specified");
6033 return (-1);
6034 }
6035 }
6036
6037 if (optopt != 0)
6038 {
6039 log_error ("ERROR: Invalid argument specified");
6040
6041 return (-1);
6042 }
6043
6044 /**
6045 * Inform user things getting started,
6046 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6047 * - we do not need to check algorithm_pos
6048 */
6049
6050 if (quiet == 0)
6051 {
6052 if (benchmark == 1)
6053 {
6054 if (machine_readable == 0)
6055 {
6056 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6057 log_info ("");
6058 }
6059 else
6060 {
6061 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6062 }
6063 }
6064 else if (restore == 1)
6065 {
6066 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6067 log_info ("");
6068 }
6069 else
6070 {
6071 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6072 log_info ("");
6073 }
6074 }
6075
6076 /**
6077 * sanity check
6078 */
6079
6080 if (attack_mode > 7)
6081 {
6082 log_error ("ERROR: Invalid attack-mode specified");
6083
6084 return (-1);
6085 }
6086
6087 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6088 {
6089 log_error ("ERROR: Invalid runtime specified");
6090
6091 return (-1);
6092 }
6093
6094 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6095 {
6096 log_error ("ERROR: Invalid hash-type specified");
6097
6098 return (-1);
6099 }
6100
6101 // renamed hash modes
6102
6103 if (hash_mode_chgd)
6104 {
6105 int n = -1;
6106
6107 switch (hash_mode)
6108 {
6109 case 123: n = 124;
6110 break;
6111 }
6112
6113 if (n >= 0)
6114 {
6115 log_error ("Old -m specified, use -m %d instead", n);
6116
6117 return (-1);
6118 }
6119 }
6120
6121 if (username == 1)
6122 {
6123 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6124 {
6125 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6126
6127 return (-1);
6128 }
6129 }
6130
6131 if (outfile_format > 16)
6132 {
6133 log_error ("ERROR: Invalid outfile-format specified");
6134
6135 return (-1);
6136 }
6137
6138 if (left == 1)
6139 {
6140 if (outfile_format_chgd == 1)
6141 {
6142 if (outfile_format > 1)
6143 {
6144 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6145
6146 return (-1);
6147 }
6148 }
6149 else
6150 {
6151 outfile_format = OUTFILE_FMT_HASH;
6152 }
6153 }
6154
6155 if (show == 1)
6156 {
6157 if (outfile_format_chgd == 1)
6158 {
6159 if ((outfile_format > 7) && (outfile_format < 16))
6160 {
6161 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6162
6163 return (-1);
6164 }
6165 }
6166 }
6167
6168 if (increment_min < INCREMENT_MIN)
6169 {
6170 log_error ("ERROR: Invalid increment-min specified");
6171
6172 return (-1);
6173 }
6174
6175 if (increment_max > INCREMENT_MAX)
6176 {
6177 log_error ("ERROR: Invalid increment-max specified");
6178
6179 return (-1);
6180 }
6181
6182 if (increment_min > increment_max)
6183 {
6184 log_error ("ERROR: Invalid increment-min specified");
6185
6186 return (-1);
6187 }
6188
6189 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6190 {
6191 log_error ("ERROR: increment is not allowed in attack-mode 0");
6192
6193 return (-1);
6194 }
6195
6196 if ((increment == 0) && (increment_min_chgd == 1))
6197 {
6198 log_error ("ERROR: increment-min is only supported together with increment switch");
6199
6200 return (-1);
6201 }
6202
6203 if ((increment == 0) && (increment_max_chgd == 1))
6204 {
6205 log_error ("ERROR: increment-max is only supported together with increment switch");
6206
6207 return (-1);
6208 }
6209
6210 if (rp_files_cnt && rp_gen)
6211 {
6212 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6213
6214 return (-1);
6215 }
6216
6217 if (rp_files_cnt || rp_gen)
6218 {
6219 if (attack_mode != ATTACK_MODE_STRAIGHT)
6220 {
6221 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6222
6223 return (-1);
6224 }
6225 }
6226
6227 if (rp_gen_func_min > rp_gen_func_max)
6228 {
6229 log_error ("ERROR: Invalid rp-gen-func-min specified");
6230
6231 return (-1);
6232 }
6233
6234 if (kernel_accel_chgd == 1)
6235 {
6236 if (force == 0)
6237 {
6238 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6239 log_info ("Please consider using the option -w instead");
6240 log_info ("You can use --force to override this but do not post error reports if you do so");
6241 log_info ("");
6242
6243 return (-1);
6244 }
6245
6246 if (kernel_accel < 1)
6247 {
6248 log_error ("ERROR: Invalid kernel-accel specified");
6249
6250 return (-1);
6251 }
6252
6253 if (kernel_accel > 1024)
6254 {
6255 log_error ("ERROR: Invalid kernel-accel specified");
6256
6257 return (-1);
6258 }
6259 }
6260
6261 if (kernel_loops_chgd == 1)
6262 {
6263 if (force == 0)
6264 {
6265 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6266 log_info ("Please consider using the option -w instead");
6267 log_info ("You can use --force to override this but do not post error reports if you do so");
6268 log_info ("");
6269
6270 return (-1);
6271 }
6272
6273 if (kernel_loops < 1)
6274 {
6275 log_error ("ERROR: Invalid kernel-loops specified");
6276
6277 return (-1);
6278 }
6279
6280 if (kernel_loops > 1024)
6281 {
6282 log_error ("ERROR: Invalid kernel-loops specified");
6283
6284 return (-1);
6285 }
6286 }
6287
6288 if ((workload_profile < 1) || (workload_profile > 4))
6289 {
6290 log_error ("ERROR: workload-profile %i not available", workload_profile);
6291
6292 return (-1);
6293 }
6294
6295 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6296 {
6297 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6298
6299 return (-1);
6300 }
6301
6302 if (show == 1 || left == 1)
6303 {
6304 attack_mode = ATTACK_MODE_NONE;
6305
6306 if (remove == 1)
6307 {
6308 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6309
6310 return (-1);
6311 }
6312
6313 if (potfile_disable == 1)
6314 {
6315 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6316
6317 return (-1);
6318 }
6319 }
6320
6321 uint attack_kern = ATTACK_KERN_NONE;
6322
6323 switch (attack_mode)
6324 {
6325 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6326 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6327 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6328 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6329 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6330 }
6331
6332 if (benchmark == 0)
6333 {
6334 if (keyspace == 1)
6335 {
6336 int num_additional_params = 1;
6337
6338 if (attack_kern == ATTACK_KERN_COMBI)
6339 {
6340 num_additional_params = 2;
6341 }
6342
6343 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6344
6345 if (keyspace_wordlist_specified == 0) optind--;
6346 }
6347
6348 if (attack_kern == ATTACK_KERN_NONE)
6349 {
6350 if ((optind + 1) != myargc)
6351 {
6352 usage_mini_print (myargv[0]);
6353
6354 return (-1);
6355 }
6356 }
6357 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6358 {
6359 if ((optind + 1) > myargc)
6360 {
6361 usage_mini_print (myargv[0]);
6362
6363 return (-1);
6364 }
6365 }
6366 else if (attack_kern == ATTACK_KERN_COMBI)
6367 {
6368 if ((optind + 3) != myargc)
6369 {
6370 usage_mini_print (myargv[0]);
6371
6372 return (-1);
6373 }
6374 }
6375 else if (attack_kern == ATTACK_KERN_BF)
6376 {
6377 if ((optind + 1) > myargc)
6378 {
6379 usage_mini_print (myargv[0]);
6380
6381 return (-1);
6382 }
6383 }
6384 else
6385 {
6386 usage_mini_print (myargv[0]);
6387
6388 return (-1);
6389 }
6390 }
6391 else
6392 {
6393 if (myargv[optind] != 0)
6394 {
6395 log_error ("ERROR: Invalid argument for benchmark mode specified");
6396
6397 return (-1);
6398 }
6399
6400 if (attack_mode_chgd == 1)
6401 {
6402 if (attack_mode != ATTACK_MODE_BF)
6403 {
6404 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6405
6406 return (-1);
6407 }
6408 }
6409 }
6410
6411 if (skip != 0 && limit != 0)
6412 {
6413 limit += skip;
6414 }
6415
6416 if (keyspace == 1)
6417 {
6418 if (show == 1)
6419 {
6420 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6421
6422 return (-1);
6423 }
6424 else if (left == 1)
6425 {
6426 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6427
6428 return (-1);
6429 }
6430
6431 potfile_disable = 1;
6432
6433 restore_disable = 1;
6434
6435 restore = 0;
6436
6437 weak_hash_threshold = 0;
6438
6439 quiet = 1;
6440 }
6441
6442 if (remove_timer_chgd == 1)
6443 {
6444 if (remove == 0)
6445 {
6446 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6447
6448 return (-1);
6449 }
6450
6451 if (remove_timer < 1)
6452 {
6453 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6454
6455 return (-1);
6456 }
6457 }
6458
6459 if (loopback == 1)
6460 {
6461 if (attack_mode == ATTACK_MODE_STRAIGHT)
6462 {
6463 if ((rp_files_cnt == 0) && (rp_gen == 0))
6464 {
6465 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6466
6467 return (-1);
6468 }
6469 }
6470 else
6471 {
6472 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6473
6474 return (-1);
6475 }
6476 }
6477
6478 if (debug_mode > 0)
6479 {
6480 if (attack_mode != ATTACK_MODE_STRAIGHT)
6481 {
6482 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6483
6484 return (-1);
6485 }
6486
6487 if ((rp_files_cnt == 0) && (rp_gen == 0))
6488 {
6489 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6490
6491 return (-1);
6492 }
6493 }
6494
6495 if (debug_mode > 4)
6496 {
6497 log_error ("ERROR: Invalid debug-mode specified");
6498
6499 return (-1);
6500 }
6501
6502 if (debug_file != NULL)
6503 {
6504 if (debug_mode < 1)
6505 {
6506 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6507
6508 return (-1);
6509 }
6510 }
6511
6512 if (induction_dir != NULL)
6513 {
6514 if (attack_mode == ATTACK_MODE_BF)
6515 {
6516 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6517
6518 return (-1);
6519 }
6520 }
6521
6522 if (attack_mode != ATTACK_MODE_STRAIGHT)
6523 {
6524 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6525 {
6526 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6527
6528 return (-1);
6529 }
6530
6531 weak_hash_threshold = 0;
6532 }
6533
6534 /**
6535 * induction directory
6536 */
6537
6538 char *induction_directory = NULL;
6539
6540 if (attack_mode != ATTACK_MODE_BF)
6541 {
6542 if (induction_dir == NULL)
6543 {
6544 induction_directory = (char *) mymalloc (session_size);
6545
6546 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6547
6548 // create induction folder if it does not already exist
6549
6550 if (keyspace == 0)
6551 {
6552 if (rmdir (induction_directory) == -1)
6553 {
6554 if (errno == ENOENT)
6555 {
6556 // good, we can ignore
6557 }
6558 else if (errno == ENOTEMPTY)
6559 {
6560 char *induction_directory_mv = (char *) mymalloc (session_size);
6561
6562 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6563
6564 if (rename (induction_directory, induction_directory_mv) != 0)
6565 {
6566 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6567
6568 return (-1);
6569 }
6570 }
6571 else
6572 {
6573 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6574
6575 return (-1);
6576 }
6577 }
6578
6579 if (mkdir (induction_directory, 0700) == -1)
6580 {
6581 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6582
6583 return (-1);
6584 }
6585 }
6586 }
6587 else
6588 {
6589 induction_directory = induction_dir;
6590 }
6591 }
6592
6593 data.induction_directory = induction_directory;
6594
6595 /**
6596 * loopback
6597 */
6598
6599 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6600
6601 char *loopback_file = (char *) mymalloc (loopback_size);
6602
6603 /**
6604 * tuning db
6605 */
6606
6607 char tuning_db_file[256] = { 0 };
6608
6609 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6610
6611 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6612
6613 /**
6614 * outfile-check directory
6615 */
6616
6617 char *outfile_check_directory = NULL;
6618
6619 if (outfile_check_dir == NULL)
6620 {
6621 outfile_check_directory = (char *) mymalloc (session_size);
6622
6623 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6624 }
6625 else
6626 {
6627 outfile_check_directory = outfile_check_dir;
6628 }
6629
6630 data.outfile_check_directory = outfile_check_directory;
6631
6632 if (keyspace == 0)
6633 {
6634 struct stat outfile_check_stat;
6635
6636 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6637 {
6638 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6639
6640 if (is_dir == 0)
6641 {
6642 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6643
6644 return (-1);
6645 }
6646 }
6647 else if (outfile_check_dir == NULL)
6648 {
6649 if (mkdir (outfile_check_directory, 0700) == -1)
6650 {
6651 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6652
6653 return (-1);
6654 }
6655 }
6656 }
6657
6658 /**
6659 * special other stuff
6660 */
6661
6662 if (hash_mode == 9710)
6663 {
6664 outfile_format = 5;
6665 outfile_format_chgd = 1;
6666 }
6667
6668 if (hash_mode == 9810)
6669 {
6670 outfile_format = 5;
6671 outfile_format_chgd = 1;
6672 }
6673
6674 if (hash_mode == 10410)
6675 {
6676 outfile_format = 5;
6677 outfile_format_chgd = 1;
6678 }
6679
6680 /**
6681 * store stuff
6682 */
6683
6684 data.hash_mode = hash_mode;
6685 data.restore = restore;
6686 data.restore_timer = restore_timer;
6687 data.restore_disable = restore_disable;
6688 data.status = status;
6689 data.status_timer = status_timer;
6690 data.machine_readable = machine_readable;
6691 data.loopback = loopback;
6692 data.runtime = runtime;
6693 data.remove = remove;
6694 data.remove_timer = remove_timer;
6695 data.debug_mode = debug_mode;
6696 data.debug_file = debug_file;
6697 data.username = username;
6698 data.quiet = quiet;
6699 data.outfile = outfile;
6700 data.outfile_format = outfile_format;
6701 data.outfile_autohex = outfile_autohex;
6702 data.hex_charset = hex_charset;
6703 data.hex_salt = hex_salt;
6704 data.hex_wordlist = hex_wordlist;
6705 data.separator = separator;
6706 data.rp_files = rp_files;
6707 data.rp_files_cnt = rp_files_cnt;
6708 data.rp_gen = rp_gen;
6709 data.rp_gen_seed = rp_gen_seed;
6710 data.force = force;
6711 data.benchmark = benchmark;
6712 data.skip = skip;
6713 data.limit = limit;
6714 #ifdef HAVE_HWMON
6715 #ifdef HAVE_ADL
6716 data.powertune_enable = powertune_enable;
6717 #endif
6718 #endif
6719 data.logfile_disable = logfile_disable;
6720 data.truecrypt_keyfiles = truecrypt_keyfiles;
6721 data.veracrypt_keyfiles = veracrypt_keyfiles;
6722 data.veracrypt_pim = veracrypt_pim;
6723 data.scrypt_tmto = scrypt_tmto;
6724 data.workload_profile = workload_profile;
6725
6726 /**
6727 * cpu affinity
6728 */
6729
6730 if (cpu_affinity)
6731 {
6732 set_cpu_affinity (cpu_affinity);
6733 }
6734
6735 if (rp_gen_seed_chgd == 0)
6736 {
6737 srand (proc_start);
6738 }
6739 else
6740 {
6741 srand (rp_gen_seed);
6742 }
6743
6744 /**
6745 * logfile init
6746 */
6747
6748 if (logfile_disable == 0)
6749 {
6750 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6751
6752 char *logfile = (char *) mymalloc (logfile_size);
6753
6754 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6755
6756 data.logfile = logfile;
6757
6758 char *topid = logfile_generate_topid ();
6759
6760 data.topid = topid;
6761 }
6762
6763 // logfile_append() checks for logfile_disable internally to make it easier from here
6764
6765 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6766 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6767 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6768 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6769 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6770 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6771 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6772 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6773 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6774 #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));
6775
6776 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6777 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6778 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6779 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6780 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6781 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6782 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6783 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6784
6785 logfile_top_msg ("START");
6786
6787 logfile_top_uint (attack_mode);
6788 logfile_top_uint (attack_kern);
6789 logfile_top_uint (benchmark);
6790 logfile_top_uint (bitmap_min);
6791 logfile_top_uint (bitmap_max);
6792 logfile_top_uint (debug_mode);
6793 logfile_top_uint (force);
6794 logfile_top_uint (kernel_accel);
6795 logfile_top_uint (kernel_loops);
6796 logfile_top_uint (gpu_temp_disable);
6797 #ifdef HAVE_HWMON
6798 logfile_top_uint (gpu_temp_abort);
6799 logfile_top_uint (gpu_temp_retain);
6800 #endif
6801 logfile_top_uint (hash_mode);
6802 logfile_top_uint (hex_charset);
6803 logfile_top_uint (hex_salt);
6804 logfile_top_uint (hex_wordlist);
6805 logfile_top_uint (increment);
6806 logfile_top_uint (increment_max);
6807 logfile_top_uint (increment_min);
6808 logfile_top_uint (keyspace);
6809 logfile_top_uint (left);
6810 logfile_top_uint (logfile_disable);
6811 logfile_top_uint (loopback);
6812 logfile_top_uint (markov_classic);
6813 logfile_top_uint (markov_disable);
6814 logfile_top_uint (markov_threshold);
6815 logfile_top_uint (outfile_autohex);
6816 logfile_top_uint (outfile_check_timer);
6817 logfile_top_uint (outfile_format);
6818 logfile_top_uint (potfile_disable);
6819 logfile_top_string (potfile_path);
6820 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6821 logfile_top_uint (powertune_enable);
6822 #endif
6823 logfile_top_uint (scrypt_tmto);
6824 logfile_top_uint (quiet);
6825 logfile_top_uint (remove);
6826 logfile_top_uint (remove_timer);
6827 logfile_top_uint (restore);
6828 logfile_top_uint (restore_disable);
6829 logfile_top_uint (restore_timer);
6830 logfile_top_uint (rp_gen);
6831 logfile_top_uint (rp_gen_func_max);
6832 logfile_top_uint (rp_gen_func_min);
6833 logfile_top_uint (rp_gen_seed);
6834 logfile_top_uint (runtime);
6835 logfile_top_uint (segment_size);
6836 logfile_top_uint (show);
6837 logfile_top_uint (status);
6838 logfile_top_uint (machine_readable);
6839 logfile_top_uint (status_timer);
6840 logfile_top_uint (usage);
6841 logfile_top_uint (username);
6842 logfile_top_uint (version);
6843 logfile_top_uint (weak_hash_threshold);
6844 logfile_top_uint (workload_profile);
6845 logfile_top_uint64 (limit);
6846 logfile_top_uint64 (skip);
6847 logfile_top_char (separator);
6848 logfile_top_string (cpu_affinity);
6849 logfile_top_string (custom_charset_1);
6850 logfile_top_string (custom_charset_2);
6851 logfile_top_string (custom_charset_3);
6852 logfile_top_string (custom_charset_4);
6853 logfile_top_string (debug_file);
6854 logfile_top_string (opencl_devices);
6855 logfile_top_string (opencl_platforms);
6856 logfile_top_string (opencl_device_types);
6857 logfile_top_uint (opencl_vector_width);
6858 logfile_top_string (induction_dir);
6859 logfile_top_string (markov_hcstat);
6860 logfile_top_string (outfile);
6861 logfile_top_string (outfile_check_dir);
6862 logfile_top_string (rule_buf_l);
6863 logfile_top_string (rule_buf_r);
6864 logfile_top_string (session);
6865 logfile_top_string (truecrypt_keyfiles);
6866 logfile_top_string (veracrypt_keyfiles);
6867 logfile_top_uint (veracrypt_pim);
6868
6869 /**
6870 * Init OpenCL library loader
6871 */
6872
6873 if (keyspace == 0)
6874 {
6875 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6876
6877 ocl_init (ocl);
6878
6879 data.ocl = ocl;
6880 }
6881
6882 /**
6883 * OpenCL platform selection
6884 */
6885
6886 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6887
6888 /**
6889 * OpenCL device selection
6890 */
6891
6892 u32 devices_filter = setup_devices_filter (opencl_devices);
6893
6894 /**
6895 * OpenCL device type selection
6896 */
6897
6898 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6899
6900 /**
6901 * benchmark
6902 */
6903
6904 if (benchmark == 1)
6905 {
6906 /**
6907 * disable useless stuff for benchmark
6908 */
6909
6910 status_timer = 0;
6911 restore_timer = 0;
6912 restore_disable = 1;
6913 potfile_disable = 1;
6914 weak_hash_threshold = 0;
6915 gpu_temp_disable = 1;
6916
6917 #ifdef HAVE_HWMON
6918 #ifdef HAVE_ADL
6919 powertune_enable = 1;
6920 #endif
6921 #endif
6922
6923 data.status_timer = status_timer;
6924 data.restore_timer = restore_timer;
6925 data.restore_disable = restore_disable;
6926
6927 /**
6928 * force attack mode to be bruteforce
6929 */
6930
6931 attack_mode = ATTACK_MODE_BF;
6932 attack_kern = ATTACK_KERN_BF;
6933
6934 if (workload_profile_chgd == 0)
6935 {
6936 workload_profile = 3;
6937
6938 data.workload_profile = workload_profile;
6939 }
6940 }
6941
6942 /**
6943 * config
6944 */
6945
6946 uint hash_type = 0;
6947 uint salt_type = 0;
6948 uint attack_exec = 0;
6949 uint opts_type = 0;
6950 uint kern_type = 0;
6951 uint dgst_size = 0;
6952 uint esalt_size = 0;
6953 uint opti_type = 0;
6954 uint dgst_pos0 = -1;
6955 uint dgst_pos1 = -1;
6956 uint dgst_pos2 = -1;
6957 uint dgst_pos3 = -1;
6958
6959 int (*parse_func) (char *, uint, hash_t *);
6960 int (*sort_by_digest) (const void *, const void *);
6961
6962 uint algorithm_pos = 0;
6963 uint algorithm_max = 1;
6964
6965 uint *algorithms = default_benchmark_algorithms;
6966
6967 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6968
6969 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6970 {
6971 /*
6972 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6973 * the following algos are skipped entirely
6974 */
6975
6976 if (algorithm_pos > 0)
6977 {
6978 local_free (rd);
6979
6980 rd = init_restore (argc, argv);
6981
6982 data.rd = rd;
6983 }
6984
6985 /**
6986 * update hash_mode in case of multihash benchmark
6987 */
6988
6989 if (benchmark == 1)
6990 {
6991 if (hash_mode_chgd == 0)
6992 {
6993 hash_mode = algorithms[algorithm_pos];
6994
6995 data.hash_mode = hash_mode;
6996 }
6997
6998 quiet = 1;
6999
7000 data.quiet = quiet;
7001 }
7002
7003 switch (hash_mode)
7004 {
7005 case 0: hash_type = HASH_TYPE_MD5;
7006 salt_type = SALT_TYPE_NONE;
7007 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7008 opts_type = OPTS_TYPE_PT_GENERATE_LE
7009 | OPTS_TYPE_PT_ADD80
7010 | OPTS_TYPE_PT_ADDBITS14;
7011 kern_type = KERN_TYPE_MD5;
7012 dgst_size = DGST_SIZE_4_4;
7013 parse_func = md5_parse_hash;
7014 sort_by_digest = sort_by_digest_4_4;
7015 opti_type = OPTI_TYPE_ZERO_BYTE
7016 | OPTI_TYPE_PRECOMPUTE_INIT
7017 | OPTI_TYPE_PRECOMPUTE_MERKLE
7018 | OPTI_TYPE_MEET_IN_MIDDLE
7019 | OPTI_TYPE_EARLY_SKIP
7020 | OPTI_TYPE_NOT_ITERATED
7021 | OPTI_TYPE_NOT_SALTED
7022 | OPTI_TYPE_RAW_HASH;
7023 dgst_pos0 = 0;
7024 dgst_pos1 = 3;
7025 dgst_pos2 = 2;
7026 dgst_pos3 = 1;
7027 break;
7028
7029 case 10: hash_type = HASH_TYPE_MD5;
7030 salt_type = SALT_TYPE_INTERN;
7031 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7032 opts_type = OPTS_TYPE_PT_GENERATE_LE
7033 | OPTS_TYPE_ST_ADD80
7034 | OPTS_TYPE_ST_ADDBITS14;
7035 kern_type = KERN_TYPE_MD5_PWSLT;
7036 dgst_size = DGST_SIZE_4_4;
7037 parse_func = md5s_parse_hash;
7038 sort_by_digest = sort_by_digest_4_4;
7039 opti_type = OPTI_TYPE_ZERO_BYTE
7040 | OPTI_TYPE_PRECOMPUTE_INIT
7041 | OPTI_TYPE_PRECOMPUTE_MERKLE
7042 | OPTI_TYPE_MEET_IN_MIDDLE
7043 | OPTI_TYPE_EARLY_SKIP
7044 | OPTI_TYPE_NOT_ITERATED
7045 | OPTI_TYPE_APPENDED_SALT
7046 | OPTI_TYPE_RAW_HASH;
7047 dgst_pos0 = 0;
7048 dgst_pos1 = 3;
7049 dgst_pos2 = 2;
7050 dgst_pos3 = 1;
7051 break;
7052
7053 case 11: hash_type = HASH_TYPE_MD5;
7054 salt_type = SALT_TYPE_INTERN;
7055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7056 opts_type = OPTS_TYPE_PT_GENERATE_LE
7057 | OPTS_TYPE_ST_ADD80
7058 | OPTS_TYPE_ST_ADDBITS14;
7059 kern_type = KERN_TYPE_MD5_PWSLT;
7060 dgst_size = DGST_SIZE_4_4;
7061 parse_func = joomla_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_APPENDED_SALT
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 12: 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 = postgresql_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 20: 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_PT_ADD80
7106 | OPTS_TYPE_PT_ADDBITS14;
7107 kern_type = KERN_TYPE_MD5_SLTPW;
7108 dgst_size = DGST_SIZE_4_4;
7109 parse_func = md5s_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_EARLY_SKIP
7115 | OPTI_TYPE_NOT_ITERATED
7116 | OPTI_TYPE_PREPENDED_SALT
7117 | OPTI_TYPE_RAW_HASH;
7118 dgst_pos0 = 0;
7119 dgst_pos1 = 3;
7120 dgst_pos2 = 2;
7121 dgst_pos3 = 1;
7122 break;
7123
7124 case 21: hash_type = HASH_TYPE_MD5;
7125 salt_type = SALT_TYPE_INTERN;
7126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7127 opts_type = OPTS_TYPE_PT_GENERATE_LE
7128 | OPTS_TYPE_PT_ADD80
7129 | OPTS_TYPE_PT_ADDBITS14;
7130 kern_type = KERN_TYPE_MD5_SLTPW;
7131 dgst_size = DGST_SIZE_4_4;
7132 parse_func = osc_parse_hash;
7133 sort_by_digest = sort_by_digest_4_4;
7134 opti_type = OPTI_TYPE_ZERO_BYTE
7135 | OPTI_TYPE_PRECOMPUTE_INIT
7136 | OPTI_TYPE_PRECOMPUTE_MERKLE
7137 | OPTI_TYPE_EARLY_SKIP
7138 | OPTI_TYPE_NOT_ITERATED
7139 | OPTI_TYPE_PREPENDED_SALT
7140 | OPTI_TYPE_RAW_HASH;
7141 dgst_pos0 = 0;
7142 dgst_pos1 = 3;
7143 dgst_pos2 = 2;
7144 dgst_pos3 = 1;
7145 break;
7146
7147 case 22: hash_type = HASH_TYPE_MD5;
7148 salt_type = SALT_TYPE_EMBEDDED;
7149 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7150 opts_type = OPTS_TYPE_PT_GENERATE_LE
7151 | OPTS_TYPE_PT_ADD80
7152 | OPTS_TYPE_PT_ADDBITS14;
7153 kern_type = KERN_TYPE_MD5_SLTPW;
7154 dgst_size = DGST_SIZE_4_4;
7155 parse_func = netscreen_parse_hash;
7156 sort_by_digest = sort_by_digest_4_4;
7157 opti_type = OPTI_TYPE_ZERO_BYTE
7158 | OPTI_TYPE_PRECOMPUTE_INIT
7159 | OPTI_TYPE_PRECOMPUTE_MERKLE
7160 | OPTI_TYPE_EARLY_SKIP
7161 | OPTI_TYPE_NOT_ITERATED
7162 | OPTI_TYPE_PREPENDED_SALT
7163 | OPTI_TYPE_RAW_HASH;
7164 dgst_pos0 = 0;
7165 dgst_pos1 = 3;
7166 dgst_pos2 = 2;
7167 dgst_pos3 = 1;
7168 break;
7169
7170 case 23: hash_type = HASH_TYPE_MD5;
7171 salt_type = SALT_TYPE_EMBEDDED;
7172 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7173 opts_type = OPTS_TYPE_PT_GENERATE_LE
7174 | OPTS_TYPE_PT_ADD80
7175 | OPTS_TYPE_PT_ADDBITS14;
7176 kern_type = KERN_TYPE_MD5_SLTPW;
7177 dgst_size = DGST_SIZE_4_4;
7178 parse_func = skype_parse_hash;
7179 sort_by_digest = sort_by_digest_4_4;
7180 opti_type = OPTI_TYPE_ZERO_BYTE
7181 | OPTI_TYPE_PRECOMPUTE_INIT
7182 | OPTI_TYPE_PRECOMPUTE_MERKLE
7183 | OPTI_TYPE_EARLY_SKIP
7184 | OPTI_TYPE_NOT_ITERATED
7185 | OPTI_TYPE_PREPENDED_SALT
7186 | OPTI_TYPE_RAW_HASH;
7187 dgst_pos0 = 0;
7188 dgst_pos1 = 3;
7189 dgst_pos2 = 2;
7190 dgst_pos3 = 1;
7191 break;
7192
7193 case 30: hash_type = HASH_TYPE_MD5;
7194 salt_type = SALT_TYPE_INTERN;
7195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7196 opts_type = OPTS_TYPE_PT_GENERATE_LE
7197 | OPTS_TYPE_PT_UNICODE
7198 | OPTS_TYPE_ST_ADD80
7199 | OPTS_TYPE_ST_ADDBITS14;
7200 kern_type = KERN_TYPE_MD5_PWUSLT;
7201 dgst_size = DGST_SIZE_4_4;
7202 parse_func = md5s_parse_hash;
7203 sort_by_digest = sort_by_digest_4_4;
7204 opti_type = OPTI_TYPE_ZERO_BYTE
7205 | OPTI_TYPE_PRECOMPUTE_INIT
7206 | OPTI_TYPE_PRECOMPUTE_MERKLE
7207 | OPTI_TYPE_MEET_IN_MIDDLE
7208 | OPTI_TYPE_EARLY_SKIP
7209 | OPTI_TYPE_NOT_ITERATED
7210 | OPTI_TYPE_APPENDED_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 40: hash_type = HASH_TYPE_MD5;
7219 salt_type = SALT_TYPE_INTERN;
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 | OPTS_TYPE_PT_UNICODE;
7225 kern_type = KERN_TYPE_MD5_SLTPWU;
7226 dgst_size = DGST_SIZE_4_4;
7227 parse_func = md5s_parse_hash;
7228 sort_by_digest = sort_by_digest_4_4;
7229 opti_type = OPTI_TYPE_ZERO_BYTE
7230 | OPTI_TYPE_PRECOMPUTE_INIT
7231 | OPTI_TYPE_PRECOMPUTE_MERKLE
7232 | OPTI_TYPE_EARLY_SKIP
7233 | OPTI_TYPE_NOT_ITERATED
7234 | OPTI_TYPE_PREPENDED_SALT
7235 | OPTI_TYPE_RAW_HASH;
7236 dgst_pos0 = 0;
7237 dgst_pos1 = 3;
7238 dgst_pos2 = 2;
7239 dgst_pos3 = 1;
7240 break;
7241
7242 case 50: hash_type = HASH_TYPE_MD5;
7243 salt_type = SALT_TYPE_INTERN;
7244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7245 opts_type = OPTS_TYPE_PT_GENERATE_LE
7246 | OPTS_TYPE_ST_ADD80
7247 | OPTS_TYPE_ST_ADDBITS14;
7248 kern_type = KERN_TYPE_HMACMD5_PW;
7249 dgst_size = DGST_SIZE_4_4;
7250 parse_func = hmacmd5_parse_hash;
7251 sort_by_digest = sort_by_digest_4_4;
7252 opti_type = OPTI_TYPE_ZERO_BYTE
7253 | OPTI_TYPE_NOT_ITERATED;
7254 dgst_pos0 = 0;
7255 dgst_pos1 = 3;
7256 dgst_pos2 = 2;
7257 dgst_pos3 = 1;
7258 break;
7259
7260 case 60: hash_type = HASH_TYPE_MD5;
7261 salt_type = SALT_TYPE_INTERN;
7262 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7263 opts_type = OPTS_TYPE_PT_GENERATE_LE
7264 | OPTS_TYPE_PT_ADD80
7265 | OPTS_TYPE_PT_ADDBITS14;
7266 kern_type = KERN_TYPE_HMACMD5_SLT;
7267 dgst_size = DGST_SIZE_4_4;
7268 parse_func = hmacmd5_parse_hash;
7269 sort_by_digest = sort_by_digest_4_4;
7270 opti_type = OPTI_TYPE_ZERO_BYTE
7271 | OPTI_TYPE_NOT_ITERATED;
7272 dgst_pos0 = 0;
7273 dgst_pos1 = 3;
7274 dgst_pos2 = 2;
7275 dgst_pos3 = 1;
7276 break;
7277
7278 case 100: hash_type = HASH_TYPE_SHA1;
7279 salt_type = SALT_TYPE_NONE;
7280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7281 opts_type = OPTS_TYPE_PT_GENERATE_BE
7282 | OPTS_TYPE_PT_ADD80
7283 | OPTS_TYPE_PT_ADDBITS15;
7284 kern_type = KERN_TYPE_SHA1;
7285 dgst_size = DGST_SIZE_4_5;
7286 parse_func = sha1_parse_hash;
7287 sort_by_digest = sort_by_digest_4_5;
7288 opti_type = OPTI_TYPE_ZERO_BYTE
7289 | OPTI_TYPE_PRECOMPUTE_INIT
7290 | OPTI_TYPE_PRECOMPUTE_MERKLE
7291 | OPTI_TYPE_EARLY_SKIP
7292 | OPTI_TYPE_NOT_ITERATED
7293 | OPTI_TYPE_NOT_SALTED
7294 | OPTI_TYPE_RAW_HASH;
7295 dgst_pos0 = 3;
7296 dgst_pos1 = 4;
7297 dgst_pos2 = 2;
7298 dgst_pos3 = 1;
7299 break;
7300
7301 case 101: hash_type = HASH_TYPE_SHA1;
7302 salt_type = SALT_TYPE_NONE;
7303 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7304 opts_type = OPTS_TYPE_PT_GENERATE_BE
7305 | OPTS_TYPE_PT_ADD80
7306 | OPTS_TYPE_PT_ADDBITS15;
7307 kern_type = KERN_TYPE_SHA1;
7308 dgst_size = DGST_SIZE_4_5;
7309 parse_func = sha1b64_parse_hash;
7310 sort_by_digest = sort_by_digest_4_5;
7311 opti_type = OPTI_TYPE_ZERO_BYTE
7312 | OPTI_TYPE_PRECOMPUTE_INIT
7313 | OPTI_TYPE_PRECOMPUTE_MERKLE
7314 | OPTI_TYPE_EARLY_SKIP
7315 | OPTI_TYPE_NOT_ITERATED
7316 | OPTI_TYPE_NOT_SALTED
7317 | OPTI_TYPE_RAW_HASH;
7318 dgst_pos0 = 3;
7319 dgst_pos1 = 4;
7320 dgst_pos2 = 2;
7321 dgst_pos3 = 1;
7322 break;
7323
7324 case 110: hash_type = HASH_TYPE_SHA1;
7325 salt_type = SALT_TYPE_INTERN;
7326 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7327 opts_type = OPTS_TYPE_PT_GENERATE_BE
7328 | OPTS_TYPE_ST_ADD80
7329 | OPTS_TYPE_ST_ADDBITS15;
7330 kern_type = KERN_TYPE_SHA1_PWSLT;
7331 dgst_size = DGST_SIZE_4_5;
7332 parse_func = sha1s_parse_hash;
7333 sort_by_digest = sort_by_digest_4_5;
7334 opti_type = OPTI_TYPE_ZERO_BYTE
7335 | OPTI_TYPE_PRECOMPUTE_INIT
7336 | OPTI_TYPE_PRECOMPUTE_MERKLE
7337 | OPTI_TYPE_EARLY_SKIP
7338 | OPTI_TYPE_NOT_ITERATED
7339 | OPTI_TYPE_APPENDED_SALT
7340 | OPTI_TYPE_RAW_HASH;
7341 dgst_pos0 = 3;
7342 dgst_pos1 = 4;
7343 dgst_pos2 = 2;
7344 dgst_pos3 = 1;
7345 break;
7346
7347 case 111: hash_type = HASH_TYPE_SHA1;
7348 salt_type = SALT_TYPE_EMBEDDED;
7349 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7350 opts_type = OPTS_TYPE_PT_GENERATE_BE
7351 | OPTS_TYPE_ST_ADD80
7352 | OPTS_TYPE_ST_ADDBITS15;
7353 kern_type = KERN_TYPE_SHA1_PWSLT;
7354 dgst_size = DGST_SIZE_4_5;
7355 parse_func = sha1b64s_parse_hash;
7356 sort_by_digest = sort_by_digest_4_5;
7357 opti_type = OPTI_TYPE_ZERO_BYTE
7358 | OPTI_TYPE_PRECOMPUTE_INIT
7359 | OPTI_TYPE_PRECOMPUTE_MERKLE
7360 | OPTI_TYPE_EARLY_SKIP
7361 | OPTI_TYPE_NOT_ITERATED
7362 | OPTI_TYPE_APPENDED_SALT
7363 | OPTI_TYPE_RAW_HASH;
7364 dgst_pos0 = 3;
7365 dgst_pos1 = 4;
7366 dgst_pos2 = 2;
7367 dgst_pos3 = 1;
7368 break;
7369
7370 case 112: hash_type = HASH_TYPE_SHA1;
7371 salt_type = SALT_TYPE_INTERN;
7372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7373 opts_type = OPTS_TYPE_PT_GENERATE_BE
7374 | OPTS_TYPE_ST_ADD80
7375 | OPTS_TYPE_ST_ADDBITS15
7376 | OPTS_TYPE_ST_HEX;
7377 kern_type = KERN_TYPE_SHA1_PWSLT;
7378 dgst_size = DGST_SIZE_4_5;
7379 parse_func = oracles_parse_hash;
7380 sort_by_digest = sort_by_digest_4_5;
7381 opti_type = OPTI_TYPE_ZERO_BYTE
7382 | OPTI_TYPE_PRECOMPUTE_INIT
7383 | OPTI_TYPE_PRECOMPUTE_MERKLE
7384 | OPTI_TYPE_EARLY_SKIP
7385 | OPTI_TYPE_NOT_ITERATED
7386 | OPTI_TYPE_APPENDED_SALT
7387 | OPTI_TYPE_RAW_HASH;
7388 dgst_pos0 = 3;
7389 dgst_pos1 = 4;
7390 dgst_pos2 = 2;
7391 dgst_pos3 = 1;
7392 break;
7393
7394 case 120: hash_type = HASH_TYPE_SHA1;
7395 salt_type = SALT_TYPE_INTERN;
7396 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7397 opts_type = OPTS_TYPE_PT_GENERATE_BE
7398 | OPTS_TYPE_PT_ADD80
7399 | OPTS_TYPE_PT_ADDBITS15;
7400 kern_type = KERN_TYPE_SHA1_SLTPW;
7401 dgst_size = DGST_SIZE_4_5;
7402 parse_func = sha1s_parse_hash;
7403 sort_by_digest = sort_by_digest_4_5;
7404 opti_type = OPTI_TYPE_ZERO_BYTE
7405 | OPTI_TYPE_PRECOMPUTE_INIT
7406 | OPTI_TYPE_PRECOMPUTE_MERKLE
7407 | OPTI_TYPE_EARLY_SKIP
7408 | OPTI_TYPE_NOT_ITERATED
7409 | OPTI_TYPE_PREPENDED_SALT
7410 | OPTI_TYPE_RAW_HASH;
7411 dgst_pos0 = 3;
7412 dgst_pos1 = 4;
7413 dgst_pos2 = 2;
7414 dgst_pos3 = 1;
7415 break;
7416
7417 case 121: hash_type = HASH_TYPE_SHA1;
7418 salt_type = SALT_TYPE_INTERN;
7419 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7420 opts_type = OPTS_TYPE_PT_GENERATE_BE
7421 | OPTS_TYPE_PT_ADD80
7422 | OPTS_TYPE_PT_ADDBITS15
7423 | OPTS_TYPE_ST_LOWER;
7424 kern_type = KERN_TYPE_SHA1_SLTPW;
7425 dgst_size = DGST_SIZE_4_5;
7426 parse_func = smf_parse_hash;
7427 sort_by_digest = sort_by_digest_4_5;
7428 opti_type = OPTI_TYPE_ZERO_BYTE
7429 | OPTI_TYPE_PRECOMPUTE_INIT
7430 | OPTI_TYPE_PRECOMPUTE_MERKLE
7431 | OPTI_TYPE_EARLY_SKIP
7432 | OPTI_TYPE_NOT_ITERATED
7433 | OPTI_TYPE_PREPENDED_SALT
7434 | OPTI_TYPE_RAW_HASH;
7435 dgst_pos0 = 3;
7436 dgst_pos1 = 4;
7437 dgst_pos2 = 2;
7438 dgst_pos3 = 1;
7439 break;
7440
7441 case 122: hash_type = HASH_TYPE_SHA1;
7442 salt_type = SALT_TYPE_EMBEDDED;
7443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7444 opts_type = OPTS_TYPE_PT_GENERATE_BE
7445 | OPTS_TYPE_PT_ADD80
7446 | OPTS_TYPE_PT_ADDBITS15
7447 | OPTS_TYPE_ST_HEX;
7448 kern_type = KERN_TYPE_SHA1_SLTPW;
7449 dgst_size = DGST_SIZE_4_5;
7450 parse_func = osx1_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 124: hash_type = HASH_TYPE_SHA1;
7466 salt_type = SALT_TYPE_EMBEDDED;
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 kern_type = KERN_TYPE_SHA1_SLTPW;
7472 dgst_size = DGST_SIZE_4_5;
7473 parse_func = djangosha1_parse_hash;
7474 sort_by_digest = sort_by_digest_4_5;
7475 opti_type = OPTI_TYPE_ZERO_BYTE
7476 | OPTI_TYPE_PRECOMPUTE_INIT
7477 | OPTI_TYPE_PRECOMPUTE_MERKLE
7478 | OPTI_TYPE_EARLY_SKIP
7479 | OPTI_TYPE_NOT_ITERATED
7480 | OPTI_TYPE_PREPENDED_SALT
7481 | OPTI_TYPE_RAW_HASH;
7482 dgst_pos0 = 3;
7483 dgst_pos1 = 4;
7484 dgst_pos2 = 2;
7485 dgst_pos3 = 1;
7486 break;
7487
7488 case 125: hash_type = HASH_TYPE_SHA1;
7489 salt_type = SALT_TYPE_EMBEDDED;
7490 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7491 opts_type = OPTS_TYPE_PT_GENERATE_BE
7492 | OPTS_TYPE_PT_ADD80
7493 | OPTS_TYPE_PT_ADDBITS15
7494 | OPTS_TYPE_ST_HEX;
7495 kern_type = KERN_TYPE_SHA1_SLTPW;
7496 dgst_size = DGST_SIZE_4_5;
7497 parse_func = arubaos_parse_hash;
7498 sort_by_digest = sort_by_digest_4_5;
7499 opti_type = OPTI_TYPE_ZERO_BYTE
7500 | OPTI_TYPE_PRECOMPUTE_INIT
7501 | OPTI_TYPE_PRECOMPUTE_MERKLE
7502 | OPTI_TYPE_EARLY_SKIP
7503 | OPTI_TYPE_NOT_ITERATED
7504 | OPTI_TYPE_PREPENDED_SALT
7505 | OPTI_TYPE_RAW_HASH;
7506 dgst_pos0 = 3;
7507 dgst_pos1 = 4;
7508 dgst_pos2 = 2;
7509 dgst_pos3 = 1;
7510 break;
7511
7512 case 130: hash_type = HASH_TYPE_SHA1;
7513 salt_type = SALT_TYPE_INTERN;
7514 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7515 opts_type = OPTS_TYPE_PT_GENERATE_BE
7516 | OPTS_TYPE_PT_UNICODE
7517 | OPTS_TYPE_ST_ADD80
7518 | OPTS_TYPE_ST_ADDBITS15;
7519 kern_type = KERN_TYPE_SHA1_PWUSLT;
7520 dgst_size = DGST_SIZE_4_5;
7521 parse_func = sha1s_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_APPENDED_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 131: 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_UNICODE
7541 | OPTS_TYPE_PT_UPPER
7542 | OPTS_TYPE_ST_ADD80
7543 | OPTS_TYPE_ST_ADDBITS15
7544 | OPTS_TYPE_ST_HEX;
7545 kern_type = KERN_TYPE_SHA1_PWUSLT;
7546 dgst_size = DGST_SIZE_4_5;
7547 parse_func = mssql2000_parse_hash;
7548 sort_by_digest = sort_by_digest_4_5;
7549 opti_type = OPTI_TYPE_ZERO_BYTE
7550 | OPTI_TYPE_PRECOMPUTE_INIT
7551 | OPTI_TYPE_PRECOMPUTE_MERKLE
7552 | OPTI_TYPE_EARLY_SKIP
7553 | OPTI_TYPE_NOT_ITERATED
7554 | OPTI_TYPE_APPENDED_SALT
7555 | OPTI_TYPE_RAW_HASH;
7556 dgst_pos0 = 3;
7557 dgst_pos1 = 4;
7558 dgst_pos2 = 2;
7559 dgst_pos3 = 1;
7560 break;
7561
7562 case 132: hash_type = HASH_TYPE_SHA1;
7563 salt_type = SALT_TYPE_EMBEDDED;
7564 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7565 opts_type = OPTS_TYPE_PT_GENERATE_BE
7566 | OPTS_TYPE_PT_UNICODE
7567 | OPTS_TYPE_ST_ADD80
7568 | OPTS_TYPE_ST_ADDBITS15
7569 | OPTS_TYPE_ST_HEX;
7570 kern_type = KERN_TYPE_SHA1_PWUSLT;
7571 dgst_size = DGST_SIZE_4_5;
7572 parse_func = mssql2005_parse_hash;
7573 sort_by_digest = sort_by_digest_4_5;
7574 opti_type = OPTI_TYPE_ZERO_BYTE
7575 | OPTI_TYPE_PRECOMPUTE_INIT
7576 | OPTI_TYPE_PRECOMPUTE_MERKLE
7577 | OPTI_TYPE_EARLY_SKIP
7578 | OPTI_TYPE_NOT_ITERATED
7579 | OPTI_TYPE_APPENDED_SALT
7580 | OPTI_TYPE_RAW_HASH;
7581 dgst_pos0 = 3;
7582 dgst_pos1 = 4;
7583 dgst_pos2 = 2;
7584 dgst_pos3 = 1;
7585 break;
7586
7587 case 133: hash_type = HASH_TYPE_SHA1;
7588 salt_type = SALT_TYPE_EMBEDDED;
7589 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7590 opts_type = OPTS_TYPE_PT_GENERATE_BE
7591 | OPTS_TYPE_PT_UNICODE
7592 | OPTS_TYPE_ST_ADD80
7593 | OPTS_TYPE_ST_ADDBITS15;
7594 kern_type = KERN_TYPE_SHA1_PWUSLT;
7595 dgst_size = DGST_SIZE_4_5;
7596 parse_func = peoplesoft_parse_hash;
7597 sort_by_digest = sort_by_digest_4_5;
7598 opti_type = OPTI_TYPE_ZERO_BYTE
7599 | OPTI_TYPE_PRECOMPUTE_INIT
7600 | OPTI_TYPE_PRECOMPUTE_MERKLE
7601 | OPTI_TYPE_EARLY_SKIP
7602 | OPTI_TYPE_NOT_ITERATED
7603 | OPTI_TYPE_APPENDED_SALT
7604 | OPTI_TYPE_RAW_HASH;
7605 dgst_pos0 = 3;
7606 dgst_pos1 = 4;
7607 dgst_pos2 = 2;
7608 dgst_pos3 = 1;
7609 break;
7610
7611 case 140: hash_type = HASH_TYPE_SHA1;
7612 salt_type = SALT_TYPE_INTERN;
7613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7614 opts_type = OPTS_TYPE_PT_GENERATE_BE
7615 | OPTS_TYPE_PT_ADD80
7616 | OPTS_TYPE_PT_ADDBITS15
7617 | OPTS_TYPE_PT_UNICODE;
7618 kern_type = KERN_TYPE_SHA1_SLTPWU;
7619 dgst_size = DGST_SIZE_4_5;
7620 parse_func = sha1s_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_PREPENDED_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 141: 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_ADD80
7640 | OPTS_TYPE_PT_ADDBITS15
7641 | OPTS_TYPE_PT_UNICODE
7642 | OPTS_TYPE_ST_BASE64;
7643 kern_type = KERN_TYPE_SHA1_SLTPWU;
7644 dgst_size = DGST_SIZE_4_5;
7645 parse_func = episerver_parse_hash;
7646 sort_by_digest = sort_by_digest_4_5;
7647 opti_type = OPTI_TYPE_ZERO_BYTE
7648 | OPTI_TYPE_PRECOMPUTE_INIT
7649 | OPTI_TYPE_PRECOMPUTE_MERKLE
7650 | OPTI_TYPE_EARLY_SKIP
7651 | OPTI_TYPE_NOT_ITERATED
7652 | OPTI_TYPE_PREPENDED_SALT
7653 | OPTI_TYPE_RAW_HASH;
7654 dgst_pos0 = 3;
7655 dgst_pos1 = 4;
7656 dgst_pos2 = 2;
7657 dgst_pos3 = 1;
7658 break;
7659
7660 case 150: hash_type = HASH_TYPE_SHA1;
7661 salt_type = SALT_TYPE_INTERN;
7662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7663 opts_type = OPTS_TYPE_PT_GENERATE_BE
7664 | OPTS_TYPE_ST_ADD80
7665 | OPTS_TYPE_ST_ADDBITS15;
7666 kern_type = KERN_TYPE_HMACSHA1_PW;
7667 dgst_size = DGST_SIZE_4_5;
7668 parse_func = hmacsha1_parse_hash;
7669 sort_by_digest = sort_by_digest_4_5;
7670 opti_type = OPTI_TYPE_ZERO_BYTE
7671 | OPTI_TYPE_NOT_ITERATED;
7672 dgst_pos0 = 3;
7673 dgst_pos1 = 4;
7674 dgst_pos2 = 2;
7675 dgst_pos3 = 1;
7676 break;
7677
7678 case 160: hash_type = HASH_TYPE_SHA1;
7679 salt_type = SALT_TYPE_INTERN;
7680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7681 opts_type = OPTS_TYPE_PT_GENERATE_BE
7682 | OPTS_TYPE_PT_ADD80
7683 | OPTS_TYPE_PT_ADDBITS15;
7684 kern_type = KERN_TYPE_HMACSHA1_SLT;
7685 dgst_size = DGST_SIZE_4_5;
7686 parse_func = hmacsha1_parse_hash;
7687 sort_by_digest = sort_by_digest_4_5;
7688 opti_type = OPTI_TYPE_ZERO_BYTE
7689 | OPTI_TYPE_NOT_ITERATED;
7690 dgst_pos0 = 3;
7691 dgst_pos1 = 4;
7692 dgst_pos2 = 2;
7693 dgst_pos3 = 1;
7694 break;
7695
7696 case 190: hash_type = HASH_TYPE_SHA1;
7697 salt_type = SALT_TYPE_NONE;
7698 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7699 opts_type = OPTS_TYPE_PT_GENERATE_BE
7700 | OPTS_TYPE_PT_ADD80
7701 | OPTS_TYPE_PT_ADDBITS15;
7702 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7703 dgst_size = DGST_SIZE_4_5;
7704 parse_func = sha1linkedin_parse_hash;
7705 sort_by_digest = sort_by_digest_4_5;
7706 opti_type = OPTI_TYPE_ZERO_BYTE
7707 | OPTI_TYPE_PRECOMPUTE_INIT
7708 | OPTI_TYPE_EARLY_SKIP
7709 | OPTI_TYPE_NOT_ITERATED
7710 | OPTI_TYPE_NOT_SALTED;
7711 dgst_pos0 = 0;
7712 dgst_pos1 = 4;
7713 dgst_pos2 = 3;
7714 dgst_pos3 = 2;
7715 break;
7716
7717 case 200: hash_type = HASH_TYPE_MYSQL;
7718 salt_type = SALT_TYPE_NONE;
7719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7720 opts_type = 0;
7721 kern_type = KERN_TYPE_MYSQL;
7722 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7723 parse_func = mysql323_parse_hash;
7724 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7725 opti_type = OPTI_TYPE_ZERO_BYTE;
7726 dgst_pos0 = 0;
7727 dgst_pos1 = 1;
7728 dgst_pos2 = 2;
7729 dgst_pos3 = 3;
7730 break;
7731
7732 case 300: hash_type = HASH_TYPE_SHA1;
7733 salt_type = SALT_TYPE_NONE;
7734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7735 opts_type = OPTS_TYPE_PT_GENERATE_BE
7736 | OPTS_TYPE_PT_ADD80
7737 | OPTS_TYPE_PT_ADDBITS15;
7738 kern_type = KERN_TYPE_MYSQL41;
7739 dgst_size = DGST_SIZE_4_5;
7740 parse_func = sha1_parse_hash;
7741 sort_by_digest = sort_by_digest_4_5;
7742 opti_type = OPTI_TYPE_ZERO_BYTE
7743 | OPTI_TYPE_PRECOMPUTE_INIT
7744 | OPTI_TYPE_PRECOMPUTE_MERKLE
7745 | OPTI_TYPE_EARLY_SKIP
7746 | OPTI_TYPE_NOT_ITERATED
7747 | OPTI_TYPE_NOT_SALTED;
7748 dgst_pos0 = 3;
7749 dgst_pos1 = 4;
7750 dgst_pos2 = 2;
7751 dgst_pos3 = 1;
7752 break;
7753
7754 case 400: hash_type = HASH_TYPE_MD5;
7755 salt_type = SALT_TYPE_EMBEDDED;
7756 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7757 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7758 kern_type = KERN_TYPE_PHPASS;
7759 dgst_size = DGST_SIZE_4_4;
7760 parse_func = phpass_parse_hash;
7761 sort_by_digest = sort_by_digest_4_4;
7762 opti_type = OPTI_TYPE_ZERO_BYTE
7763 | OPTI_TYPE_SLOW_HASH_SIMD;
7764 dgst_pos0 = 0;
7765 dgst_pos1 = 1;
7766 dgst_pos2 = 2;
7767 dgst_pos3 = 3;
7768 break;
7769
7770 case 500: hash_type = HASH_TYPE_MD5;
7771 salt_type = SALT_TYPE_EMBEDDED;
7772 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7773 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7774 kern_type = KERN_TYPE_MD5CRYPT;
7775 dgst_size = DGST_SIZE_4_4;
7776 parse_func = md5crypt_parse_hash;
7777 sort_by_digest = sort_by_digest_4_4;
7778 opti_type = OPTI_TYPE_ZERO_BYTE;
7779 dgst_pos0 = 0;
7780 dgst_pos1 = 1;
7781 dgst_pos2 = 2;
7782 dgst_pos3 = 3;
7783 break;
7784
7785 case 501: hash_type = HASH_TYPE_MD5;
7786 salt_type = SALT_TYPE_EMBEDDED;
7787 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7788 opts_type = OPTS_TYPE_PT_GENERATE_LE
7789 | OPTS_TYPE_HASH_COPY;
7790 kern_type = KERN_TYPE_MD5CRYPT;
7791 dgst_size = DGST_SIZE_4_4;
7792 parse_func = juniper_parse_hash;
7793 sort_by_digest = sort_by_digest_4_4;
7794 opti_type = OPTI_TYPE_ZERO_BYTE;
7795 dgst_pos0 = 0;
7796 dgst_pos1 = 1;
7797 dgst_pos2 = 2;
7798 dgst_pos3 = 3;
7799 break;
7800
7801 case 900: hash_type = HASH_TYPE_MD4;
7802 salt_type = SALT_TYPE_NONE;
7803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7804 opts_type = OPTS_TYPE_PT_GENERATE_LE
7805 | OPTS_TYPE_PT_ADD80
7806 | OPTS_TYPE_PT_ADDBITS14;
7807 kern_type = KERN_TYPE_MD4;
7808 dgst_size = DGST_SIZE_4_4;
7809 parse_func = md4_parse_hash;
7810 sort_by_digest = sort_by_digest_4_4;
7811 opti_type = OPTI_TYPE_ZERO_BYTE
7812 | OPTI_TYPE_PRECOMPUTE_INIT
7813 | OPTI_TYPE_PRECOMPUTE_MERKLE
7814 | OPTI_TYPE_MEET_IN_MIDDLE
7815 | OPTI_TYPE_EARLY_SKIP
7816 | OPTI_TYPE_NOT_ITERATED
7817 | OPTI_TYPE_NOT_SALTED
7818 | OPTI_TYPE_RAW_HASH;
7819 dgst_pos0 = 0;
7820 dgst_pos1 = 3;
7821 dgst_pos2 = 2;
7822 dgst_pos3 = 1;
7823 break;
7824
7825 case 1000: hash_type = HASH_TYPE_MD4;
7826 salt_type = SALT_TYPE_NONE;
7827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7828 opts_type = OPTS_TYPE_PT_GENERATE_LE
7829 | OPTS_TYPE_PT_ADD80
7830 | OPTS_TYPE_PT_ADDBITS14
7831 | OPTS_TYPE_PT_UNICODE;
7832 kern_type = KERN_TYPE_MD4_PWU;
7833 dgst_size = DGST_SIZE_4_4;
7834 parse_func = md4_parse_hash;
7835 sort_by_digest = sort_by_digest_4_4;
7836 opti_type = OPTI_TYPE_ZERO_BYTE
7837 | OPTI_TYPE_PRECOMPUTE_INIT
7838 | OPTI_TYPE_PRECOMPUTE_MERKLE
7839 | OPTI_TYPE_MEET_IN_MIDDLE
7840 | OPTI_TYPE_EARLY_SKIP
7841 | OPTI_TYPE_NOT_ITERATED
7842 | OPTI_TYPE_NOT_SALTED
7843 | OPTI_TYPE_RAW_HASH;
7844 dgst_pos0 = 0;
7845 dgst_pos1 = 3;
7846 dgst_pos2 = 2;
7847 dgst_pos3 = 1;
7848 break;
7849
7850 case 1100: hash_type = HASH_TYPE_MD4;
7851 salt_type = SALT_TYPE_INTERN;
7852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7853 opts_type = OPTS_TYPE_PT_GENERATE_LE
7854 | OPTS_TYPE_PT_ADD80
7855 | OPTS_TYPE_PT_ADDBITS14
7856 | OPTS_TYPE_PT_UNICODE
7857 | OPTS_TYPE_ST_ADD80
7858 | OPTS_TYPE_ST_UNICODE
7859 | OPTS_TYPE_ST_LOWER;
7860 kern_type = KERN_TYPE_MD44_PWUSLT;
7861 dgst_size = DGST_SIZE_4_4;
7862 parse_func = dcc_parse_hash;
7863 sort_by_digest = sort_by_digest_4_4;
7864 opti_type = OPTI_TYPE_ZERO_BYTE
7865 | OPTI_TYPE_PRECOMPUTE_INIT
7866 | OPTI_TYPE_PRECOMPUTE_MERKLE
7867 | OPTI_TYPE_EARLY_SKIP
7868 | OPTI_TYPE_NOT_ITERATED;
7869 dgst_pos0 = 0;
7870 dgst_pos1 = 3;
7871 dgst_pos2 = 2;
7872 dgst_pos3 = 1;
7873 break;
7874
7875 case 1400: hash_type = HASH_TYPE_SHA256;
7876 salt_type = SALT_TYPE_NONE;
7877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7878 opts_type = OPTS_TYPE_PT_GENERATE_BE
7879 | OPTS_TYPE_PT_ADD80
7880 | OPTS_TYPE_PT_ADDBITS15;
7881 kern_type = KERN_TYPE_SHA256;
7882 dgst_size = DGST_SIZE_4_8;
7883 parse_func = sha256_parse_hash;
7884 sort_by_digest = sort_by_digest_4_8;
7885 opti_type = OPTI_TYPE_ZERO_BYTE
7886 | OPTI_TYPE_PRECOMPUTE_INIT
7887 | OPTI_TYPE_PRECOMPUTE_MERKLE
7888 | OPTI_TYPE_EARLY_SKIP
7889 | OPTI_TYPE_NOT_ITERATED
7890 | OPTI_TYPE_NOT_SALTED
7891 | OPTI_TYPE_RAW_HASH;
7892 dgst_pos0 = 3;
7893 dgst_pos1 = 7;
7894 dgst_pos2 = 2;
7895 dgst_pos3 = 6;
7896 break;
7897
7898 case 1410: hash_type = HASH_TYPE_SHA256;
7899 salt_type = SALT_TYPE_INTERN;
7900 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7901 opts_type = OPTS_TYPE_PT_GENERATE_BE
7902 | OPTS_TYPE_ST_ADD80
7903 | OPTS_TYPE_ST_ADDBITS15;
7904 kern_type = KERN_TYPE_SHA256_PWSLT;
7905 dgst_size = DGST_SIZE_4_8;
7906 parse_func = sha256s_parse_hash;
7907 sort_by_digest = sort_by_digest_4_8;
7908 opti_type = OPTI_TYPE_ZERO_BYTE
7909 | OPTI_TYPE_PRECOMPUTE_INIT
7910 | OPTI_TYPE_PRECOMPUTE_MERKLE
7911 | OPTI_TYPE_EARLY_SKIP
7912 | OPTI_TYPE_NOT_ITERATED
7913 | OPTI_TYPE_APPENDED_SALT
7914 | OPTI_TYPE_RAW_HASH;
7915 dgst_pos0 = 3;
7916 dgst_pos1 = 7;
7917 dgst_pos2 = 2;
7918 dgst_pos3 = 6;
7919 break;
7920
7921 case 1420: hash_type = HASH_TYPE_SHA256;
7922 salt_type = SALT_TYPE_INTERN;
7923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7924 opts_type = OPTS_TYPE_PT_GENERATE_BE
7925 | OPTS_TYPE_PT_ADD80
7926 | OPTS_TYPE_PT_ADDBITS15;
7927 kern_type = KERN_TYPE_SHA256_SLTPW;
7928 dgst_size = DGST_SIZE_4_8;
7929 parse_func = sha256s_parse_hash;
7930 sort_by_digest = sort_by_digest_4_8;
7931 opti_type = OPTI_TYPE_ZERO_BYTE
7932 | OPTI_TYPE_PRECOMPUTE_INIT
7933 | OPTI_TYPE_PRECOMPUTE_MERKLE
7934 | OPTI_TYPE_EARLY_SKIP
7935 | OPTI_TYPE_NOT_ITERATED
7936 | OPTI_TYPE_PREPENDED_SALT
7937 | OPTI_TYPE_RAW_HASH;
7938 dgst_pos0 = 3;
7939 dgst_pos1 = 7;
7940 dgst_pos2 = 2;
7941 dgst_pos3 = 6;
7942 break;
7943
7944 case 1421: hash_type = HASH_TYPE_SHA256;
7945 salt_type = SALT_TYPE_EMBEDDED;
7946 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7947 opts_type = OPTS_TYPE_PT_GENERATE_BE
7948 | OPTS_TYPE_PT_ADD80
7949 | OPTS_TYPE_PT_ADDBITS15;
7950 kern_type = KERN_TYPE_SHA256_SLTPW;
7951 dgst_size = DGST_SIZE_4_8;
7952 parse_func = hmailserver_parse_hash;
7953 sort_by_digest = sort_by_digest_4_8;
7954 opti_type = OPTI_TYPE_ZERO_BYTE
7955 | OPTI_TYPE_PRECOMPUTE_INIT
7956 | OPTI_TYPE_PRECOMPUTE_MERKLE
7957 | OPTI_TYPE_EARLY_SKIP
7958 | OPTI_TYPE_NOT_ITERATED
7959 | OPTI_TYPE_PREPENDED_SALT
7960 | OPTI_TYPE_RAW_HASH;
7961 dgst_pos0 = 3;
7962 dgst_pos1 = 7;
7963 dgst_pos2 = 2;
7964 dgst_pos3 = 6;
7965 break;
7966
7967 case 1430: hash_type = HASH_TYPE_SHA256;
7968 salt_type = SALT_TYPE_INTERN;
7969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7970 opts_type = OPTS_TYPE_PT_GENERATE_BE
7971 | OPTS_TYPE_PT_UNICODE
7972 | OPTS_TYPE_ST_ADD80
7973 | OPTS_TYPE_ST_ADDBITS15;
7974 kern_type = KERN_TYPE_SHA256_PWUSLT;
7975 dgst_size = DGST_SIZE_4_8;
7976 parse_func = sha256s_parse_hash;
7977 sort_by_digest = sort_by_digest_4_8;
7978 opti_type = OPTI_TYPE_ZERO_BYTE
7979 | OPTI_TYPE_PRECOMPUTE_INIT
7980 | OPTI_TYPE_PRECOMPUTE_MERKLE
7981 | OPTI_TYPE_EARLY_SKIP
7982 | OPTI_TYPE_NOT_ITERATED
7983 | OPTI_TYPE_APPENDED_SALT
7984 | OPTI_TYPE_RAW_HASH;
7985 dgst_pos0 = 3;
7986 dgst_pos1 = 7;
7987 dgst_pos2 = 2;
7988 dgst_pos3 = 6;
7989 break;
7990
7991 case 1440: hash_type = HASH_TYPE_SHA256;
7992 salt_type = SALT_TYPE_INTERN;
7993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7994 opts_type = OPTS_TYPE_PT_GENERATE_BE
7995 | OPTS_TYPE_PT_ADD80
7996 | OPTS_TYPE_PT_ADDBITS15
7997 | OPTS_TYPE_PT_UNICODE;
7998 kern_type = KERN_TYPE_SHA256_SLTPWU;
7999 dgst_size = DGST_SIZE_4_8;
8000 parse_func = sha256s_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 1441: hash_type = HASH_TYPE_SHA256;
8016 salt_type = SALT_TYPE_EMBEDDED;
8017 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8018 opts_type = OPTS_TYPE_PT_GENERATE_BE
8019 | OPTS_TYPE_PT_ADD80
8020 | OPTS_TYPE_PT_ADDBITS15
8021 | OPTS_TYPE_PT_UNICODE
8022 | OPTS_TYPE_ST_BASE64;
8023 kern_type = KERN_TYPE_SHA256_SLTPWU;
8024 dgst_size = DGST_SIZE_4_8;
8025 parse_func = episerver4_parse_hash;
8026 sort_by_digest = sort_by_digest_4_8;
8027 opti_type = OPTI_TYPE_ZERO_BYTE
8028 | OPTI_TYPE_PRECOMPUTE_INIT
8029 | OPTI_TYPE_PRECOMPUTE_MERKLE
8030 | OPTI_TYPE_EARLY_SKIP
8031 | OPTI_TYPE_NOT_ITERATED
8032 | OPTI_TYPE_PREPENDED_SALT
8033 | OPTI_TYPE_RAW_HASH;
8034 dgst_pos0 = 3;
8035 dgst_pos1 = 7;
8036 dgst_pos2 = 2;
8037 dgst_pos3 = 6;
8038 break;
8039
8040 case 1450: hash_type = HASH_TYPE_SHA256;
8041 salt_type = SALT_TYPE_INTERN;
8042 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8043 opts_type = OPTS_TYPE_PT_GENERATE_BE
8044 | OPTS_TYPE_ST_ADD80;
8045 kern_type = KERN_TYPE_HMACSHA256_PW;
8046 dgst_size = DGST_SIZE_4_8;
8047 parse_func = hmacsha256_parse_hash;
8048 sort_by_digest = sort_by_digest_4_8;
8049 opti_type = OPTI_TYPE_ZERO_BYTE
8050 | OPTI_TYPE_NOT_ITERATED;
8051 dgst_pos0 = 3;
8052 dgst_pos1 = 7;
8053 dgst_pos2 = 2;
8054 dgst_pos3 = 6;
8055 break;
8056
8057 case 1460: hash_type = HASH_TYPE_SHA256;
8058 salt_type = SALT_TYPE_INTERN;
8059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8060 opts_type = OPTS_TYPE_PT_GENERATE_BE
8061 | OPTS_TYPE_PT_ADD80
8062 | OPTS_TYPE_PT_ADDBITS15;
8063 kern_type = KERN_TYPE_HMACSHA256_SLT;
8064 dgst_size = DGST_SIZE_4_8;
8065 parse_func = hmacsha256_parse_hash;
8066 sort_by_digest = sort_by_digest_4_8;
8067 opti_type = OPTI_TYPE_ZERO_BYTE
8068 | OPTI_TYPE_NOT_ITERATED;
8069 dgst_pos0 = 3;
8070 dgst_pos1 = 7;
8071 dgst_pos2 = 2;
8072 dgst_pos3 = 6;
8073 break;
8074
8075 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8076 salt_type = SALT_TYPE_EMBEDDED;
8077 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8078 opts_type = OPTS_TYPE_PT_GENERATE_LE
8079 | OPTS_TYPE_PT_BITSLICE;
8080 kern_type = KERN_TYPE_DESCRYPT;
8081 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8082 parse_func = descrypt_parse_hash;
8083 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8084 opti_type = OPTI_TYPE_ZERO_BYTE
8085 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8086 dgst_pos0 = 0;
8087 dgst_pos1 = 1;
8088 dgst_pos2 = 2;
8089 dgst_pos3 = 3;
8090 break;
8091
8092 case 1600: hash_type = HASH_TYPE_MD5;
8093 salt_type = SALT_TYPE_EMBEDDED;
8094 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8095 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8096 kern_type = KERN_TYPE_APR1CRYPT;
8097 dgst_size = DGST_SIZE_4_4;
8098 parse_func = md5apr1_parse_hash;
8099 sort_by_digest = sort_by_digest_4_4;
8100 opti_type = OPTI_TYPE_ZERO_BYTE;
8101 dgst_pos0 = 0;
8102 dgst_pos1 = 1;
8103 dgst_pos2 = 2;
8104 dgst_pos3 = 3;
8105 break;
8106
8107 case 1700: hash_type = HASH_TYPE_SHA512;
8108 salt_type = SALT_TYPE_NONE;
8109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8110 opts_type = OPTS_TYPE_PT_GENERATE_BE
8111 | OPTS_TYPE_PT_ADD80
8112 | OPTS_TYPE_PT_ADDBITS15;
8113 kern_type = KERN_TYPE_SHA512;
8114 dgst_size = DGST_SIZE_8_8;
8115 parse_func = sha512_parse_hash;
8116 sort_by_digest = sort_by_digest_8_8;
8117 opti_type = OPTI_TYPE_ZERO_BYTE
8118 | OPTI_TYPE_PRECOMPUTE_INIT
8119 | OPTI_TYPE_PRECOMPUTE_MERKLE
8120 | OPTI_TYPE_EARLY_SKIP
8121 | OPTI_TYPE_NOT_ITERATED
8122 | OPTI_TYPE_NOT_SALTED
8123 | OPTI_TYPE_USES_BITS_64
8124 | OPTI_TYPE_RAW_HASH;
8125 dgst_pos0 = 14;
8126 dgst_pos1 = 15;
8127 dgst_pos2 = 6;
8128 dgst_pos3 = 7;
8129 break;
8130
8131 case 1710: hash_type = HASH_TYPE_SHA512;
8132 salt_type = SALT_TYPE_INTERN;
8133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8134 opts_type = OPTS_TYPE_PT_GENERATE_BE
8135 | OPTS_TYPE_ST_ADD80
8136 | OPTS_TYPE_ST_ADDBITS15;
8137 kern_type = KERN_TYPE_SHA512_PWSLT;
8138 dgst_size = DGST_SIZE_8_8;
8139 parse_func = sha512s_parse_hash;
8140 sort_by_digest = sort_by_digest_8_8;
8141 opti_type = OPTI_TYPE_ZERO_BYTE
8142 | OPTI_TYPE_PRECOMPUTE_INIT
8143 | OPTI_TYPE_PRECOMPUTE_MERKLE
8144 | OPTI_TYPE_EARLY_SKIP
8145 | OPTI_TYPE_NOT_ITERATED
8146 | OPTI_TYPE_APPENDED_SALT
8147 | OPTI_TYPE_USES_BITS_64
8148 | OPTI_TYPE_RAW_HASH;
8149 dgst_pos0 = 14;
8150 dgst_pos1 = 15;
8151 dgst_pos2 = 6;
8152 dgst_pos3 = 7;
8153 break;
8154
8155 case 1711: hash_type = HASH_TYPE_SHA512;
8156 salt_type = SALT_TYPE_EMBEDDED;
8157 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8158 opts_type = OPTS_TYPE_PT_GENERATE_BE
8159 | OPTS_TYPE_ST_ADD80
8160 | OPTS_TYPE_ST_ADDBITS15;
8161 kern_type = KERN_TYPE_SHA512_PWSLT;
8162 dgst_size = DGST_SIZE_8_8;
8163 parse_func = sha512b64s_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_APPENDED_SALT
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 1720: 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_PT_ADD80
8184 | OPTS_TYPE_PT_ADDBITS15;
8185 kern_type = KERN_TYPE_SHA512_SLTPW;
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_PREPENDED_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 1722: 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_PT_ADD80
8208 | OPTS_TYPE_PT_ADDBITS15
8209 | OPTS_TYPE_ST_HEX;
8210 kern_type = KERN_TYPE_SHA512_SLTPW;
8211 dgst_size = DGST_SIZE_8_8;
8212 parse_func = osx512_parse_hash;
8213 sort_by_digest = sort_by_digest_8_8;
8214 opti_type = OPTI_TYPE_ZERO_BYTE
8215 | OPTI_TYPE_PRECOMPUTE_INIT
8216 | OPTI_TYPE_PRECOMPUTE_MERKLE
8217 | OPTI_TYPE_EARLY_SKIP
8218 | OPTI_TYPE_NOT_ITERATED
8219 | OPTI_TYPE_PREPENDED_SALT
8220 | OPTI_TYPE_USES_BITS_64
8221 | OPTI_TYPE_RAW_HASH;
8222 dgst_pos0 = 14;
8223 dgst_pos1 = 15;
8224 dgst_pos2 = 6;
8225 dgst_pos3 = 7;
8226 break;
8227
8228 case 1730: hash_type = HASH_TYPE_SHA512;
8229 salt_type = SALT_TYPE_INTERN;
8230 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8231 opts_type = OPTS_TYPE_PT_GENERATE_BE
8232 | OPTS_TYPE_PT_UNICODE
8233 | OPTS_TYPE_ST_ADD80
8234 | OPTS_TYPE_ST_ADDBITS15;
8235 kern_type = KERN_TYPE_SHA512_PWSLTU;
8236 dgst_size = DGST_SIZE_8_8;
8237 parse_func = sha512s_parse_hash;
8238 sort_by_digest = sort_by_digest_8_8;
8239 opti_type = OPTI_TYPE_ZERO_BYTE
8240 | OPTI_TYPE_PRECOMPUTE_INIT
8241 | OPTI_TYPE_PRECOMPUTE_MERKLE
8242 | OPTI_TYPE_EARLY_SKIP
8243 | OPTI_TYPE_NOT_ITERATED
8244 | OPTI_TYPE_APPENDED_SALT
8245 | OPTI_TYPE_USES_BITS_64
8246 | OPTI_TYPE_RAW_HASH;
8247 dgst_pos0 = 14;
8248 dgst_pos1 = 15;
8249 dgst_pos2 = 6;
8250 dgst_pos3 = 7;
8251 break;
8252
8253 case 1731: hash_type = HASH_TYPE_SHA512;
8254 salt_type = SALT_TYPE_EMBEDDED;
8255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8256 opts_type = OPTS_TYPE_PT_GENERATE_BE
8257 | OPTS_TYPE_PT_UNICODE
8258 | OPTS_TYPE_ST_ADD80
8259 | OPTS_TYPE_ST_ADDBITS15
8260 | OPTS_TYPE_ST_HEX;
8261 kern_type = KERN_TYPE_SHA512_PWSLTU;
8262 dgst_size = DGST_SIZE_8_8;
8263 parse_func = mssql2012_parse_hash;
8264 sort_by_digest = sort_by_digest_8_8;
8265 opti_type = OPTI_TYPE_ZERO_BYTE
8266 | OPTI_TYPE_PRECOMPUTE_INIT
8267 | OPTI_TYPE_PRECOMPUTE_MERKLE
8268 | OPTI_TYPE_EARLY_SKIP
8269 | OPTI_TYPE_NOT_ITERATED
8270 | OPTI_TYPE_APPENDED_SALT
8271 | OPTI_TYPE_USES_BITS_64
8272 | OPTI_TYPE_RAW_HASH;
8273 dgst_pos0 = 14;
8274 dgst_pos1 = 15;
8275 dgst_pos2 = 6;
8276 dgst_pos3 = 7;
8277 break;
8278
8279 case 1740: hash_type = HASH_TYPE_SHA512;
8280 salt_type = SALT_TYPE_INTERN;
8281 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8282 opts_type = OPTS_TYPE_PT_GENERATE_BE
8283 | OPTS_TYPE_PT_ADD80
8284 | OPTS_TYPE_PT_ADDBITS15
8285 | OPTS_TYPE_PT_UNICODE;
8286 kern_type = KERN_TYPE_SHA512_SLTPWU;
8287 dgst_size = DGST_SIZE_8_8;
8288 parse_func = sha512s_parse_hash;
8289 sort_by_digest = sort_by_digest_8_8;
8290 opti_type = OPTI_TYPE_ZERO_BYTE
8291 | OPTI_TYPE_PRECOMPUTE_INIT
8292 | OPTI_TYPE_PRECOMPUTE_MERKLE
8293 | OPTI_TYPE_EARLY_SKIP
8294 | OPTI_TYPE_NOT_ITERATED
8295 | OPTI_TYPE_PREPENDED_SALT
8296 | OPTI_TYPE_USES_BITS_64
8297 | OPTI_TYPE_RAW_HASH;
8298 dgst_pos0 = 14;
8299 dgst_pos1 = 15;
8300 dgst_pos2 = 6;
8301 dgst_pos3 = 7;
8302 break;
8303
8304 case 1750: hash_type = HASH_TYPE_SHA512;
8305 salt_type = SALT_TYPE_INTERN;
8306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8307 opts_type = OPTS_TYPE_PT_GENERATE_BE
8308 | OPTS_TYPE_ST_ADD80;
8309 kern_type = KERN_TYPE_HMACSHA512_PW;
8310 dgst_size = DGST_SIZE_8_8;
8311 parse_func = hmacsha512_parse_hash;
8312 sort_by_digest = sort_by_digest_8_8;
8313 opti_type = OPTI_TYPE_ZERO_BYTE
8314 | OPTI_TYPE_USES_BITS_64
8315 | OPTI_TYPE_NOT_ITERATED;
8316 dgst_pos0 = 14;
8317 dgst_pos1 = 15;
8318 dgst_pos2 = 6;
8319 dgst_pos3 = 7;
8320 break;
8321
8322 case 1760: hash_type = HASH_TYPE_SHA512;
8323 salt_type = SALT_TYPE_INTERN;
8324 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8325 opts_type = OPTS_TYPE_PT_GENERATE_BE
8326 | OPTS_TYPE_PT_ADD80
8327 | OPTS_TYPE_PT_ADDBITS15;
8328 kern_type = KERN_TYPE_HMACSHA512_SLT;
8329 dgst_size = DGST_SIZE_8_8;
8330 parse_func = hmacsha512_parse_hash;
8331 sort_by_digest = sort_by_digest_8_8;
8332 opti_type = OPTI_TYPE_ZERO_BYTE
8333 | OPTI_TYPE_USES_BITS_64
8334 | OPTI_TYPE_NOT_ITERATED;
8335 dgst_pos0 = 14;
8336 dgst_pos1 = 15;
8337 dgst_pos2 = 6;
8338 dgst_pos3 = 7;
8339 break;
8340
8341 case 1800: hash_type = HASH_TYPE_SHA512;
8342 salt_type = SALT_TYPE_EMBEDDED;
8343 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8344 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8345 kern_type = KERN_TYPE_SHA512CRYPT;
8346 dgst_size = DGST_SIZE_8_8;
8347 parse_func = sha512crypt_parse_hash;
8348 sort_by_digest = sort_by_digest_8_8;
8349 opti_type = OPTI_TYPE_ZERO_BYTE
8350 | OPTI_TYPE_USES_BITS_64;
8351 dgst_pos0 = 0;
8352 dgst_pos1 = 1;
8353 dgst_pos2 = 2;
8354 dgst_pos3 = 3;
8355 break;
8356
8357 case 2100: hash_type = HASH_TYPE_DCC2;
8358 salt_type = SALT_TYPE_EMBEDDED;
8359 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8360 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8361 | OPTS_TYPE_ST_LOWER
8362 | OPTS_TYPE_ST_UNICODE;
8363 kern_type = KERN_TYPE_DCC2;
8364 dgst_size = DGST_SIZE_4_4;
8365 parse_func = dcc2_parse_hash;
8366 sort_by_digest = sort_by_digest_4_4;
8367 opti_type = OPTI_TYPE_ZERO_BYTE
8368 | OPTI_TYPE_SLOW_HASH_SIMD;
8369 dgst_pos0 = 0;
8370 dgst_pos1 = 1;
8371 dgst_pos2 = 2;
8372 dgst_pos3 = 3;
8373 break;
8374
8375 case 2400: hash_type = HASH_TYPE_MD5;
8376 salt_type = SALT_TYPE_NONE;
8377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8378 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8379 kern_type = KERN_TYPE_MD5PIX;
8380 dgst_size = DGST_SIZE_4_4;
8381 parse_func = md5pix_parse_hash;
8382 sort_by_digest = sort_by_digest_4_4;
8383 opti_type = OPTI_TYPE_ZERO_BYTE
8384 | OPTI_TYPE_PRECOMPUTE_INIT
8385 | OPTI_TYPE_PRECOMPUTE_MERKLE
8386 | OPTI_TYPE_EARLY_SKIP
8387 | OPTI_TYPE_NOT_ITERATED
8388 | OPTI_TYPE_NOT_SALTED;
8389 dgst_pos0 = 0;
8390 dgst_pos1 = 3;
8391 dgst_pos2 = 2;
8392 dgst_pos3 = 1;
8393 break;
8394
8395 case 2410: hash_type = HASH_TYPE_MD5;
8396 salt_type = SALT_TYPE_INTERN;
8397 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8398 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8399 kern_type = KERN_TYPE_MD5ASA;
8400 dgst_size = DGST_SIZE_4_4;
8401 parse_func = md5asa_parse_hash;
8402 sort_by_digest = sort_by_digest_4_4;
8403 opti_type = OPTI_TYPE_ZERO_BYTE
8404 | OPTI_TYPE_PRECOMPUTE_INIT
8405 | OPTI_TYPE_PRECOMPUTE_MERKLE
8406 | OPTI_TYPE_EARLY_SKIP
8407 | OPTI_TYPE_NOT_ITERATED;
8408 dgst_pos0 = 0;
8409 dgst_pos1 = 3;
8410 dgst_pos2 = 2;
8411 dgst_pos3 = 1;
8412 break;
8413
8414 case 2500: hash_type = HASH_TYPE_WPA;
8415 salt_type = SALT_TYPE_EMBEDDED;
8416 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8417 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8418 kern_type = KERN_TYPE_WPA;
8419 dgst_size = DGST_SIZE_4_4;
8420 parse_func = wpa_parse_hash;
8421 sort_by_digest = sort_by_digest_4_4;
8422 opti_type = OPTI_TYPE_ZERO_BYTE
8423 | OPTI_TYPE_SLOW_HASH_SIMD;
8424 dgst_pos0 = 0;
8425 dgst_pos1 = 1;
8426 dgst_pos2 = 2;
8427 dgst_pos3 = 3;
8428 break;
8429
8430 case 2600: hash_type = HASH_TYPE_MD5;
8431 salt_type = SALT_TYPE_VIRTUAL;
8432 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8433 opts_type = OPTS_TYPE_PT_GENERATE_LE
8434 | OPTS_TYPE_PT_ADD80
8435 | OPTS_TYPE_PT_ADDBITS14
8436 | OPTS_TYPE_ST_ADD80;
8437 kern_type = KERN_TYPE_MD55_PWSLT1;
8438 dgst_size = DGST_SIZE_4_4;
8439 parse_func = md5md5_parse_hash;
8440 sort_by_digest = sort_by_digest_4_4;
8441 opti_type = OPTI_TYPE_ZERO_BYTE
8442 | OPTI_TYPE_PRECOMPUTE_INIT
8443 | OPTI_TYPE_PRECOMPUTE_MERKLE
8444 | OPTI_TYPE_EARLY_SKIP;
8445 dgst_pos0 = 0;
8446 dgst_pos1 = 3;
8447 dgst_pos2 = 2;
8448 dgst_pos3 = 1;
8449 break;
8450
8451 case 2611: hash_type = HASH_TYPE_MD5;
8452 salt_type = SALT_TYPE_INTERN;
8453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8454 opts_type = OPTS_TYPE_PT_GENERATE_LE
8455 | OPTS_TYPE_PT_ADD80
8456 | OPTS_TYPE_PT_ADDBITS14
8457 | OPTS_TYPE_ST_ADD80;
8458 kern_type = KERN_TYPE_MD55_PWSLT1;
8459 dgst_size = DGST_SIZE_4_4;
8460 parse_func = vb3_parse_hash;
8461 sort_by_digest = sort_by_digest_4_4;
8462 opti_type = OPTI_TYPE_ZERO_BYTE
8463 | OPTI_TYPE_PRECOMPUTE_INIT
8464 | OPTI_TYPE_PRECOMPUTE_MERKLE
8465 | OPTI_TYPE_EARLY_SKIP;
8466 dgst_pos0 = 0;
8467 dgst_pos1 = 3;
8468 dgst_pos2 = 2;
8469 dgst_pos3 = 1;
8470 break;
8471
8472 case 2612: hash_type = HASH_TYPE_MD5;
8473 salt_type = SALT_TYPE_EMBEDDED;
8474 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8475 opts_type = OPTS_TYPE_PT_GENERATE_LE
8476 | OPTS_TYPE_PT_ADD80
8477 | OPTS_TYPE_PT_ADDBITS14
8478 | OPTS_TYPE_ST_ADD80
8479 | OPTS_TYPE_ST_HEX;
8480 kern_type = KERN_TYPE_MD55_PWSLT1;
8481 dgst_size = DGST_SIZE_4_4;
8482 parse_func = phps_parse_hash;
8483 sort_by_digest = sort_by_digest_4_4;
8484 opti_type = OPTI_TYPE_ZERO_BYTE
8485 | OPTI_TYPE_PRECOMPUTE_INIT
8486 | OPTI_TYPE_PRECOMPUTE_MERKLE
8487 | OPTI_TYPE_EARLY_SKIP;
8488 dgst_pos0 = 0;
8489 dgst_pos1 = 3;
8490 dgst_pos2 = 2;
8491 dgst_pos3 = 1;
8492 break;
8493
8494 case 2711: hash_type = HASH_TYPE_MD5;
8495 salt_type = SALT_TYPE_INTERN;
8496 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8497 opts_type = OPTS_TYPE_PT_GENERATE_LE
8498 | OPTS_TYPE_PT_ADD80
8499 | OPTS_TYPE_PT_ADDBITS14
8500 | OPTS_TYPE_ST_ADD80;
8501 kern_type = KERN_TYPE_MD55_PWSLT2;
8502 dgst_size = DGST_SIZE_4_4;
8503 parse_func = vb30_parse_hash;
8504 sort_by_digest = sort_by_digest_4_4;
8505 opti_type = OPTI_TYPE_ZERO_BYTE
8506 | OPTI_TYPE_PRECOMPUTE_INIT
8507 | OPTI_TYPE_EARLY_SKIP;
8508 dgst_pos0 = 0;
8509 dgst_pos1 = 3;
8510 dgst_pos2 = 2;
8511 dgst_pos3 = 1;
8512 break;
8513
8514 case 2811: hash_type = HASH_TYPE_MD5;
8515 salt_type = SALT_TYPE_INTERN;
8516 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8517 opts_type = OPTS_TYPE_PT_GENERATE_LE
8518 | OPTS_TYPE_PT_ADD80
8519 | OPTS_TYPE_PT_ADDBITS14;
8520 kern_type = KERN_TYPE_MD55_SLTPW;
8521 dgst_size = DGST_SIZE_4_4;
8522 parse_func = ipb2_parse_hash;
8523 sort_by_digest = sort_by_digest_4_4;
8524 opti_type = OPTI_TYPE_ZERO_BYTE
8525 | OPTI_TYPE_PRECOMPUTE_INIT
8526 | OPTI_TYPE_EARLY_SKIP;
8527 dgst_pos0 = 0;
8528 dgst_pos1 = 3;
8529 dgst_pos2 = 2;
8530 dgst_pos3 = 1;
8531 break;
8532
8533 case 3000: hash_type = HASH_TYPE_LM;
8534 salt_type = SALT_TYPE_NONE;
8535 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8536 opts_type = OPTS_TYPE_PT_GENERATE_LE
8537 | OPTS_TYPE_PT_UPPER
8538 | OPTS_TYPE_PT_BITSLICE;
8539 kern_type = KERN_TYPE_LM;
8540 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8541 parse_func = lm_parse_hash;
8542 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8543 opti_type = OPTI_TYPE_ZERO_BYTE
8544 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8545 dgst_pos0 = 0;
8546 dgst_pos1 = 1;
8547 dgst_pos2 = 2;
8548 dgst_pos3 = 3;
8549 break;
8550
8551 case 3100: hash_type = HASH_TYPE_ORACLEH;
8552 salt_type = SALT_TYPE_INTERN;
8553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8554 opts_type = OPTS_TYPE_PT_GENERATE_LE
8555 | OPTS_TYPE_PT_UPPER
8556 | OPTS_TYPE_ST_UPPER;
8557 kern_type = KERN_TYPE_ORACLEH;
8558 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8559 parse_func = oracleh_parse_hash;
8560 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8561 opti_type = OPTI_TYPE_ZERO_BYTE;
8562 dgst_pos0 = 0;
8563 dgst_pos1 = 1;
8564 dgst_pos2 = 2;
8565 dgst_pos3 = 3;
8566 break;
8567
8568 case 3200: hash_type = HASH_TYPE_BCRYPT;
8569 salt_type = SALT_TYPE_EMBEDDED;
8570 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8571 opts_type = OPTS_TYPE_PT_GENERATE_LE
8572 | OPTS_TYPE_ST_GENERATE_LE;
8573 kern_type = KERN_TYPE_BCRYPT;
8574 dgst_size = DGST_SIZE_4_6;
8575 parse_func = bcrypt_parse_hash;
8576 sort_by_digest = sort_by_digest_4_6;
8577 opti_type = OPTI_TYPE_ZERO_BYTE;
8578 dgst_pos0 = 0;
8579 dgst_pos1 = 1;
8580 dgst_pos2 = 2;
8581 dgst_pos3 = 3;
8582 break;
8583
8584 case 3710: hash_type = HASH_TYPE_MD5;
8585 salt_type = SALT_TYPE_INTERN;
8586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8587 opts_type = OPTS_TYPE_PT_GENERATE_LE
8588 | OPTS_TYPE_PT_ADD80
8589 | OPTS_TYPE_PT_ADDBITS14;
8590 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8591 dgst_size = DGST_SIZE_4_4;
8592 parse_func = md5s_parse_hash;
8593 sort_by_digest = sort_by_digest_4_4;
8594 opti_type = OPTI_TYPE_ZERO_BYTE
8595 | OPTI_TYPE_PRECOMPUTE_INIT
8596 | OPTI_TYPE_PRECOMPUTE_MERKLE
8597 | OPTI_TYPE_EARLY_SKIP;
8598 dgst_pos0 = 0;
8599 dgst_pos1 = 3;
8600 dgst_pos2 = 2;
8601 dgst_pos3 = 1;
8602 break;
8603
8604 case 3711: hash_type = HASH_TYPE_MD5;
8605 salt_type = SALT_TYPE_EMBEDDED;
8606 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8607 opts_type = OPTS_TYPE_PT_GENERATE_LE
8608 | OPTS_TYPE_PT_ADD80
8609 | OPTS_TYPE_PT_ADDBITS14;
8610 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8611 dgst_size = DGST_SIZE_4_4;
8612 parse_func = mediawiki_b_parse_hash;
8613 sort_by_digest = sort_by_digest_4_4;
8614 opti_type = OPTI_TYPE_ZERO_BYTE
8615 | OPTI_TYPE_PRECOMPUTE_INIT
8616 | OPTI_TYPE_PRECOMPUTE_MERKLE
8617 | OPTI_TYPE_EARLY_SKIP;
8618 dgst_pos0 = 0;
8619 dgst_pos1 = 3;
8620 dgst_pos2 = 2;
8621 dgst_pos3 = 1;
8622 break;
8623
8624 case 3800: hash_type = HASH_TYPE_MD5;
8625 salt_type = SALT_TYPE_INTERN;
8626 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8627 opts_type = OPTS_TYPE_PT_GENERATE_LE
8628 | OPTS_TYPE_ST_ADDBITS14;
8629 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8630 dgst_size = DGST_SIZE_4_4;
8631 parse_func = md5s_parse_hash;
8632 sort_by_digest = sort_by_digest_4_4;
8633 opti_type = OPTI_TYPE_ZERO_BYTE
8634 | OPTI_TYPE_PRECOMPUTE_INIT
8635 | OPTI_TYPE_PRECOMPUTE_MERKLE
8636 | OPTI_TYPE_EARLY_SKIP
8637 | OPTI_TYPE_NOT_ITERATED
8638 | OPTI_TYPE_RAW_HASH;
8639 dgst_pos0 = 0;
8640 dgst_pos1 = 3;
8641 dgst_pos2 = 2;
8642 dgst_pos3 = 1;
8643 break;
8644
8645 case 4300: hash_type = HASH_TYPE_MD5;
8646 salt_type = SALT_TYPE_VIRTUAL;
8647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8648 opts_type = OPTS_TYPE_PT_GENERATE_LE
8649 | OPTS_TYPE_PT_ADD80
8650 | OPTS_TYPE_PT_ADDBITS14
8651 | OPTS_TYPE_ST_ADD80;
8652 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8653 dgst_size = DGST_SIZE_4_4;
8654 parse_func = md5md5_parse_hash;
8655 sort_by_digest = sort_by_digest_4_4;
8656 opti_type = OPTI_TYPE_ZERO_BYTE
8657 | OPTI_TYPE_PRECOMPUTE_INIT
8658 | OPTI_TYPE_PRECOMPUTE_MERKLE
8659 | OPTI_TYPE_EARLY_SKIP;
8660 dgst_pos0 = 0;
8661 dgst_pos1 = 3;
8662 dgst_pos2 = 2;
8663 dgst_pos3 = 1;
8664 break;
8665
8666
8667 case 4400: hash_type = HASH_TYPE_MD5;
8668 salt_type = SALT_TYPE_NONE;
8669 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8670 opts_type = OPTS_TYPE_PT_GENERATE_BE
8671 | OPTS_TYPE_PT_ADD80
8672 | OPTS_TYPE_PT_ADDBITS15;
8673 kern_type = KERN_TYPE_MD5_SHA1;
8674 dgst_size = DGST_SIZE_4_4;
8675 parse_func = md5_parse_hash;
8676 sort_by_digest = sort_by_digest_4_4;
8677 opti_type = OPTI_TYPE_ZERO_BYTE
8678 | OPTI_TYPE_PRECOMPUTE_INIT
8679 | OPTI_TYPE_PRECOMPUTE_MERKLE
8680 | OPTI_TYPE_EARLY_SKIP
8681 | OPTI_TYPE_NOT_ITERATED
8682 | OPTI_TYPE_NOT_SALTED
8683 | OPTI_TYPE_RAW_HASH;
8684 dgst_pos0 = 0;
8685 dgst_pos1 = 3;
8686 dgst_pos2 = 2;
8687 dgst_pos3 = 1;
8688 break;
8689
8690 case 4500: hash_type = HASH_TYPE_SHA1;
8691 salt_type = SALT_TYPE_NONE;
8692 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8693 opts_type = OPTS_TYPE_PT_GENERATE_BE
8694 | OPTS_TYPE_PT_ADD80
8695 | OPTS_TYPE_PT_ADDBITS15;
8696 kern_type = KERN_TYPE_SHA11;
8697 dgst_size = DGST_SIZE_4_5;
8698 parse_func = sha1_parse_hash;
8699 sort_by_digest = sort_by_digest_4_5;
8700 opti_type = OPTI_TYPE_ZERO_BYTE
8701 | OPTI_TYPE_PRECOMPUTE_INIT
8702 | OPTI_TYPE_PRECOMPUTE_MERKLE
8703 | OPTI_TYPE_EARLY_SKIP
8704 | OPTI_TYPE_NOT_SALTED;
8705 dgst_pos0 = 3;
8706 dgst_pos1 = 4;
8707 dgst_pos2 = 2;
8708 dgst_pos3 = 1;
8709 break;
8710
8711 case 4700: hash_type = HASH_TYPE_SHA1;
8712 salt_type = SALT_TYPE_NONE;
8713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8714 opts_type = OPTS_TYPE_PT_GENERATE_LE
8715 | OPTS_TYPE_PT_ADD80
8716 | OPTS_TYPE_PT_ADDBITS14;
8717 kern_type = KERN_TYPE_SHA1_MD5;
8718 dgst_size = DGST_SIZE_4_5;
8719 parse_func = sha1_parse_hash;
8720 sort_by_digest = sort_by_digest_4_5;
8721 opti_type = OPTI_TYPE_ZERO_BYTE
8722 | OPTI_TYPE_PRECOMPUTE_INIT
8723 | OPTI_TYPE_PRECOMPUTE_MERKLE
8724 | OPTI_TYPE_EARLY_SKIP
8725 | OPTI_TYPE_NOT_ITERATED
8726 | OPTI_TYPE_NOT_SALTED
8727 | OPTI_TYPE_RAW_HASH;
8728 dgst_pos0 = 3;
8729 dgst_pos1 = 4;
8730 dgst_pos2 = 2;
8731 dgst_pos3 = 1;
8732 break;
8733
8734 case 4800: hash_type = HASH_TYPE_MD5;
8735 salt_type = SALT_TYPE_EMBEDDED;
8736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8737 opts_type = OPTS_TYPE_PT_GENERATE_LE
8738 | OPTS_TYPE_PT_ADDBITS14;
8739 kern_type = KERN_TYPE_MD5_CHAP;
8740 dgst_size = DGST_SIZE_4_4;
8741 parse_func = chap_parse_hash;
8742 sort_by_digest = sort_by_digest_4_4;
8743 opti_type = OPTI_TYPE_ZERO_BYTE
8744 | OPTI_TYPE_PRECOMPUTE_INIT
8745 | OPTI_TYPE_PRECOMPUTE_MERKLE
8746 | OPTI_TYPE_MEET_IN_MIDDLE
8747 | OPTI_TYPE_EARLY_SKIP
8748 | OPTI_TYPE_NOT_ITERATED
8749 | OPTI_TYPE_RAW_HASH;
8750 dgst_pos0 = 0;
8751 dgst_pos1 = 3;
8752 dgst_pos2 = 2;
8753 dgst_pos3 = 1;
8754 break;
8755
8756 case 4900: hash_type = HASH_TYPE_SHA1;
8757 salt_type = SALT_TYPE_INTERN;
8758 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8759 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8760 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8761 dgst_size = DGST_SIZE_4_5;
8762 parse_func = sha1s_parse_hash;
8763 sort_by_digest = sort_by_digest_4_5;
8764 opti_type = OPTI_TYPE_ZERO_BYTE
8765 | OPTI_TYPE_PRECOMPUTE_INIT
8766 | OPTI_TYPE_PRECOMPUTE_MERKLE
8767 | OPTI_TYPE_EARLY_SKIP;
8768 dgst_pos0 = 3;
8769 dgst_pos1 = 4;
8770 dgst_pos2 = 2;
8771 dgst_pos3 = 1;
8772 break;
8773
8774 case 5000: hash_type = HASH_TYPE_KECCAK;
8775 salt_type = SALT_TYPE_EMBEDDED;
8776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8777 opts_type = OPTS_TYPE_PT_GENERATE_LE
8778 | OPTS_TYPE_PT_ADD01;
8779 kern_type = KERN_TYPE_KECCAK;
8780 dgst_size = DGST_SIZE_8_25;
8781 parse_func = keccak_parse_hash;
8782 sort_by_digest = sort_by_digest_8_25;
8783 opti_type = OPTI_TYPE_ZERO_BYTE
8784 | OPTI_TYPE_USES_BITS_64
8785 | OPTI_TYPE_RAW_HASH;
8786 dgst_pos0 = 2;
8787 dgst_pos1 = 3;
8788 dgst_pos2 = 4;
8789 dgst_pos3 = 5;
8790 break;
8791
8792 case 5100: hash_type = HASH_TYPE_MD5H;
8793 salt_type = SALT_TYPE_NONE;
8794 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8795 opts_type = OPTS_TYPE_PT_GENERATE_LE
8796 | OPTS_TYPE_PT_ADD80
8797 | OPTS_TYPE_PT_ADDBITS14;
8798 kern_type = KERN_TYPE_MD5H;
8799 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8800 parse_func = md5half_parse_hash;
8801 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8802 opti_type = OPTI_TYPE_ZERO_BYTE
8803 | OPTI_TYPE_RAW_HASH;
8804 dgst_pos0 = 0;
8805 dgst_pos1 = 1;
8806 dgst_pos2 = 2;
8807 dgst_pos3 = 3;
8808 break;
8809
8810 case 5200: hash_type = HASH_TYPE_SHA256;
8811 salt_type = SALT_TYPE_EMBEDDED;
8812 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8813 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8814 kern_type = KERN_TYPE_PSAFE3;
8815 dgst_size = DGST_SIZE_4_8;
8816 parse_func = psafe3_parse_hash;
8817 sort_by_digest = sort_by_digest_4_8;
8818 opti_type = OPTI_TYPE_ZERO_BYTE;
8819 dgst_pos0 = 0;
8820 dgst_pos1 = 1;
8821 dgst_pos2 = 2;
8822 dgst_pos3 = 3;
8823 break;
8824
8825 case 5300: hash_type = HASH_TYPE_MD5;
8826 salt_type = SALT_TYPE_EMBEDDED;
8827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8828 opts_type = OPTS_TYPE_PT_GENERATE_LE
8829 | OPTS_TYPE_ST_ADD80;
8830 kern_type = KERN_TYPE_IKEPSK_MD5;
8831 dgst_size = DGST_SIZE_4_4;
8832 parse_func = ikepsk_md5_parse_hash;
8833 sort_by_digest = sort_by_digest_4_4;
8834 opti_type = OPTI_TYPE_ZERO_BYTE;
8835 dgst_pos0 = 0;
8836 dgst_pos1 = 3;
8837 dgst_pos2 = 2;
8838 dgst_pos3 = 1;
8839 break;
8840
8841 case 5400: hash_type = HASH_TYPE_SHA1;
8842 salt_type = SALT_TYPE_EMBEDDED;
8843 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8844 opts_type = OPTS_TYPE_PT_GENERATE_BE
8845 | OPTS_TYPE_ST_ADD80;
8846 kern_type = KERN_TYPE_IKEPSK_SHA1;
8847 dgst_size = DGST_SIZE_4_5;
8848 parse_func = ikepsk_sha1_parse_hash;
8849 sort_by_digest = sort_by_digest_4_5;
8850 opti_type = OPTI_TYPE_ZERO_BYTE;
8851 dgst_pos0 = 3;
8852 dgst_pos1 = 4;
8853 dgst_pos2 = 2;
8854 dgst_pos3 = 1;
8855 break;
8856
8857 case 5500: hash_type = HASH_TYPE_NETNTLM;
8858 salt_type = SALT_TYPE_EMBEDDED;
8859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8860 opts_type = OPTS_TYPE_PT_GENERATE_LE
8861 | OPTS_TYPE_PT_ADD80
8862 | OPTS_TYPE_PT_ADDBITS14
8863 | OPTS_TYPE_PT_UNICODE
8864 | OPTS_TYPE_ST_HEX;
8865 kern_type = KERN_TYPE_NETNTLMv1;
8866 dgst_size = DGST_SIZE_4_4;
8867 parse_func = netntlmv1_parse_hash;
8868 sort_by_digest = sort_by_digest_4_4;
8869 opti_type = OPTI_TYPE_ZERO_BYTE
8870 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8871 dgst_pos0 = 0;
8872 dgst_pos1 = 1;
8873 dgst_pos2 = 2;
8874 dgst_pos3 = 3;
8875 break;
8876
8877 case 5600: hash_type = HASH_TYPE_MD5;
8878 salt_type = SALT_TYPE_EMBEDDED;
8879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8880 opts_type = OPTS_TYPE_PT_GENERATE_LE
8881 | OPTS_TYPE_PT_ADD80
8882 | OPTS_TYPE_PT_ADDBITS14
8883 | OPTS_TYPE_PT_UNICODE;
8884 kern_type = KERN_TYPE_NETNTLMv2;
8885 dgst_size = DGST_SIZE_4_4;
8886 parse_func = netntlmv2_parse_hash;
8887 sort_by_digest = sort_by_digest_4_4;
8888 opti_type = OPTI_TYPE_ZERO_BYTE;
8889 dgst_pos0 = 0;
8890 dgst_pos1 = 3;
8891 dgst_pos2 = 2;
8892 dgst_pos3 = 1;
8893 break;
8894
8895 case 5700: hash_type = HASH_TYPE_SHA256;
8896 salt_type = SALT_TYPE_NONE;
8897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8898 opts_type = OPTS_TYPE_PT_GENERATE_BE
8899 | OPTS_TYPE_PT_ADD80
8900 | OPTS_TYPE_PT_ADDBITS15;
8901 kern_type = KERN_TYPE_SHA256;
8902 dgst_size = DGST_SIZE_4_8;
8903 parse_func = cisco4_parse_hash;
8904 sort_by_digest = sort_by_digest_4_8;
8905 opti_type = OPTI_TYPE_ZERO_BYTE
8906 | OPTI_TYPE_PRECOMPUTE_INIT
8907 | OPTI_TYPE_PRECOMPUTE_MERKLE
8908 | OPTI_TYPE_EARLY_SKIP
8909 | OPTI_TYPE_NOT_ITERATED
8910 | OPTI_TYPE_NOT_SALTED
8911 | OPTI_TYPE_RAW_HASH;
8912 dgst_pos0 = 3;
8913 dgst_pos1 = 7;
8914 dgst_pos2 = 2;
8915 dgst_pos3 = 6;
8916 break;
8917
8918 case 5800: hash_type = HASH_TYPE_SHA1;
8919 salt_type = SALT_TYPE_INTERN;
8920 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8921 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8922 | OPTS_TYPE_ST_ADD80;
8923 kern_type = KERN_TYPE_ANDROIDPIN;
8924 dgst_size = DGST_SIZE_4_5;
8925 parse_func = androidpin_parse_hash;
8926 sort_by_digest = sort_by_digest_4_5;
8927 opti_type = OPTI_TYPE_ZERO_BYTE;
8928 dgst_pos0 = 0;
8929 dgst_pos1 = 1;
8930 dgst_pos2 = 2;
8931 dgst_pos3 = 3;
8932 break;
8933
8934 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8935 salt_type = SALT_TYPE_NONE;
8936 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8937 opts_type = OPTS_TYPE_PT_GENERATE_LE
8938 | OPTS_TYPE_PT_ADD80;
8939 kern_type = KERN_TYPE_RIPEMD160;
8940 dgst_size = DGST_SIZE_4_5;
8941 parse_func = ripemd160_parse_hash;
8942 sort_by_digest = sort_by_digest_4_5;
8943 opti_type = OPTI_TYPE_ZERO_BYTE;
8944 dgst_pos0 = 0;
8945 dgst_pos1 = 1;
8946 dgst_pos2 = 2;
8947 dgst_pos3 = 3;
8948 break;
8949
8950 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8951 salt_type = SALT_TYPE_NONE;
8952 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8953 opts_type = OPTS_TYPE_PT_GENERATE_BE
8954 | OPTS_TYPE_PT_ADD80;
8955 kern_type = KERN_TYPE_WHIRLPOOL;
8956 dgst_size = DGST_SIZE_4_16;
8957 parse_func = whirlpool_parse_hash;
8958 sort_by_digest = sort_by_digest_4_16;
8959 opti_type = OPTI_TYPE_ZERO_BYTE;
8960 dgst_pos0 = 0;
8961 dgst_pos1 = 1;
8962 dgst_pos2 = 2;
8963 dgst_pos3 = 3;
8964 break;
8965
8966 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8967 salt_type = SALT_TYPE_EMBEDDED;
8968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8969 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8970 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8971 dgst_size = DGST_SIZE_4_5;
8972 parse_func = truecrypt_parse_hash_2k;
8973 sort_by_digest = sort_by_digest_4_5;
8974 opti_type = OPTI_TYPE_ZERO_BYTE;
8975 dgst_pos0 = 0;
8976 dgst_pos1 = 1;
8977 dgst_pos2 = 2;
8978 dgst_pos3 = 3;
8979 break;
8980
8981 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8982 salt_type = SALT_TYPE_EMBEDDED;
8983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8984 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8985 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8986 dgst_size = DGST_SIZE_4_5;
8987 parse_func = truecrypt_parse_hash_2k;
8988 sort_by_digest = sort_by_digest_4_5;
8989 opti_type = OPTI_TYPE_ZERO_BYTE;
8990 dgst_pos0 = 0;
8991 dgst_pos1 = 1;
8992 dgst_pos2 = 2;
8993 dgst_pos3 = 3;
8994 break;
8995
8996 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8997 salt_type = SALT_TYPE_EMBEDDED;
8998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8999 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9000 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9001 dgst_size = DGST_SIZE_4_5;
9002 parse_func = truecrypt_parse_hash_2k;
9003 sort_by_digest = sort_by_digest_4_5;
9004 opti_type = OPTI_TYPE_ZERO_BYTE;
9005 dgst_pos0 = 0;
9006 dgst_pos1 = 1;
9007 dgst_pos2 = 2;
9008 dgst_pos3 = 3;
9009 break;
9010
9011 case 6221: hash_type = HASH_TYPE_SHA512;
9012 salt_type = SALT_TYPE_EMBEDDED;
9013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9014 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9015 kern_type = KERN_TYPE_TCSHA512_XTS512;
9016 dgst_size = DGST_SIZE_8_8;
9017 parse_func = truecrypt_parse_hash_1k;
9018 sort_by_digest = sort_by_digest_8_8;
9019 opti_type = OPTI_TYPE_ZERO_BYTE
9020 | OPTI_TYPE_USES_BITS_64;
9021 dgst_pos0 = 0;
9022 dgst_pos1 = 1;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 3;
9025 break;
9026
9027 case 6222: hash_type = HASH_TYPE_SHA512;
9028 salt_type = SALT_TYPE_EMBEDDED;
9029 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9030 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9031 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9032 dgst_size = DGST_SIZE_8_8;
9033 parse_func = truecrypt_parse_hash_1k;
9034 sort_by_digest = sort_by_digest_8_8;
9035 opti_type = OPTI_TYPE_ZERO_BYTE
9036 | OPTI_TYPE_USES_BITS_64;
9037 dgst_pos0 = 0;
9038 dgst_pos1 = 1;
9039 dgst_pos2 = 2;
9040 dgst_pos3 = 3;
9041 break;
9042
9043 case 6223: hash_type = HASH_TYPE_SHA512;
9044 salt_type = SALT_TYPE_EMBEDDED;
9045 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9046 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9047 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9048 dgst_size = DGST_SIZE_8_8;
9049 parse_func = truecrypt_parse_hash_1k;
9050 sort_by_digest = sort_by_digest_8_8;
9051 opti_type = OPTI_TYPE_ZERO_BYTE
9052 | OPTI_TYPE_USES_BITS_64;
9053 dgst_pos0 = 0;
9054 dgst_pos1 = 1;
9055 dgst_pos2 = 2;
9056 dgst_pos3 = 3;
9057 break;
9058
9059 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9060 salt_type = SALT_TYPE_EMBEDDED;
9061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9062 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9063 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9064 dgst_size = DGST_SIZE_4_8;
9065 parse_func = truecrypt_parse_hash_1k;
9066 sort_by_digest = sort_by_digest_4_8;
9067 opti_type = OPTI_TYPE_ZERO_BYTE;
9068 dgst_pos0 = 0;
9069 dgst_pos1 = 1;
9070 dgst_pos2 = 2;
9071 dgst_pos3 = 3;
9072 break;
9073
9074 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9075 salt_type = SALT_TYPE_EMBEDDED;
9076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9077 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9078 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9079 dgst_size = DGST_SIZE_4_8;
9080 parse_func = truecrypt_parse_hash_1k;
9081 sort_by_digest = sort_by_digest_4_8;
9082 opti_type = OPTI_TYPE_ZERO_BYTE;
9083 dgst_pos0 = 0;
9084 dgst_pos1 = 1;
9085 dgst_pos2 = 2;
9086 dgst_pos3 = 3;
9087 break;
9088
9089 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9090 salt_type = SALT_TYPE_EMBEDDED;
9091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9092 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9093 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9094 dgst_size = DGST_SIZE_4_8;
9095 parse_func = truecrypt_parse_hash_1k;
9096 sort_by_digest = sort_by_digest_4_8;
9097 opti_type = OPTI_TYPE_ZERO_BYTE;
9098 dgst_pos0 = 0;
9099 dgst_pos1 = 1;
9100 dgst_pos2 = 2;
9101 dgst_pos3 = 3;
9102 break;
9103
9104 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9105 salt_type = SALT_TYPE_EMBEDDED;
9106 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9107 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9108 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9109 dgst_size = DGST_SIZE_4_5;
9110 parse_func = truecrypt_parse_hash_1k;
9111 sort_by_digest = sort_by_digest_4_5;
9112 opti_type = OPTI_TYPE_ZERO_BYTE;
9113 dgst_pos0 = 0;
9114 dgst_pos1 = 1;
9115 dgst_pos2 = 2;
9116 dgst_pos3 = 3;
9117 break;
9118
9119 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9120 salt_type = SALT_TYPE_EMBEDDED;
9121 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9122 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9123 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9124 dgst_size = DGST_SIZE_4_5;
9125 parse_func = truecrypt_parse_hash_1k;
9126 sort_by_digest = sort_by_digest_4_5;
9127 opti_type = OPTI_TYPE_ZERO_BYTE;
9128 dgst_pos0 = 0;
9129 dgst_pos1 = 1;
9130 dgst_pos2 = 2;
9131 dgst_pos3 = 3;
9132 break;
9133
9134 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9135 salt_type = SALT_TYPE_EMBEDDED;
9136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9137 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9138 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9139 dgst_size = DGST_SIZE_4_5;
9140 parse_func = truecrypt_parse_hash_1k;
9141 sort_by_digest = sort_by_digest_4_5;
9142 opti_type = OPTI_TYPE_ZERO_BYTE;
9143 dgst_pos0 = 0;
9144 dgst_pos1 = 1;
9145 dgst_pos2 = 2;
9146 dgst_pos3 = 3;
9147 break;
9148
9149 case 6300: hash_type = HASH_TYPE_MD5;
9150 salt_type = SALT_TYPE_EMBEDDED;
9151 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9152 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9153 kern_type = KERN_TYPE_MD5AIX;
9154 dgst_size = DGST_SIZE_4_4;
9155 parse_func = md5aix_parse_hash;
9156 sort_by_digest = sort_by_digest_4_4;
9157 opti_type = OPTI_TYPE_ZERO_BYTE;
9158 dgst_pos0 = 0;
9159 dgst_pos1 = 1;
9160 dgst_pos2 = 2;
9161 dgst_pos3 = 3;
9162 break;
9163
9164 case 6400: hash_type = HASH_TYPE_SHA256;
9165 salt_type = SALT_TYPE_EMBEDDED;
9166 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9167 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9168 kern_type = KERN_TYPE_SHA256AIX;
9169 dgst_size = DGST_SIZE_4_8;
9170 parse_func = sha256aix_parse_hash;
9171 sort_by_digest = sort_by_digest_4_8;
9172 opti_type = OPTI_TYPE_ZERO_BYTE;
9173 dgst_pos0 = 0;
9174 dgst_pos1 = 1;
9175 dgst_pos2 = 2;
9176 dgst_pos3 = 3;
9177 break;
9178
9179 case 6500: hash_type = HASH_TYPE_SHA512;
9180 salt_type = SALT_TYPE_EMBEDDED;
9181 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9182 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9183 kern_type = KERN_TYPE_SHA512AIX;
9184 dgst_size = DGST_SIZE_8_8;
9185 parse_func = sha512aix_parse_hash;
9186 sort_by_digest = sort_by_digest_8_8;
9187 opti_type = OPTI_TYPE_ZERO_BYTE
9188 | OPTI_TYPE_USES_BITS_64;
9189 dgst_pos0 = 0;
9190 dgst_pos1 = 1;
9191 dgst_pos2 = 2;
9192 dgst_pos3 = 3;
9193 break;
9194
9195 case 6600: hash_type = HASH_TYPE_AES;
9196 salt_type = SALT_TYPE_EMBEDDED;
9197 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9198 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9199 kern_type = KERN_TYPE_AGILEKEY;
9200 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9201 parse_func = agilekey_parse_hash;
9202 sort_by_digest = sort_by_digest_4_5;
9203 opti_type = OPTI_TYPE_ZERO_BYTE;
9204 dgst_pos0 = 0;
9205 dgst_pos1 = 1;
9206 dgst_pos2 = 2;
9207 dgst_pos3 = 3;
9208 break;
9209
9210 case 6700: hash_type = HASH_TYPE_SHA1;
9211 salt_type = SALT_TYPE_EMBEDDED;
9212 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9213 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9214 kern_type = KERN_TYPE_SHA1AIX;
9215 dgst_size = DGST_SIZE_4_5;
9216 parse_func = sha1aix_parse_hash;
9217 sort_by_digest = sort_by_digest_4_5;
9218 opti_type = OPTI_TYPE_ZERO_BYTE;
9219 dgst_pos0 = 0;
9220 dgst_pos1 = 1;
9221 dgst_pos2 = 2;
9222 dgst_pos3 = 3;
9223 break;
9224
9225 case 6800: hash_type = HASH_TYPE_AES;
9226 salt_type = SALT_TYPE_EMBEDDED;
9227 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9228 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9229 kern_type = KERN_TYPE_LASTPASS;
9230 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9231 parse_func = lastpass_parse_hash;
9232 sort_by_digest = sort_by_digest_4_8;
9233 opti_type = OPTI_TYPE_ZERO_BYTE;
9234 dgst_pos0 = 0;
9235 dgst_pos1 = 1;
9236 dgst_pos2 = 2;
9237 dgst_pos3 = 3;
9238 break;
9239
9240 case 6900: hash_type = HASH_TYPE_GOST;
9241 salt_type = SALT_TYPE_NONE;
9242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9243 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9244 kern_type = KERN_TYPE_GOST;
9245 dgst_size = DGST_SIZE_4_8;
9246 parse_func = gost_parse_hash;
9247 sort_by_digest = sort_by_digest_4_8;
9248 opti_type = OPTI_TYPE_ZERO_BYTE;
9249 dgst_pos0 = 0;
9250 dgst_pos1 = 1;
9251 dgst_pos2 = 2;
9252 dgst_pos3 = 3;
9253 break;
9254
9255 case 7100: hash_type = HASH_TYPE_SHA512;
9256 salt_type = SALT_TYPE_EMBEDDED;
9257 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9258 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9259 kern_type = KERN_TYPE_PBKDF2_SHA512;
9260 dgst_size = DGST_SIZE_8_16;
9261 parse_func = sha512osx_parse_hash;
9262 sort_by_digest = sort_by_digest_8_16;
9263 opti_type = OPTI_TYPE_ZERO_BYTE
9264 | OPTI_TYPE_USES_BITS_64
9265 | OPTI_TYPE_SLOW_HASH_SIMD;
9266 dgst_pos0 = 0;
9267 dgst_pos1 = 1;
9268 dgst_pos2 = 2;
9269 dgst_pos3 = 3;
9270 break;
9271
9272 case 7200: hash_type = HASH_TYPE_SHA512;
9273 salt_type = SALT_TYPE_EMBEDDED;
9274 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9275 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9276 kern_type = KERN_TYPE_PBKDF2_SHA512;
9277 dgst_size = DGST_SIZE_8_16;
9278 parse_func = sha512grub_parse_hash;
9279 sort_by_digest = sort_by_digest_8_16;
9280 opti_type = OPTI_TYPE_ZERO_BYTE
9281 | OPTI_TYPE_USES_BITS_64
9282 | OPTI_TYPE_SLOW_HASH_SIMD;
9283 dgst_pos0 = 0;
9284 dgst_pos1 = 1;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 3;
9287 break;
9288
9289 case 7300: hash_type = HASH_TYPE_SHA1;
9290 salt_type = SALT_TYPE_EMBEDDED;
9291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9292 opts_type = OPTS_TYPE_PT_GENERATE_BE
9293 | OPTS_TYPE_ST_ADD80
9294 | OPTS_TYPE_ST_ADDBITS15;
9295 kern_type = KERN_TYPE_RAKP;
9296 dgst_size = DGST_SIZE_4_5;
9297 parse_func = rakp_parse_hash;
9298 sort_by_digest = sort_by_digest_4_5;
9299 opti_type = OPTI_TYPE_ZERO_BYTE
9300 | OPTI_TYPE_NOT_ITERATED;
9301 dgst_pos0 = 3;
9302 dgst_pos1 = 4;
9303 dgst_pos2 = 2;
9304 dgst_pos3 = 1;
9305 break;
9306
9307 case 7400: hash_type = HASH_TYPE_SHA256;
9308 salt_type = SALT_TYPE_EMBEDDED;
9309 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9310 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9311 kern_type = KERN_TYPE_SHA256CRYPT;
9312 dgst_size = DGST_SIZE_4_8;
9313 parse_func = sha256crypt_parse_hash;
9314 sort_by_digest = sort_by_digest_4_8;
9315 opti_type = OPTI_TYPE_ZERO_BYTE;
9316 dgst_pos0 = 0;
9317 dgst_pos1 = 1;
9318 dgst_pos2 = 2;
9319 dgst_pos3 = 3;
9320 break;
9321
9322 case 7500: hash_type = HASH_TYPE_KRB5PA;
9323 salt_type = SALT_TYPE_EMBEDDED;
9324 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9325 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9326 kern_type = KERN_TYPE_KRB5PA;
9327 dgst_size = DGST_SIZE_4_4;
9328 parse_func = krb5pa_parse_hash;
9329 sort_by_digest = sort_by_digest_4_4;
9330 opti_type = OPTI_TYPE_ZERO_BYTE
9331 | OPTI_TYPE_NOT_ITERATED;
9332 dgst_pos0 = 0;
9333 dgst_pos1 = 1;
9334 dgst_pos2 = 2;
9335 dgst_pos3 = 3;
9336 break;
9337
9338 case 7600: hash_type = HASH_TYPE_SHA1;
9339 salt_type = SALT_TYPE_INTERN;
9340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9341 opts_type = OPTS_TYPE_PT_GENERATE_BE
9342 | OPTS_TYPE_PT_ADD80
9343 | OPTS_TYPE_PT_ADDBITS15;
9344 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9345 dgst_size = DGST_SIZE_4_5;
9346 parse_func = redmine_parse_hash;
9347 sort_by_digest = sort_by_digest_4_5;
9348 opti_type = OPTI_TYPE_ZERO_BYTE
9349 | OPTI_TYPE_PRECOMPUTE_INIT
9350 | OPTI_TYPE_EARLY_SKIP
9351 | OPTI_TYPE_NOT_ITERATED
9352 | OPTI_TYPE_PREPENDED_SALT;
9353 dgst_pos0 = 3;
9354 dgst_pos1 = 4;
9355 dgst_pos2 = 2;
9356 dgst_pos3 = 1;
9357 break;
9358
9359 case 7700: hash_type = HASH_TYPE_SAPB;
9360 salt_type = SALT_TYPE_EMBEDDED;
9361 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9362 opts_type = OPTS_TYPE_PT_GENERATE_LE
9363 | OPTS_TYPE_PT_UPPER
9364 | OPTS_TYPE_ST_UPPER;
9365 kern_type = KERN_TYPE_SAPB;
9366 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9367 parse_func = sapb_parse_hash;
9368 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9369 opti_type = OPTI_TYPE_ZERO_BYTE
9370 | OPTI_TYPE_PRECOMPUTE_INIT
9371 | OPTI_TYPE_NOT_ITERATED;
9372 dgst_pos0 = 0;
9373 dgst_pos1 = 1;
9374 dgst_pos2 = 2;
9375 dgst_pos3 = 3;
9376 break;
9377
9378 case 7800: hash_type = HASH_TYPE_SAPG;
9379 salt_type = SALT_TYPE_EMBEDDED;
9380 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9381 opts_type = OPTS_TYPE_PT_GENERATE_BE
9382 | OPTS_TYPE_ST_ADD80
9383 | OPTS_TYPE_ST_UPPER;
9384 kern_type = KERN_TYPE_SAPG;
9385 dgst_size = DGST_SIZE_4_5;
9386 parse_func = sapg_parse_hash;
9387 sort_by_digest = sort_by_digest_4_5;
9388 opti_type = OPTI_TYPE_ZERO_BYTE
9389 | OPTI_TYPE_PRECOMPUTE_INIT
9390 | OPTI_TYPE_NOT_ITERATED;
9391 dgst_pos0 = 3;
9392 dgst_pos1 = 4;
9393 dgst_pos2 = 2;
9394 dgst_pos3 = 1;
9395 break;
9396
9397 case 7900: hash_type = HASH_TYPE_SHA512;
9398 salt_type = SALT_TYPE_EMBEDDED;
9399 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9400 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9401 kern_type = KERN_TYPE_DRUPAL7;
9402 dgst_size = DGST_SIZE_8_8;
9403 parse_func = drupal7_parse_hash;
9404 sort_by_digest = sort_by_digest_8_8;
9405 opti_type = OPTI_TYPE_ZERO_BYTE
9406 | OPTI_TYPE_USES_BITS_64;
9407 dgst_pos0 = 0;
9408 dgst_pos1 = 1;
9409 dgst_pos2 = 2;
9410 dgst_pos3 = 3;
9411 break;
9412
9413 case 8000: hash_type = HASH_TYPE_SHA256;
9414 salt_type = SALT_TYPE_EMBEDDED;
9415 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9416 opts_type = OPTS_TYPE_PT_GENERATE_BE
9417 | OPTS_TYPE_PT_UNICODE
9418 | OPTS_TYPE_ST_ADD80
9419 | OPTS_TYPE_ST_HEX;
9420 kern_type = KERN_TYPE_SYBASEASE;
9421 dgst_size = DGST_SIZE_4_8;
9422 parse_func = sybasease_parse_hash;
9423 sort_by_digest = sort_by_digest_4_8;
9424 opti_type = OPTI_TYPE_ZERO_BYTE
9425 | OPTI_TYPE_PRECOMPUTE_INIT
9426 | OPTI_TYPE_EARLY_SKIP
9427 | OPTI_TYPE_NOT_ITERATED
9428 | OPTI_TYPE_RAW_HASH;
9429 dgst_pos0 = 3;
9430 dgst_pos1 = 7;
9431 dgst_pos2 = 2;
9432 dgst_pos3 = 6;
9433 break;
9434
9435 case 8100: hash_type = HASH_TYPE_SHA1;
9436 salt_type = SALT_TYPE_EMBEDDED;
9437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9438 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9439 kern_type = KERN_TYPE_NETSCALER;
9440 dgst_size = DGST_SIZE_4_5;
9441 parse_func = netscaler_parse_hash;
9442 sort_by_digest = sort_by_digest_4_5;
9443 opti_type = OPTI_TYPE_ZERO_BYTE
9444 | OPTI_TYPE_PRECOMPUTE_INIT
9445 | OPTI_TYPE_PRECOMPUTE_MERKLE
9446 | OPTI_TYPE_EARLY_SKIP
9447 | OPTI_TYPE_NOT_ITERATED
9448 | OPTI_TYPE_PREPENDED_SALT
9449 | OPTI_TYPE_RAW_HASH;
9450 dgst_pos0 = 3;
9451 dgst_pos1 = 4;
9452 dgst_pos2 = 2;
9453 dgst_pos3 = 1;
9454 break;
9455
9456 case 8200: hash_type = HASH_TYPE_SHA256;
9457 salt_type = SALT_TYPE_EMBEDDED;
9458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9459 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9460 kern_type = KERN_TYPE_CLOUDKEY;
9461 dgst_size = DGST_SIZE_4_8;
9462 parse_func = cloudkey_parse_hash;
9463 sort_by_digest = sort_by_digest_4_8;
9464 opti_type = OPTI_TYPE_ZERO_BYTE;
9465 dgst_pos0 = 0;
9466 dgst_pos1 = 1;
9467 dgst_pos2 = 2;
9468 dgst_pos3 = 3;
9469 break;
9470
9471 case 8300: hash_type = HASH_TYPE_SHA1;
9472 salt_type = SALT_TYPE_EMBEDDED;
9473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9474 opts_type = OPTS_TYPE_PT_GENERATE_BE
9475 | OPTS_TYPE_ST_HEX
9476 | OPTS_TYPE_ST_ADD80;
9477 kern_type = KERN_TYPE_NSEC3;
9478 dgst_size = DGST_SIZE_4_5;
9479 parse_func = nsec3_parse_hash;
9480 sort_by_digest = sort_by_digest_4_5;
9481 opti_type = OPTI_TYPE_ZERO_BYTE;
9482 dgst_pos0 = 3;
9483 dgst_pos1 = 4;
9484 dgst_pos2 = 2;
9485 dgst_pos3 = 1;
9486 break;
9487
9488 case 8400: hash_type = HASH_TYPE_SHA1;
9489 salt_type = SALT_TYPE_INTERN;
9490 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9491 opts_type = OPTS_TYPE_PT_GENERATE_BE
9492 | OPTS_TYPE_PT_ADD80
9493 | OPTS_TYPE_PT_ADDBITS15;
9494 kern_type = KERN_TYPE_WBB3;
9495 dgst_size = DGST_SIZE_4_5;
9496 parse_func = wbb3_parse_hash;
9497 sort_by_digest = sort_by_digest_4_5;
9498 opti_type = OPTI_TYPE_ZERO_BYTE
9499 | OPTI_TYPE_PRECOMPUTE_INIT
9500 | OPTI_TYPE_NOT_ITERATED;
9501 dgst_pos0 = 3;
9502 dgst_pos1 = 4;
9503 dgst_pos2 = 2;
9504 dgst_pos3 = 1;
9505 break;
9506
9507 case 8500: hash_type = HASH_TYPE_DESRACF;
9508 salt_type = SALT_TYPE_EMBEDDED;
9509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9510 opts_type = OPTS_TYPE_PT_GENERATE_LE
9511 | OPTS_TYPE_ST_UPPER;
9512 kern_type = KERN_TYPE_RACF;
9513 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9514 parse_func = racf_parse_hash;
9515 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9516 opti_type = OPTI_TYPE_ZERO_BYTE
9517 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9518 dgst_pos0 = 0;
9519 dgst_pos1 = 1;
9520 dgst_pos2 = 2;
9521 dgst_pos3 = 3;
9522 break;
9523
9524 case 8600: hash_type = HASH_TYPE_LOTUS5;
9525 salt_type = SALT_TYPE_NONE;
9526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9527 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9528 kern_type = KERN_TYPE_LOTUS5;
9529 dgst_size = DGST_SIZE_4_4;
9530 parse_func = lotus5_parse_hash;
9531 sort_by_digest = sort_by_digest_4_4;
9532 opti_type = OPTI_TYPE_EARLY_SKIP
9533 | OPTI_TYPE_NOT_ITERATED
9534 | OPTI_TYPE_NOT_SALTED
9535 | OPTI_TYPE_RAW_HASH;
9536 dgst_pos0 = 0;
9537 dgst_pos1 = 1;
9538 dgst_pos2 = 2;
9539 dgst_pos3 = 3;
9540 break;
9541
9542 case 8700: hash_type = HASH_TYPE_LOTUS6;
9543 salt_type = SALT_TYPE_EMBEDDED;
9544 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9545 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9546 kern_type = KERN_TYPE_LOTUS6;
9547 dgst_size = DGST_SIZE_4_4;
9548 parse_func = lotus6_parse_hash;
9549 sort_by_digest = sort_by_digest_4_4;
9550 opti_type = OPTI_TYPE_EARLY_SKIP
9551 | OPTI_TYPE_NOT_ITERATED
9552 | OPTI_TYPE_RAW_HASH;
9553 dgst_pos0 = 0;
9554 dgst_pos1 = 1;
9555 dgst_pos2 = 2;
9556 dgst_pos3 = 3;
9557 break;
9558
9559 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9560 salt_type = SALT_TYPE_EMBEDDED;
9561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9562 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9563 kern_type = KERN_TYPE_ANDROIDFDE;
9564 dgst_size = DGST_SIZE_4_4;
9565 parse_func = androidfde_parse_hash;
9566 sort_by_digest = sort_by_digest_4_4;
9567 opti_type = OPTI_TYPE_ZERO_BYTE;
9568 dgst_pos0 = 0;
9569 dgst_pos1 = 1;
9570 dgst_pos2 = 2;
9571 dgst_pos3 = 3;
9572 break;
9573
9574 case 8900: hash_type = HASH_TYPE_SCRYPT;
9575 salt_type = SALT_TYPE_EMBEDDED;
9576 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9577 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9578 kern_type = KERN_TYPE_SCRYPT;
9579 dgst_size = DGST_SIZE_4_8;
9580 parse_func = scrypt_parse_hash;
9581 sort_by_digest = sort_by_digest_4_8;
9582 opti_type = OPTI_TYPE_ZERO_BYTE;
9583 dgst_pos0 = 0;
9584 dgst_pos1 = 1;
9585 dgst_pos2 = 2;
9586 dgst_pos3 = 3;
9587 break;
9588
9589 case 9000: hash_type = HASH_TYPE_SHA1;
9590 salt_type = SALT_TYPE_EMBEDDED;
9591 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9592 opts_type = OPTS_TYPE_PT_GENERATE_LE
9593 | OPTS_TYPE_ST_GENERATE_LE;
9594 kern_type = KERN_TYPE_PSAFE2;
9595 dgst_size = DGST_SIZE_4_5;
9596 parse_func = psafe2_parse_hash;
9597 sort_by_digest = sort_by_digest_4_5;
9598 opti_type = OPTI_TYPE_ZERO_BYTE;
9599 dgst_pos0 = 0;
9600 dgst_pos1 = 1;
9601 dgst_pos2 = 2;
9602 dgst_pos3 = 3;
9603 break;
9604
9605 case 9100: hash_type = HASH_TYPE_LOTUS8;
9606 salt_type = SALT_TYPE_EMBEDDED;
9607 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9608 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9609 kern_type = KERN_TYPE_LOTUS8;
9610 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9611 parse_func = lotus8_parse_hash;
9612 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9613 opti_type = OPTI_TYPE_ZERO_BYTE;
9614 dgst_pos0 = 0;
9615 dgst_pos1 = 1;
9616 dgst_pos2 = 2;
9617 dgst_pos3 = 3;
9618 break;
9619
9620 case 9200: hash_type = HASH_TYPE_SHA256;
9621 salt_type = SALT_TYPE_EMBEDDED;
9622 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9623 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9624 kern_type = KERN_TYPE_PBKDF2_SHA256;
9625 dgst_size = DGST_SIZE_4_32;
9626 parse_func = cisco8_parse_hash;
9627 sort_by_digest = sort_by_digest_4_32;
9628 opti_type = OPTI_TYPE_ZERO_BYTE
9629 | OPTI_TYPE_SLOW_HASH_SIMD;
9630 dgst_pos0 = 0;
9631 dgst_pos1 = 1;
9632 dgst_pos2 = 2;
9633 dgst_pos3 = 3;
9634 break;
9635
9636 case 9300: hash_type = HASH_TYPE_SCRYPT;
9637 salt_type = SALT_TYPE_EMBEDDED;
9638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9639 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9640 kern_type = KERN_TYPE_SCRYPT;
9641 dgst_size = DGST_SIZE_4_8;
9642 parse_func = cisco9_parse_hash;
9643 sort_by_digest = sort_by_digest_4_8;
9644 opti_type = OPTI_TYPE_ZERO_BYTE;
9645 dgst_pos0 = 0;
9646 dgst_pos1 = 1;
9647 dgst_pos2 = 2;
9648 dgst_pos3 = 3;
9649 break;
9650
9651 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9652 salt_type = SALT_TYPE_EMBEDDED;
9653 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9654 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9655 kern_type = KERN_TYPE_OFFICE2007;
9656 dgst_size = DGST_SIZE_4_4;
9657 parse_func = office2007_parse_hash;
9658 sort_by_digest = sort_by_digest_4_4;
9659 opti_type = OPTI_TYPE_ZERO_BYTE;
9660 dgst_pos0 = 0;
9661 dgst_pos1 = 1;
9662 dgst_pos2 = 2;
9663 dgst_pos3 = 3;
9664 break;
9665
9666 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9667 salt_type = SALT_TYPE_EMBEDDED;
9668 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9669 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9670 kern_type = KERN_TYPE_OFFICE2010;
9671 dgst_size = DGST_SIZE_4_4;
9672 parse_func = office2010_parse_hash;
9673 sort_by_digest = sort_by_digest_4_4;
9674 opti_type = OPTI_TYPE_ZERO_BYTE;
9675 dgst_pos0 = 0;
9676 dgst_pos1 = 1;
9677 dgst_pos2 = 2;
9678 dgst_pos3 = 3;
9679 break;
9680
9681 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9682 salt_type = SALT_TYPE_EMBEDDED;
9683 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9684 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9685 kern_type = KERN_TYPE_OFFICE2013;
9686 dgst_size = DGST_SIZE_4_4;
9687 parse_func = office2013_parse_hash;
9688 sort_by_digest = sort_by_digest_4_4;
9689 opti_type = OPTI_TYPE_ZERO_BYTE;
9690 dgst_pos0 = 0;
9691 dgst_pos1 = 1;
9692 dgst_pos2 = 2;
9693 dgst_pos3 = 3;
9694 break;
9695
9696 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9697 salt_type = SALT_TYPE_EMBEDDED;
9698 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9699 opts_type = OPTS_TYPE_PT_GENERATE_LE
9700 | OPTS_TYPE_PT_ADD80
9701 | OPTS_TYPE_PT_UNICODE;
9702 kern_type = KERN_TYPE_OLDOFFICE01;
9703 dgst_size = DGST_SIZE_4_4;
9704 parse_func = oldoffice01_parse_hash;
9705 sort_by_digest = sort_by_digest_4_4;
9706 opti_type = OPTI_TYPE_ZERO_BYTE
9707 | OPTI_TYPE_PRECOMPUTE_INIT
9708 | OPTI_TYPE_NOT_ITERATED;
9709 dgst_pos0 = 0;
9710 dgst_pos1 = 1;
9711 dgst_pos2 = 2;
9712 dgst_pos3 = 3;
9713 break;
9714
9715 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9716 salt_type = SALT_TYPE_EMBEDDED;
9717 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9718 opts_type = OPTS_TYPE_PT_GENERATE_LE
9719 | OPTS_TYPE_PT_ADD80;
9720 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9721 dgst_size = DGST_SIZE_4_4;
9722 parse_func = oldoffice01cm1_parse_hash;
9723 sort_by_digest = sort_by_digest_4_4;
9724 opti_type = OPTI_TYPE_ZERO_BYTE
9725 | OPTI_TYPE_PRECOMPUTE_INIT
9726 | OPTI_TYPE_NOT_ITERATED;
9727 dgst_pos0 = 0;
9728 dgst_pos1 = 1;
9729 dgst_pos2 = 2;
9730 dgst_pos3 = 3;
9731 break;
9732
9733 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9734 salt_type = SALT_TYPE_EMBEDDED;
9735 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9736 opts_type = OPTS_TYPE_PT_GENERATE_LE
9737 | OPTS_TYPE_PT_ADD80
9738 | OPTS_TYPE_PT_UNICODE
9739 | OPTS_TYPE_PT_NEVERCRACK;
9740 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9741 dgst_size = DGST_SIZE_4_4;
9742 parse_func = oldoffice01cm2_parse_hash;
9743 sort_by_digest = sort_by_digest_4_4;
9744 opti_type = OPTI_TYPE_ZERO_BYTE
9745 | OPTI_TYPE_PRECOMPUTE_INIT
9746 | OPTI_TYPE_NOT_ITERATED;
9747 dgst_pos0 = 0;
9748 dgst_pos1 = 1;
9749 dgst_pos2 = 2;
9750 dgst_pos3 = 3;
9751 break;
9752
9753 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9754 salt_type = SALT_TYPE_EMBEDDED;
9755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9756 opts_type = OPTS_TYPE_PT_GENERATE_BE
9757 | OPTS_TYPE_PT_ADD80
9758 | OPTS_TYPE_PT_UNICODE;
9759 kern_type = KERN_TYPE_OLDOFFICE34;
9760 dgst_size = DGST_SIZE_4_4;
9761 parse_func = oldoffice34_parse_hash;
9762 sort_by_digest = sort_by_digest_4_4;
9763 opti_type = OPTI_TYPE_ZERO_BYTE
9764 | OPTI_TYPE_PRECOMPUTE_INIT
9765 | OPTI_TYPE_NOT_ITERATED;
9766 dgst_pos0 = 0;
9767 dgst_pos1 = 1;
9768 dgst_pos2 = 2;
9769 dgst_pos3 = 3;
9770 break;
9771
9772 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9773 salt_type = SALT_TYPE_EMBEDDED;
9774 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9775 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9776 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9777 dgst_size = DGST_SIZE_4_4;
9778 parse_func = oldoffice34cm1_parse_hash;
9779 sort_by_digest = sort_by_digest_4_4;
9780 opti_type = OPTI_TYPE_ZERO_BYTE
9781 | OPTI_TYPE_PRECOMPUTE_INIT
9782 | OPTI_TYPE_NOT_ITERATED;
9783 dgst_pos0 = 0;
9784 dgst_pos1 = 1;
9785 dgst_pos2 = 2;
9786 dgst_pos3 = 3;
9787 break;
9788
9789 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9790 salt_type = SALT_TYPE_EMBEDDED;
9791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9792 opts_type = OPTS_TYPE_PT_GENERATE_BE
9793 | OPTS_TYPE_PT_ADD80
9794 | OPTS_TYPE_PT_UNICODE
9795 | OPTS_TYPE_PT_NEVERCRACK;
9796 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9797 dgst_size = DGST_SIZE_4_4;
9798 parse_func = oldoffice34cm2_parse_hash;
9799 sort_by_digest = sort_by_digest_4_4;
9800 opti_type = OPTI_TYPE_ZERO_BYTE
9801 | OPTI_TYPE_PRECOMPUTE_INIT
9802 | OPTI_TYPE_NOT_ITERATED;
9803 dgst_pos0 = 0;
9804 dgst_pos1 = 1;
9805 dgst_pos2 = 2;
9806 dgst_pos3 = 3;
9807 break;
9808
9809 case 9900: hash_type = HASH_TYPE_MD5;
9810 salt_type = SALT_TYPE_NONE;
9811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9812 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9813 kern_type = KERN_TYPE_RADMIN2;
9814 dgst_size = DGST_SIZE_4_4;
9815 parse_func = radmin2_parse_hash;
9816 sort_by_digest = sort_by_digest_4_4;
9817 opti_type = OPTI_TYPE_ZERO_BYTE
9818 | OPTI_TYPE_PRECOMPUTE_INIT
9819 | OPTI_TYPE_EARLY_SKIP
9820 | OPTI_TYPE_NOT_ITERATED
9821 | OPTI_TYPE_NOT_SALTED;
9822 dgst_pos0 = 0;
9823 dgst_pos1 = 3;
9824 dgst_pos2 = 2;
9825 dgst_pos3 = 1;
9826 break;
9827
9828 case 10000: hash_type = HASH_TYPE_SHA256;
9829 salt_type = SALT_TYPE_EMBEDDED;
9830 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9831 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9832 kern_type = KERN_TYPE_PBKDF2_SHA256;
9833 dgst_size = DGST_SIZE_4_32;
9834 parse_func = djangopbkdf2_parse_hash;
9835 sort_by_digest = sort_by_digest_4_32;
9836 opti_type = OPTI_TYPE_ZERO_BYTE
9837 | OPTI_TYPE_SLOW_HASH_SIMD;
9838 dgst_pos0 = 0;
9839 dgst_pos1 = 1;
9840 dgst_pos2 = 2;
9841 dgst_pos3 = 3;
9842 break;
9843
9844 case 10100: hash_type = HASH_TYPE_SIPHASH;
9845 salt_type = SALT_TYPE_EMBEDDED;
9846 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9847 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9848 kern_type = KERN_TYPE_SIPHASH;
9849 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9850 parse_func = siphash_parse_hash;
9851 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9852 opti_type = OPTI_TYPE_ZERO_BYTE
9853 | OPTI_TYPE_NOT_ITERATED
9854 | OPTI_TYPE_RAW_HASH;
9855 dgst_pos0 = 0;
9856 dgst_pos1 = 1;
9857 dgst_pos2 = 2;
9858 dgst_pos3 = 3;
9859 break;
9860
9861 case 10200: hash_type = HASH_TYPE_MD5;
9862 salt_type = SALT_TYPE_EMBEDDED;
9863 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9864 opts_type = OPTS_TYPE_PT_GENERATE_LE
9865 | OPTS_TYPE_ST_ADD80
9866 | OPTS_TYPE_ST_ADDBITS14;
9867 kern_type = KERN_TYPE_HMACMD5_PW;
9868 dgst_size = DGST_SIZE_4_4;
9869 parse_func = crammd5_parse_hash;
9870 sort_by_digest = sort_by_digest_4_4;
9871 opti_type = OPTI_TYPE_ZERO_BYTE
9872 | OPTI_TYPE_NOT_ITERATED;
9873 dgst_pos0 = 0;
9874 dgst_pos1 = 3;
9875 dgst_pos2 = 2;
9876 dgst_pos3 = 1;
9877 break;
9878
9879 case 10300: hash_type = HASH_TYPE_SHA1;
9880 salt_type = SALT_TYPE_EMBEDDED;
9881 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9882 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9883 kern_type = KERN_TYPE_SAPH_SHA1;
9884 dgst_size = DGST_SIZE_4_5;
9885 parse_func = saph_sha1_parse_hash;
9886 sort_by_digest = sort_by_digest_4_5;
9887 opti_type = OPTI_TYPE_ZERO_BYTE;
9888 dgst_pos0 = 0;
9889 dgst_pos1 = 1;
9890 dgst_pos2 = 2;
9891 dgst_pos3 = 3;
9892 break;
9893
9894 case 10400: hash_type = HASH_TYPE_PDFU16;
9895 salt_type = SALT_TYPE_EMBEDDED;
9896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9897 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9898 kern_type = KERN_TYPE_PDF11;
9899 dgst_size = DGST_SIZE_4_4;
9900 parse_func = pdf11_parse_hash;
9901 sort_by_digest = sort_by_digest_4_4;
9902 opti_type = OPTI_TYPE_ZERO_BYTE
9903 | OPTI_TYPE_NOT_ITERATED;
9904 dgst_pos0 = 0;
9905 dgst_pos1 = 1;
9906 dgst_pos2 = 2;
9907 dgst_pos3 = 3;
9908 break;
9909
9910 case 10410: hash_type = HASH_TYPE_PDFU16;
9911 salt_type = SALT_TYPE_EMBEDDED;
9912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9913 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9914 kern_type = KERN_TYPE_PDF11CM1;
9915 dgst_size = DGST_SIZE_4_4;
9916 parse_func = pdf11cm1_parse_hash;
9917 sort_by_digest = sort_by_digest_4_4;
9918 opti_type = OPTI_TYPE_ZERO_BYTE
9919 | OPTI_TYPE_NOT_ITERATED;
9920 dgst_pos0 = 0;
9921 dgst_pos1 = 1;
9922 dgst_pos2 = 2;
9923 dgst_pos3 = 3;
9924 break;
9925
9926 case 10420: hash_type = HASH_TYPE_PDFU16;
9927 salt_type = SALT_TYPE_EMBEDDED;
9928 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9929 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9930 kern_type = KERN_TYPE_PDF11CM2;
9931 dgst_size = DGST_SIZE_4_4;
9932 parse_func = pdf11cm2_parse_hash;
9933 sort_by_digest = sort_by_digest_4_4;
9934 opti_type = OPTI_TYPE_ZERO_BYTE
9935 | OPTI_TYPE_NOT_ITERATED;
9936 dgst_pos0 = 0;
9937 dgst_pos1 = 1;
9938 dgst_pos2 = 2;
9939 dgst_pos3 = 3;
9940 break;
9941
9942 case 10500: hash_type = HASH_TYPE_PDFU16;
9943 salt_type = SALT_TYPE_EMBEDDED;
9944 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9945 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9946 kern_type = KERN_TYPE_PDF14;
9947 dgst_size = DGST_SIZE_4_4;
9948 parse_func = pdf14_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 10600: hash_type = HASH_TYPE_SHA256;
9959 salt_type = SALT_TYPE_EMBEDDED;
9960 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9961 opts_type = OPTS_TYPE_PT_GENERATE_BE
9962 | OPTS_TYPE_ST_ADD80
9963 | OPTS_TYPE_ST_ADDBITS15
9964 | OPTS_TYPE_HASH_COPY;
9965 kern_type = KERN_TYPE_SHA256_PWSLT;
9966 dgst_size = DGST_SIZE_4_8;
9967 parse_func = pdf17l3_parse_hash;
9968 sort_by_digest = sort_by_digest_4_8;
9969 opti_type = OPTI_TYPE_ZERO_BYTE
9970 | OPTI_TYPE_PRECOMPUTE_INIT
9971 | OPTI_TYPE_PRECOMPUTE_MERKLE
9972 | OPTI_TYPE_EARLY_SKIP
9973 | OPTI_TYPE_NOT_ITERATED
9974 | OPTI_TYPE_APPENDED_SALT
9975 | OPTI_TYPE_RAW_HASH;
9976 dgst_pos0 = 3;
9977 dgst_pos1 = 7;
9978 dgst_pos2 = 2;
9979 dgst_pos3 = 6;
9980 break;
9981
9982 case 10700: hash_type = HASH_TYPE_PDFU32;
9983 salt_type = SALT_TYPE_EMBEDDED;
9984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9985 opts_type = OPTS_TYPE_PT_GENERATE_LE
9986 | OPTS_TYPE_HASH_COPY;
9987 kern_type = KERN_TYPE_PDF17L8;
9988 dgst_size = DGST_SIZE_4_8;
9989 parse_func = pdf17l8_parse_hash;
9990 sort_by_digest = sort_by_digest_4_8;
9991 opti_type = OPTI_TYPE_ZERO_BYTE
9992 | OPTI_TYPE_NOT_ITERATED;
9993 dgst_pos0 = 0;
9994 dgst_pos1 = 1;
9995 dgst_pos2 = 2;
9996 dgst_pos3 = 3;
9997 break;
9998
9999 case 10800: hash_type = HASH_TYPE_SHA384;
10000 salt_type = SALT_TYPE_NONE;
10001 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10002 opts_type = OPTS_TYPE_PT_GENERATE_BE
10003 | OPTS_TYPE_PT_ADD80
10004 | OPTS_TYPE_PT_ADDBITS15;
10005 kern_type = KERN_TYPE_SHA384;
10006 dgst_size = DGST_SIZE_8_8;
10007 parse_func = sha384_parse_hash;
10008 sort_by_digest = sort_by_digest_8_8;
10009 opti_type = OPTI_TYPE_ZERO_BYTE
10010 | OPTI_TYPE_PRECOMPUTE_INIT
10011 | OPTI_TYPE_PRECOMPUTE_MERKLE
10012 | OPTI_TYPE_EARLY_SKIP
10013 | OPTI_TYPE_NOT_ITERATED
10014 | OPTI_TYPE_NOT_SALTED
10015 | OPTI_TYPE_USES_BITS_64
10016 | OPTI_TYPE_RAW_HASH;
10017 dgst_pos0 = 6;
10018 dgst_pos1 = 7;
10019 dgst_pos2 = 4;
10020 dgst_pos3 = 5;
10021 break;
10022
10023 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10024 salt_type = SALT_TYPE_EMBEDDED;
10025 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10026 opts_type = OPTS_TYPE_PT_GENERATE_LE
10027 | OPTS_TYPE_ST_BASE64
10028 | OPTS_TYPE_HASH_COPY;
10029 kern_type = KERN_TYPE_PBKDF2_SHA256;
10030 dgst_size = DGST_SIZE_4_32;
10031 parse_func = pbkdf2_sha256_parse_hash;
10032 sort_by_digest = sort_by_digest_4_32;
10033 opti_type = OPTI_TYPE_ZERO_BYTE
10034 | OPTI_TYPE_SLOW_HASH_SIMD;
10035 dgst_pos0 = 0;
10036 dgst_pos1 = 1;
10037 dgst_pos2 = 2;
10038 dgst_pos3 = 3;
10039 break;
10040
10041 case 11000: hash_type = HASH_TYPE_MD5;
10042 salt_type = SALT_TYPE_INTERN;
10043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10044 opts_type = OPTS_TYPE_PT_GENERATE_LE
10045 | OPTS_TYPE_PT_ADD80;
10046 kern_type = KERN_TYPE_PRESTASHOP;
10047 dgst_size = DGST_SIZE_4_4;
10048 parse_func = prestashop_parse_hash;
10049 sort_by_digest = sort_by_digest_4_4;
10050 opti_type = OPTI_TYPE_ZERO_BYTE
10051 | OPTI_TYPE_PRECOMPUTE_INIT
10052 | OPTI_TYPE_NOT_ITERATED
10053 | OPTI_TYPE_PREPENDED_SALT;
10054 dgst_pos0 = 0;
10055 dgst_pos1 = 3;
10056 dgst_pos2 = 2;
10057 dgst_pos3 = 1;
10058 break;
10059
10060 case 11100: hash_type = HASH_TYPE_MD5;
10061 salt_type = SALT_TYPE_EMBEDDED;
10062 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10063 opts_type = OPTS_TYPE_PT_GENERATE_LE
10064 | OPTS_TYPE_ST_ADD80;
10065 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10066 dgst_size = DGST_SIZE_4_4;
10067 parse_func = postgresql_auth_parse_hash;
10068 sort_by_digest = sort_by_digest_4_4;
10069 opti_type = OPTI_TYPE_ZERO_BYTE
10070 | OPTI_TYPE_PRECOMPUTE_INIT
10071 | OPTI_TYPE_PRECOMPUTE_MERKLE
10072 | OPTI_TYPE_EARLY_SKIP;
10073 dgst_pos0 = 0;
10074 dgst_pos1 = 3;
10075 dgst_pos2 = 2;
10076 dgst_pos3 = 1;
10077 break;
10078
10079 case 11200: hash_type = HASH_TYPE_SHA1;
10080 salt_type = SALT_TYPE_EMBEDDED;
10081 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10082 opts_type = OPTS_TYPE_PT_GENERATE_BE
10083 | OPTS_TYPE_PT_ADD80
10084 | OPTS_TYPE_ST_HEX;
10085 kern_type = KERN_TYPE_MYSQL_AUTH;
10086 dgst_size = DGST_SIZE_4_5;
10087 parse_func = mysql_auth_parse_hash;
10088 sort_by_digest = sort_by_digest_4_5;
10089 opti_type = OPTI_TYPE_ZERO_BYTE
10090 | OPTI_TYPE_EARLY_SKIP;
10091 dgst_pos0 = 3;
10092 dgst_pos1 = 4;
10093 dgst_pos2 = 2;
10094 dgst_pos3 = 1;
10095 break;
10096
10097 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10098 salt_type = SALT_TYPE_EMBEDDED;
10099 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10100 opts_type = OPTS_TYPE_PT_GENERATE_LE
10101 | OPTS_TYPE_ST_HEX
10102 | OPTS_TYPE_ST_ADD80;
10103 kern_type = KERN_TYPE_BITCOIN_WALLET;
10104 dgst_size = DGST_SIZE_4_4;
10105 parse_func = bitcoin_wallet_parse_hash;
10106 sort_by_digest = sort_by_digest_4_4;
10107 opti_type = OPTI_TYPE_ZERO_BYTE;
10108 dgst_pos0 = 0;
10109 dgst_pos1 = 1;
10110 dgst_pos2 = 2;
10111 dgst_pos3 = 3;
10112 break;
10113
10114 case 11400: hash_type = HASH_TYPE_MD5;
10115 salt_type = SALT_TYPE_EMBEDDED;
10116 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10117 opts_type = OPTS_TYPE_PT_GENERATE_LE
10118 | OPTS_TYPE_PT_ADD80
10119 | OPTS_TYPE_HASH_COPY;
10120 kern_type = KERN_TYPE_SIP_AUTH;
10121 dgst_size = DGST_SIZE_4_4;
10122 parse_func = sip_auth_parse_hash;
10123 sort_by_digest = sort_by_digest_4_4;
10124 opti_type = OPTI_TYPE_ZERO_BYTE;
10125 dgst_pos0 = 0;
10126 dgst_pos1 = 3;
10127 dgst_pos2 = 2;
10128 dgst_pos3 = 1;
10129 break;
10130
10131 case 11500: hash_type = HASH_TYPE_CRC32;
10132 salt_type = SALT_TYPE_INTERN;
10133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10134 opts_type = OPTS_TYPE_PT_GENERATE_LE
10135 | OPTS_TYPE_ST_GENERATE_LE
10136 | OPTS_TYPE_ST_HEX;
10137 kern_type = KERN_TYPE_CRC32;
10138 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10139 parse_func = crc32_parse_hash;
10140 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10141 opti_type = OPTI_TYPE_ZERO_BYTE;
10142 dgst_pos0 = 0;
10143 dgst_pos1 = 1;
10144 dgst_pos2 = 2;
10145 dgst_pos3 = 3;
10146 break;
10147
10148 case 11600: hash_type = HASH_TYPE_AES;
10149 salt_type = SALT_TYPE_EMBEDDED;
10150 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10151 opts_type = OPTS_TYPE_PT_GENERATE_LE
10152 | OPTS_TYPE_PT_NEVERCRACK;
10153 kern_type = KERN_TYPE_SEVEN_ZIP;
10154 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10155 parse_func = seven_zip_parse_hash;
10156 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10157 opti_type = OPTI_TYPE_ZERO_BYTE;
10158 dgst_pos0 = 0;
10159 dgst_pos1 = 1;
10160 dgst_pos2 = 2;
10161 dgst_pos3 = 3;
10162 break;
10163
10164 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10165 salt_type = SALT_TYPE_NONE;
10166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10167 opts_type = OPTS_TYPE_PT_GENERATE_LE
10168 | OPTS_TYPE_PT_ADD01;
10169 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10170 dgst_size = DGST_SIZE_4_8;
10171 parse_func = gost2012sbog_256_parse_hash;
10172 sort_by_digest = sort_by_digest_4_8;
10173 opti_type = OPTI_TYPE_ZERO_BYTE;
10174 dgst_pos0 = 0;
10175 dgst_pos1 = 1;
10176 dgst_pos2 = 2;
10177 dgst_pos3 = 3;
10178 break;
10179
10180 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10181 salt_type = SALT_TYPE_NONE;
10182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10183 opts_type = OPTS_TYPE_PT_GENERATE_LE
10184 | OPTS_TYPE_PT_ADD01;
10185 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10186 dgst_size = DGST_SIZE_4_16;
10187 parse_func = gost2012sbog_512_parse_hash;
10188 sort_by_digest = sort_by_digest_4_16;
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 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10197 salt_type = SALT_TYPE_EMBEDDED;
10198 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10199 opts_type = OPTS_TYPE_PT_GENERATE_LE
10200 | OPTS_TYPE_ST_BASE64
10201 | OPTS_TYPE_HASH_COPY;
10202 kern_type = KERN_TYPE_PBKDF2_MD5;
10203 dgst_size = DGST_SIZE_4_32;
10204 parse_func = pbkdf2_md5_parse_hash;
10205 sort_by_digest = sort_by_digest_4_32;
10206 opti_type = OPTI_TYPE_ZERO_BYTE
10207 | OPTI_TYPE_SLOW_HASH_SIMD;
10208 dgst_pos0 = 0;
10209 dgst_pos1 = 1;
10210 dgst_pos2 = 2;
10211 dgst_pos3 = 3;
10212 break;
10213
10214 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10215 salt_type = SALT_TYPE_EMBEDDED;
10216 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10217 opts_type = OPTS_TYPE_PT_GENERATE_LE
10218 | OPTS_TYPE_ST_BASE64
10219 | OPTS_TYPE_HASH_COPY;
10220 kern_type = KERN_TYPE_PBKDF2_SHA1;
10221 dgst_size = DGST_SIZE_4_32;
10222 parse_func = pbkdf2_sha1_parse_hash;
10223 sort_by_digest = sort_by_digest_4_32;
10224 opti_type = OPTI_TYPE_ZERO_BYTE
10225 | OPTI_TYPE_SLOW_HASH_SIMD;
10226 dgst_pos0 = 0;
10227 dgst_pos1 = 1;
10228 dgst_pos2 = 2;
10229 dgst_pos3 = 3;
10230 break;
10231
10232 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10233 salt_type = SALT_TYPE_EMBEDDED;
10234 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10235 opts_type = OPTS_TYPE_PT_GENERATE_LE
10236 | OPTS_TYPE_ST_BASE64
10237 | OPTS_TYPE_HASH_COPY;
10238 kern_type = KERN_TYPE_PBKDF2_SHA512;
10239 dgst_size = DGST_SIZE_8_16;
10240 parse_func = pbkdf2_sha512_parse_hash;
10241 sort_by_digest = sort_by_digest_8_16;
10242 opti_type = OPTI_TYPE_ZERO_BYTE
10243 | OPTI_TYPE_USES_BITS_64
10244 | OPTI_TYPE_SLOW_HASH_SIMD;
10245 dgst_pos0 = 0;
10246 dgst_pos1 = 1;
10247 dgst_pos2 = 2;
10248 dgst_pos3 = 3;
10249 break;
10250
10251 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10252 salt_type = SALT_TYPE_EMBEDDED;
10253 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10254 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10255 kern_type = KERN_TYPE_ECRYPTFS;
10256 dgst_size = DGST_SIZE_8_8;
10257 parse_func = ecryptfs_parse_hash;
10258 sort_by_digest = sort_by_digest_8_8;
10259 opti_type = OPTI_TYPE_ZERO_BYTE
10260 | OPTI_TYPE_USES_BITS_64;
10261 dgst_pos0 = 0;
10262 dgst_pos1 = 1;
10263 dgst_pos2 = 2;
10264 dgst_pos3 = 3;
10265 break;
10266
10267 case 12300: hash_type = HASH_TYPE_ORACLET;
10268 salt_type = SALT_TYPE_EMBEDDED;
10269 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10270 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10271 kern_type = KERN_TYPE_ORACLET;
10272 dgst_size = DGST_SIZE_8_16;
10273 parse_func = oraclet_parse_hash;
10274 sort_by_digest = sort_by_digest_8_16;
10275 opti_type = OPTI_TYPE_ZERO_BYTE
10276 | OPTI_TYPE_USES_BITS_64;
10277 dgst_pos0 = 0;
10278 dgst_pos1 = 1;
10279 dgst_pos2 = 2;
10280 dgst_pos3 = 3;
10281 break;
10282
10283 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10284 salt_type = SALT_TYPE_EMBEDDED;
10285 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10286 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10287 kern_type = KERN_TYPE_BSDICRYPT;
10288 dgst_size = DGST_SIZE_4_4;
10289 parse_func = bsdicrypt_parse_hash;
10290 sort_by_digest = sort_by_digest_4_4;
10291 opti_type = OPTI_TYPE_ZERO_BYTE
10292 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10293 dgst_pos0 = 0;
10294 dgst_pos1 = 1;
10295 dgst_pos2 = 2;
10296 dgst_pos3 = 3;
10297 break;
10298
10299 case 12500: hash_type = HASH_TYPE_RAR3HP;
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_RAR3;
10304 dgst_size = DGST_SIZE_4_4;
10305 parse_func = rar3hp_parse_hash;
10306 sort_by_digest = sort_by_digest_4_4;
10307 opti_type = OPTI_TYPE_ZERO_BYTE;
10308 dgst_pos0 = 0;
10309 dgst_pos1 = 1;
10310 dgst_pos2 = 2;
10311 dgst_pos3 = 3;
10312 break;
10313
10314 case 12600: hash_type = HASH_TYPE_SHA256;
10315 salt_type = SALT_TYPE_INTERN;
10316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10317 opts_type = OPTS_TYPE_PT_GENERATE_BE
10318 | OPTS_TYPE_PT_ADD80;
10319 kern_type = KERN_TYPE_CF10;
10320 dgst_size = DGST_SIZE_4_8;
10321 parse_func = cf10_parse_hash;
10322 sort_by_digest = sort_by_digest_4_8;
10323 opti_type = OPTI_TYPE_ZERO_BYTE
10324 | OPTI_TYPE_PRECOMPUTE_INIT
10325 | OPTI_TYPE_EARLY_SKIP
10326 | OPTI_TYPE_NOT_ITERATED;
10327 dgst_pos0 = 3;
10328 dgst_pos1 = 7;
10329 dgst_pos2 = 2;
10330 dgst_pos3 = 6;
10331 break;
10332
10333 case 12700: hash_type = HASH_TYPE_AES;
10334 salt_type = SALT_TYPE_EMBEDDED;
10335 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10336 opts_type = OPTS_TYPE_PT_GENERATE_LE
10337 | OPTS_TYPE_HASH_COPY;
10338 kern_type = KERN_TYPE_MYWALLET;
10339 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10340 parse_func = mywallet_parse_hash;
10341 sort_by_digest = sort_by_digest_4_5;
10342 opti_type = OPTI_TYPE_ZERO_BYTE;
10343 dgst_pos0 = 0;
10344 dgst_pos1 = 1;
10345 dgst_pos2 = 2;
10346 dgst_pos3 = 3;
10347 break;
10348
10349 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10350 salt_type = SALT_TYPE_EMBEDDED;
10351 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10352 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10353 kern_type = KERN_TYPE_MS_DRSR;
10354 dgst_size = DGST_SIZE_4_8;
10355 parse_func = ms_drsr_parse_hash;
10356 sort_by_digest = sort_by_digest_4_8;
10357 opti_type = OPTI_TYPE_ZERO_BYTE;
10358 dgst_pos0 = 0;
10359 dgst_pos1 = 1;
10360 dgst_pos2 = 2;
10361 dgst_pos3 = 3;
10362 break;
10363
10364 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10365 salt_type = SALT_TYPE_EMBEDDED;
10366 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10367 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10368 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10369 dgst_size = DGST_SIZE_4_8;
10370 parse_func = androidfde_samsung_parse_hash;
10371 sort_by_digest = sort_by_digest_4_8;
10372 opti_type = OPTI_TYPE_ZERO_BYTE;
10373 dgst_pos0 = 0;
10374 dgst_pos1 = 1;
10375 dgst_pos2 = 2;
10376 dgst_pos3 = 3;
10377 break;
10378
10379 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10380 salt_type = SALT_TYPE_EMBEDDED;
10381 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10382 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10383 kern_type = KERN_TYPE_RAR5;
10384 dgst_size = DGST_SIZE_4_4;
10385 parse_func = rar5_parse_hash;
10386 sort_by_digest = sort_by_digest_4_4;
10387 opti_type = OPTI_TYPE_ZERO_BYTE;
10388 dgst_pos0 = 0;
10389 dgst_pos1 = 1;
10390 dgst_pos2 = 2;
10391 dgst_pos3 = 3;
10392 break;
10393
10394 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10395 salt_type = SALT_TYPE_EMBEDDED;
10396 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10397 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10398 kern_type = KERN_TYPE_KRB5TGS;
10399 dgst_size = DGST_SIZE_4_4;
10400 parse_func = krb5tgs_parse_hash;
10401 sort_by_digest = sort_by_digest_4_4;
10402 opti_type = OPTI_TYPE_ZERO_BYTE
10403 | OPTI_TYPE_NOT_ITERATED;
10404 dgst_pos0 = 0;
10405 dgst_pos1 = 1;
10406 dgst_pos2 = 2;
10407 dgst_pos3 = 3;
10408 break;
10409
10410 case 13200: hash_type = HASH_TYPE_AES;
10411 salt_type = SALT_TYPE_EMBEDDED;
10412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10413 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10414 kern_type = KERN_TYPE_AXCRYPT;
10415 dgst_size = DGST_SIZE_4_4;
10416 parse_func = axcrypt_parse_hash;
10417 sort_by_digest = sort_by_digest_4_4;
10418 opti_type = OPTI_TYPE_ZERO_BYTE;
10419 dgst_pos0 = 0;
10420 dgst_pos1 = 1;
10421 dgst_pos2 = 2;
10422 dgst_pos3 = 3;
10423 break;
10424
10425 case 13300: hash_type = HASH_TYPE_SHA1;
10426 salt_type = SALT_TYPE_NONE;
10427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10428 opts_type = OPTS_TYPE_PT_GENERATE_BE
10429 | OPTS_TYPE_PT_ADD80
10430 | OPTS_TYPE_PT_ADDBITS15;
10431 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10432 dgst_size = DGST_SIZE_4_5;
10433 parse_func = sha1axcrypt_parse_hash;
10434 sort_by_digest = sort_by_digest_4_5;
10435 opti_type = OPTI_TYPE_ZERO_BYTE
10436 | OPTI_TYPE_PRECOMPUTE_INIT
10437 | OPTI_TYPE_EARLY_SKIP
10438 | OPTI_TYPE_NOT_ITERATED
10439 | OPTI_TYPE_NOT_SALTED;
10440 dgst_pos0 = 0;
10441 dgst_pos1 = 4;
10442 dgst_pos2 = 3;
10443 dgst_pos3 = 2;
10444 break;
10445
10446 case 13400: hash_type = HASH_TYPE_AES;
10447 salt_type = SALT_TYPE_EMBEDDED;
10448 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10449 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10450 kern_type = KERN_TYPE_KEEPASS;
10451 dgst_size = DGST_SIZE_4_4;
10452 parse_func = keepass_parse_hash;
10453 sort_by_digest = sort_by_digest_4_4;
10454 opti_type = OPTI_TYPE_ZERO_BYTE;
10455 dgst_pos0 = 0;
10456 dgst_pos1 = 1;
10457 dgst_pos2 = 2;
10458 dgst_pos3 = 3;
10459 break;
10460
10461 case 13500: hash_type = HASH_TYPE_SHA1;
10462 salt_type = SALT_TYPE_EMBEDDED;
10463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10464 opts_type = OPTS_TYPE_PT_GENERATE_BE
10465 | OPTS_TYPE_PT_UNICODE
10466 | OPTS_TYPE_PT_ADD80;
10467 kern_type = KERN_TYPE_PSTOKEN;
10468 dgst_size = DGST_SIZE_4_5;
10469 parse_func = pstoken_parse_hash;
10470 sort_by_digest = sort_by_digest_4_5;
10471 opti_type = OPTI_TYPE_ZERO_BYTE
10472 | OPTI_TYPE_PRECOMPUTE_INIT
10473 | OPTI_TYPE_EARLY_SKIP
10474 | OPTI_TYPE_NOT_ITERATED
10475 | OPTI_TYPE_PREPENDED_SALT
10476 | OPTI_TYPE_RAW_HASH;
10477 dgst_pos0 = 3;
10478 dgst_pos1 = 4;
10479 dgst_pos2 = 2;
10480 dgst_pos3 = 1;
10481 break;
10482
10483 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10484 salt_type = SALT_TYPE_EMBEDDED;
10485 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10486 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10487 kern_type = KERN_TYPE_ZIP2;
10488 dgst_size = DGST_SIZE_4_4;
10489 parse_func = zip2_parse_hash;
10490 sort_by_digest = sort_by_digest_4_4;
10491 opti_type = OPTI_TYPE_ZERO_BYTE;
10492 dgst_pos0 = 0;
10493 dgst_pos1 = 1;
10494 dgst_pos2 = 2;
10495 dgst_pos3 = 3;
10496 break;
10497
10498 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10499 salt_type = SALT_TYPE_EMBEDDED;
10500 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10501 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10502 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10503 dgst_size = DGST_SIZE_4_5;
10504 parse_func = veracrypt_parse_hash_655331;
10505 sort_by_digest = sort_by_digest_4_5;
10506 opti_type = OPTI_TYPE_ZERO_BYTE;
10507 dgst_pos0 = 0;
10508 dgst_pos1 = 1;
10509 dgst_pos2 = 2;
10510 dgst_pos3 = 3;
10511 break;
10512
10513 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10514 salt_type = SALT_TYPE_EMBEDDED;
10515 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10516 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10517 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10518 dgst_size = DGST_SIZE_4_5;
10519 parse_func = veracrypt_parse_hash_655331;
10520 sort_by_digest = sort_by_digest_4_5;
10521 opti_type = OPTI_TYPE_ZERO_BYTE;
10522 dgst_pos0 = 0;
10523 dgst_pos1 = 1;
10524 dgst_pos2 = 2;
10525 dgst_pos3 = 3;
10526 break;
10527
10528 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10529 salt_type = SALT_TYPE_EMBEDDED;
10530 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10531 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10532 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10533 dgst_size = DGST_SIZE_4_5;
10534 parse_func = veracrypt_parse_hash_655331;
10535 sort_by_digest = sort_by_digest_4_5;
10536 opti_type = OPTI_TYPE_ZERO_BYTE;
10537 dgst_pos0 = 0;
10538 dgst_pos1 = 1;
10539 dgst_pos2 = 2;
10540 dgst_pos3 = 3;
10541 break;
10542
10543 case 13721: hash_type = HASH_TYPE_SHA512;
10544 salt_type = SALT_TYPE_EMBEDDED;
10545 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10546 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10547 kern_type = KERN_TYPE_TCSHA512_XTS512;
10548 dgst_size = DGST_SIZE_8_8;
10549 parse_func = veracrypt_parse_hash_500000;
10550 sort_by_digest = sort_by_digest_8_8;
10551 opti_type = OPTI_TYPE_ZERO_BYTE
10552 | OPTI_TYPE_USES_BITS_64;
10553 dgst_pos0 = 0;
10554 dgst_pos1 = 1;
10555 dgst_pos2 = 2;
10556 dgst_pos3 = 3;
10557 break;
10558
10559 case 13722: hash_type = HASH_TYPE_SHA512;
10560 salt_type = SALT_TYPE_EMBEDDED;
10561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10562 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10563 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10564 dgst_size = DGST_SIZE_8_8;
10565 parse_func = veracrypt_parse_hash_500000;
10566 sort_by_digest = sort_by_digest_8_8;
10567 opti_type = OPTI_TYPE_ZERO_BYTE
10568 | OPTI_TYPE_USES_BITS_64;
10569 dgst_pos0 = 0;
10570 dgst_pos1 = 1;
10571 dgst_pos2 = 2;
10572 dgst_pos3 = 3;
10573 break;
10574
10575 case 13723: hash_type = HASH_TYPE_SHA512;
10576 salt_type = SALT_TYPE_EMBEDDED;
10577 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10578 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10579 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10580 dgst_size = DGST_SIZE_8_8;
10581 parse_func = veracrypt_parse_hash_500000;
10582 sort_by_digest = sort_by_digest_8_8;
10583 opti_type = OPTI_TYPE_ZERO_BYTE
10584 | OPTI_TYPE_USES_BITS_64;
10585 dgst_pos0 = 0;
10586 dgst_pos1 = 1;
10587 dgst_pos2 = 2;
10588 dgst_pos3 = 3;
10589 break;
10590
10591 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10592 salt_type = SALT_TYPE_EMBEDDED;
10593 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10594 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10595 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10596 dgst_size = DGST_SIZE_4_8;
10597 parse_func = veracrypt_parse_hash_500000;
10598 sort_by_digest = sort_by_digest_4_8;
10599 opti_type = OPTI_TYPE_ZERO_BYTE;
10600 dgst_pos0 = 0;
10601 dgst_pos1 = 1;
10602 dgst_pos2 = 2;
10603 dgst_pos3 = 3;
10604 break;
10605
10606 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10607 salt_type = SALT_TYPE_EMBEDDED;
10608 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10609 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10610 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10611 dgst_size = DGST_SIZE_4_8;
10612 parse_func = veracrypt_parse_hash_500000;
10613 sort_by_digest = sort_by_digest_4_8;
10614 opti_type = OPTI_TYPE_ZERO_BYTE;
10615 dgst_pos0 = 0;
10616 dgst_pos1 = 1;
10617 dgst_pos2 = 2;
10618 dgst_pos3 = 3;
10619 break;
10620
10621 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10622 salt_type = SALT_TYPE_EMBEDDED;
10623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10624 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10625 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10626 dgst_size = DGST_SIZE_4_8;
10627 parse_func = veracrypt_parse_hash_500000;
10628 sort_by_digest = sort_by_digest_4_8;
10629 opti_type = OPTI_TYPE_ZERO_BYTE;
10630 dgst_pos0 = 0;
10631 dgst_pos1 = 1;
10632 dgst_pos2 = 2;
10633 dgst_pos3 = 3;
10634 break;
10635
10636 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10637 salt_type = SALT_TYPE_EMBEDDED;
10638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10639 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10640 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10641 dgst_size = DGST_SIZE_4_5;
10642 parse_func = veracrypt_parse_hash_327661;
10643 sort_by_digest = sort_by_digest_4_5;
10644 opti_type = OPTI_TYPE_ZERO_BYTE;
10645 dgst_pos0 = 0;
10646 dgst_pos1 = 1;
10647 dgst_pos2 = 2;
10648 dgst_pos3 = 3;
10649 break;
10650
10651 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10652 salt_type = SALT_TYPE_EMBEDDED;
10653 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10654 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10655 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10656 dgst_size = DGST_SIZE_4_5;
10657 parse_func = veracrypt_parse_hash_327661;
10658 sort_by_digest = sort_by_digest_4_5;
10659 opti_type = OPTI_TYPE_ZERO_BYTE;
10660 dgst_pos0 = 0;
10661 dgst_pos1 = 1;
10662 dgst_pos2 = 2;
10663 dgst_pos3 = 3;
10664 break;
10665
10666 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10667 salt_type = SALT_TYPE_EMBEDDED;
10668 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10669 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10670 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10671 dgst_size = DGST_SIZE_4_5;
10672 parse_func = veracrypt_parse_hash_327661;
10673 sort_by_digest = sort_by_digest_4_5;
10674 opti_type = OPTI_TYPE_ZERO_BYTE;
10675 dgst_pos0 = 0;
10676 dgst_pos1 = 1;
10677 dgst_pos2 = 2;
10678 dgst_pos3 = 3;
10679 break;
10680
10681 case 13751: hash_type = HASH_TYPE_SHA256;
10682 salt_type = SALT_TYPE_EMBEDDED;
10683 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10684 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10685 kern_type = KERN_TYPE_VCSHA256_XTS512;
10686 dgst_size = DGST_SIZE_4_8;
10687 parse_func = veracrypt_parse_hash_500000;
10688 sort_by_digest = sort_by_digest_4_8;
10689 opti_type = OPTI_TYPE_ZERO_BYTE;
10690 dgst_pos0 = 0;
10691 dgst_pos1 = 1;
10692 dgst_pos2 = 2;
10693 dgst_pos3 = 3;
10694 break;
10695
10696 case 13752: hash_type = HASH_TYPE_SHA256;
10697 salt_type = SALT_TYPE_EMBEDDED;
10698 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10699 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10700 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10701 dgst_size = DGST_SIZE_4_8;
10702 parse_func = veracrypt_parse_hash_500000;
10703 sort_by_digest = sort_by_digest_4_8;
10704 opti_type = OPTI_TYPE_ZERO_BYTE;
10705 dgst_pos0 = 0;
10706 dgst_pos1 = 1;
10707 dgst_pos2 = 2;
10708 dgst_pos3 = 3;
10709 break;
10710
10711 case 13753: hash_type = HASH_TYPE_SHA256;
10712 salt_type = SALT_TYPE_EMBEDDED;
10713 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10714 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10715 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10716 dgst_size = DGST_SIZE_4_8;
10717 parse_func = veracrypt_parse_hash_500000;
10718 sort_by_digest = sort_by_digest_4_8;
10719 opti_type = OPTI_TYPE_ZERO_BYTE;
10720 dgst_pos0 = 0;
10721 dgst_pos1 = 1;
10722 dgst_pos2 = 2;
10723 dgst_pos3 = 3;
10724 break;
10725
10726 case 13761: hash_type = HASH_TYPE_SHA256;
10727 salt_type = SALT_TYPE_EMBEDDED;
10728 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10729 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10730 kern_type = KERN_TYPE_VCSHA256_XTS512;
10731 dgst_size = DGST_SIZE_4_8;
10732 parse_func = veracrypt_parse_hash_200000;
10733 sort_by_digest = sort_by_digest_4_8;
10734 opti_type = OPTI_TYPE_ZERO_BYTE;
10735 dgst_pos0 = 0;
10736 dgst_pos1 = 1;
10737 dgst_pos2 = 2;
10738 dgst_pos3 = 3;
10739 break;
10740
10741 case 13762: hash_type = HASH_TYPE_SHA256;
10742 salt_type = SALT_TYPE_EMBEDDED;
10743 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10744 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10745 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10746 dgst_size = DGST_SIZE_4_8;
10747 parse_func = veracrypt_parse_hash_200000;
10748 sort_by_digest = sort_by_digest_4_8;
10749 opti_type = OPTI_TYPE_ZERO_BYTE;
10750 dgst_pos0 = 0;
10751 dgst_pos1 = 1;
10752 dgst_pos2 = 2;
10753 dgst_pos3 = 3;
10754 break;
10755
10756 case 13763: hash_type = HASH_TYPE_SHA256;
10757 salt_type = SALT_TYPE_EMBEDDED;
10758 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10759 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10760 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10761 dgst_size = DGST_SIZE_4_8;
10762 parse_func = veracrypt_parse_hash_200000;
10763 sort_by_digest = sort_by_digest_4_8;
10764 opti_type = OPTI_TYPE_ZERO_BYTE;
10765 dgst_pos0 = 0;
10766 dgst_pos1 = 1;
10767 dgst_pos2 = 2;
10768 dgst_pos3 = 3;
10769 break;
10770
10771
10772 default: usage_mini_print (PROGNAME); return (-1);
10773 }
10774
10775 /**
10776 * parser
10777 */
10778
10779 data.parse_func = parse_func;
10780
10781 /**
10782 * misc stuff
10783 */
10784
10785 if (hex_salt)
10786 {
10787 if (salt_type == SALT_TYPE_INTERN)
10788 {
10789 opts_type |= OPTS_TYPE_ST_HEX;
10790 }
10791 else
10792 {
10793 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10794
10795 return (-1);
10796 }
10797 }
10798
10799 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10800 | (salt_type == SALT_TYPE_EXTERN)
10801 | (salt_type == SALT_TYPE_EMBEDDED)
10802 | (salt_type == SALT_TYPE_VIRTUAL));
10803
10804 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10805
10806 data.hash_type = hash_type;
10807 data.attack_mode = attack_mode;
10808 data.attack_kern = attack_kern;
10809 data.attack_exec = attack_exec;
10810 data.kern_type = kern_type;
10811 data.opts_type = opts_type;
10812 data.dgst_size = dgst_size;
10813 data.salt_type = salt_type;
10814 data.isSalted = isSalted;
10815 data.sort_by_digest = sort_by_digest;
10816 data.dgst_pos0 = dgst_pos0;
10817 data.dgst_pos1 = dgst_pos1;
10818 data.dgst_pos2 = dgst_pos2;
10819 data.dgst_pos3 = dgst_pos3;
10820
10821 esalt_size = 0;
10822
10823 switch (hash_mode)
10824 {
10825 case 2500: esalt_size = sizeof (wpa_t); break;
10826 case 5300: esalt_size = sizeof (ikepsk_t); break;
10827 case 5400: esalt_size = sizeof (ikepsk_t); break;
10828 case 5500: esalt_size = sizeof (netntlm_t); break;
10829 case 5600: esalt_size = sizeof (netntlm_t); break;
10830 case 6211: esalt_size = sizeof (tc_t); break;
10831 case 6212: esalt_size = sizeof (tc_t); break;
10832 case 6213: esalt_size = sizeof (tc_t); break;
10833 case 6221: esalt_size = sizeof (tc_t); break;
10834 case 6222: esalt_size = sizeof (tc_t); break;
10835 case 6223: esalt_size = sizeof (tc_t); break;
10836 case 6231: esalt_size = sizeof (tc_t); break;
10837 case 6232: esalt_size = sizeof (tc_t); break;
10838 case 6233: esalt_size = sizeof (tc_t); break;
10839 case 6241: esalt_size = sizeof (tc_t); break;
10840 case 6242: esalt_size = sizeof (tc_t); break;
10841 case 6243: esalt_size = sizeof (tc_t); break;
10842 case 6600: esalt_size = sizeof (agilekey_t); break;
10843 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10844 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10845 case 7300: esalt_size = sizeof (rakp_t); break;
10846 case 7500: esalt_size = sizeof (krb5pa_t); break;
10847 case 8200: esalt_size = sizeof (cloudkey_t); break;
10848 case 8800: esalt_size = sizeof (androidfde_t); break;
10849 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10850 case 9400: esalt_size = sizeof (office2007_t); break;
10851 case 9500: esalt_size = sizeof (office2010_t); break;
10852 case 9600: esalt_size = sizeof (office2013_t); break;
10853 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10854 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10855 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10856 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10857 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10858 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10859 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10860 case 10200: esalt_size = sizeof (cram_md5_t); break;
10861 case 10400: esalt_size = sizeof (pdf_t); break;
10862 case 10410: esalt_size = sizeof (pdf_t); break;
10863 case 10420: esalt_size = sizeof (pdf_t); break;
10864 case 10500: esalt_size = sizeof (pdf_t); break;
10865 case 10600: esalt_size = sizeof (pdf_t); break;
10866 case 10700: esalt_size = sizeof (pdf_t); break;
10867 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10868 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10869 case 11400: esalt_size = sizeof (sip_t); break;
10870 case 11600: esalt_size = sizeof (seven_zip_t); break;
10871 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10872 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10873 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10874 case 13000: esalt_size = sizeof (rar5_t); break;
10875 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10876 case 13400: esalt_size = sizeof (keepass_t); break;
10877 case 13500: esalt_size = sizeof (pstoken_t); break;
10878 case 13600: esalt_size = sizeof (zip2_t); break;
10879 case 13711: esalt_size = sizeof (tc_t); break;
10880 case 13712: esalt_size = sizeof (tc_t); break;
10881 case 13713: esalt_size = sizeof (tc_t); break;
10882 case 13721: esalt_size = sizeof (tc_t); break;
10883 case 13722: esalt_size = sizeof (tc_t); break;
10884 case 13723: esalt_size = sizeof (tc_t); break;
10885 case 13731: esalt_size = sizeof (tc_t); break;
10886 case 13732: esalt_size = sizeof (tc_t); break;
10887 case 13733: esalt_size = sizeof (tc_t); break;
10888 case 13741: esalt_size = sizeof (tc_t); break;
10889 case 13742: esalt_size = sizeof (tc_t); break;
10890 case 13743: esalt_size = sizeof (tc_t); break;
10891 case 13751: esalt_size = sizeof (tc_t); break;
10892 case 13752: esalt_size = sizeof (tc_t); break;
10893 case 13753: esalt_size = sizeof (tc_t); break;
10894 case 13761: esalt_size = sizeof (tc_t); break;
10895 case 13762: esalt_size = sizeof (tc_t); break;
10896 case 13763: esalt_size = sizeof (tc_t); break;
10897 }
10898
10899 data.esalt_size = esalt_size;
10900
10901 /**
10902 * choose dictionary parser
10903 */
10904
10905 if (hash_type == HASH_TYPE_LM)
10906 {
10907 get_next_word_func = get_next_word_lm;
10908 }
10909 else if (opts_type & OPTS_TYPE_PT_UPPER)
10910 {
10911 get_next_word_func = get_next_word_uc;
10912 }
10913 else
10914 {
10915 get_next_word_func = get_next_word_std;
10916 }
10917
10918 /**
10919 * dictstat
10920 */
10921
10922 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10923
10924 #ifdef _POSIX
10925 size_t dictstat_nmemb = 0;
10926 #endif
10927
10928 #ifdef _WIN
10929 uint dictstat_nmemb = 0;
10930 #endif
10931
10932 char dictstat[256] = { 0 };
10933
10934 FILE *dictstat_fp = NULL;
10935
10936 if (keyspace == 0)
10937 {
10938 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10939
10940 dictstat_fp = fopen (dictstat, "rb");
10941
10942 if (dictstat_fp)
10943 {
10944 #ifdef _POSIX
10945 struct stat tmpstat;
10946
10947 fstat (fileno (dictstat_fp), &tmpstat);
10948 #endif
10949
10950 #ifdef _WIN
10951 struct stat64 tmpstat;
10952
10953 _fstat64 (fileno (dictstat_fp), &tmpstat);
10954 #endif
10955
10956 if (tmpstat.st_mtime < COMPTIME)
10957 {
10958 /* with v0.15 the format changed so we have to ensure user is using a good version
10959 since there is no version-header in the dictstat file */
10960
10961 fclose (dictstat_fp);
10962
10963 unlink (dictstat);
10964 }
10965 else
10966 {
10967 while (!feof (dictstat_fp))
10968 {
10969 dictstat_t d;
10970
10971 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10972
10973 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10974
10975 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10976 {
10977 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10978
10979 return -1;
10980 }
10981 }
10982
10983 fclose (dictstat_fp);
10984 }
10985 }
10986 }
10987
10988 /**
10989 * potfile
10990 */
10991
10992 char potfile[256] = { 0 };
10993
10994 if (potfile_path == NULL)
10995 {
10996 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10997 }
10998 else
10999 {
11000 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11001 }
11002
11003 data.pot_fp = NULL;
11004
11005 FILE *out_fp = NULL;
11006 FILE *pot_fp = NULL;
11007
11008 if (show == 1 || left == 1)
11009 {
11010 pot_fp = fopen (potfile, "rb");
11011
11012 if (pot_fp == NULL)
11013 {
11014 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11015
11016 return (-1);
11017 }
11018
11019 if (outfile != NULL)
11020 {
11021 if ((out_fp = fopen (outfile, "ab")) == NULL)
11022 {
11023 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11024
11025 fclose (pot_fp);
11026
11027 return (-1);
11028 }
11029 }
11030 else
11031 {
11032 out_fp = stdout;
11033 }
11034 }
11035 else
11036 {
11037 if (potfile_disable == 0)
11038 {
11039 pot_fp = fopen (potfile, "ab");
11040
11041 if (pot_fp == NULL)
11042 {
11043 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11044
11045 return (-1);
11046 }
11047
11048 data.pot_fp = pot_fp;
11049 }
11050 }
11051
11052 pot_t *pot = NULL;
11053
11054 uint pot_cnt = 0;
11055 uint pot_avail = 0;
11056
11057 if (show == 1 || left == 1)
11058 {
11059 SUPPRESS_OUTPUT = 1;
11060
11061 pot_avail = count_lines (pot_fp);
11062
11063 rewind (pot_fp);
11064
11065 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11066
11067 uint pot_hashes_avail = 0;
11068
11069 uint line_num = 0;
11070
11071 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11072
11073 while (!feof (pot_fp))
11074 {
11075 line_num++;
11076
11077 int line_len = fgetl (pot_fp, line_buf);
11078
11079 if (line_len == 0) continue;
11080
11081 char *plain_buf = line_buf + line_len;
11082
11083 pot_t *pot_ptr = &pot[pot_cnt];
11084
11085 hash_t *hashes_buf = &pot_ptr->hash;
11086
11087 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11088 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11089
11090 if (pot_cnt == pot_hashes_avail)
11091 {
11092 uint pos = 0;
11093
11094 for (pos = 0; pos < INCR_POT; pos++)
11095 {
11096 if ((pot_cnt + pos) >= pot_avail) break;
11097
11098 pot_t *tmp_pot = &pot[pot_cnt + pos];
11099
11100 hash_t *tmp_hash = &tmp_pot->hash;
11101
11102 tmp_hash->digest = mymalloc (dgst_size);
11103
11104 if (isSalted)
11105 {
11106 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11107 }
11108
11109 if (esalt_size)
11110 {
11111 tmp_hash->esalt = mymalloc (esalt_size);
11112 }
11113
11114 pot_hashes_avail++;
11115 }
11116 }
11117
11118 int plain_len = 0;
11119
11120 int parser_status;
11121
11122 int iter = MAX_CUT_TRIES;
11123
11124 do
11125 {
11126 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11127 {
11128 if (line_buf[i] == ':')
11129 {
11130 line_len--;
11131
11132 break;
11133 }
11134 }
11135
11136 if (data.hash_mode != 2500)
11137 {
11138 parser_status = parse_func (line_buf, line_len, hashes_buf);
11139 }
11140 else
11141 {
11142 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11143
11144 if (line_len > max_salt_size)
11145 {
11146 parser_status = PARSER_GLOBAL_LENGTH;
11147 }
11148 else
11149 {
11150 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11151
11152 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11153
11154 hashes_buf->salt->salt_len = line_len;
11155
11156 parser_status = PARSER_OK;
11157 }
11158 }
11159
11160 // if NOT parsed without error, we add the ":" to the plain
11161
11162 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11163 {
11164 plain_len++;
11165 plain_buf--;
11166 }
11167
11168 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11169
11170 if (parser_status < PARSER_GLOBAL_ZERO)
11171 {
11172 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11173
11174 continue;
11175 }
11176
11177 if (plain_len >= 255) continue;
11178
11179 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11180
11181 pot_ptr->plain_len = plain_len;
11182
11183 pot_cnt++;
11184 }
11185
11186 myfree (line_buf);
11187
11188 fclose (pot_fp);
11189
11190 SUPPRESS_OUTPUT = 0;
11191
11192 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11193 }
11194
11195 /**
11196 * word len
11197 */
11198
11199 uint pw_min = PW_MIN;
11200 uint pw_max = PW_MAX;
11201
11202 switch (hash_mode)
11203 {
11204 case 125: if (pw_max > 32) pw_max = 32;
11205 break;
11206 case 400: if (pw_max > 40) pw_max = 40;
11207 break;
11208 case 500: if (pw_max > 16) pw_max = 16;
11209 break;
11210 case 1500: if (pw_max > 8) pw_max = 8;
11211 break;
11212 case 1600: if (pw_max > 16) pw_max = 16;
11213 break;
11214 case 1800: if (pw_max > 16) pw_max = 16;
11215 break;
11216 case 2100: if (pw_max > 16) pw_max = 16;
11217 break;
11218 case 2500: if (pw_min < 8) pw_min = 8;
11219 break;
11220 case 3000: if (pw_max > 7) pw_max = 7;
11221 break;
11222 case 5200: if (pw_max > 24) pw_max = 24;
11223 break;
11224 case 5800: if (pw_max > 16) pw_max = 16;
11225 break;
11226 case 6300: if (pw_max > 16) pw_max = 16;
11227 break;
11228 case 7400: if (pw_max > 16) pw_max = 16;
11229 break;
11230 case 7500: if (pw_max > 8) pw_max = 8;
11231 break;
11232 case 7900: if (pw_max > 48) pw_max = 48;
11233 break;
11234 case 8500: if (pw_max > 8) pw_max = 8;
11235 break;
11236 case 8600: if (pw_max > 16) pw_max = 16;
11237 break;
11238 case 9710: pw_min = 5;
11239 pw_max = 5;
11240 break;
11241 case 9810: pw_min = 5;
11242 pw_max = 5;
11243 break;
11244 case 10410: pw_min = 5;
11245 pw_max = 5;
11246 break;
11247 case 10300: if (pw_max < 3) pw_min = 3;
11248 if (pw_max > 40) pw_max = 40;
11249 break;
11250 case 10500: if (pw_max < 3) pw_min = 3;
11251 if (pw_max > 40) pw_max = 40;
11252 break;
11253 case 10700: if (pw_max > 16) pw_max = 16;
11254 break;
11255 case 11300: if (pw_max > 40) pw_max = 40;
11256 break;
11257 case 11600: if (pw_max > 32) pw_max = 32;
11258 break;
11259 case 12500: if (pw_max > 20) pw_max = 20;
11260 break;
11261 case 12800: if (pw_max > 24) pw_max = 24;
11262 break;
11263 }
11264
11265 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11266 {
11267 switch (attack_kern)
11268 {
11269 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11270 break;
11271 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11272 break;
11273 }
11274 }
11275
11276 /**
11277 * charsets : keep them together for more easy maintainnce
11278 */
11279
11280 cs_t mp_sys[6] = { { { 0 }, 0 } };
11281 cs_t mp_usr[4] = { { { 0 }, 0 } };
11282
11283 mp_setup_sys (mp_sys);
11284
11285 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11286 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11287 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11288 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11289
11290 /**
11291 * load hashes, part I: find input mode, count hashes
11292 */
11293
11294 uint hashlist_mode = 0;
11295 uint hashlist_format = HLFMT_HASHCAT;
11296
11297 uint hashes_avail = 0;
11298
11299 if (benchmark == 0)
11300 {
11301 struct stat f;
11302
11303 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11304
11305 if ((hash_mode == 2500) ||
11306 (hash_mode == 5200) ||
11307 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11308 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11309 (hash_mode == 9000))
11310 {
11311 hashlist_mode = HL_MODE_ARG;
11312
11313 char *hashfile = myargv[optind];
11314
11315 data.hashfile = hashfile;
11316
11317 logfile_top_var_string ("target", hashfile);
11318 }
11319
11320 if (hashlist_mode == HL_MODE_ARG)
11321 {
11322 if (hash_mode == 2500)
11323 {
11324 struct stat st;
11325
11326 if (stat (data.hashfile, &st) == -1)
11327 {
11328 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11329
11330 return (-1);
11331 }
11332
11333 hashes_avail = st.st_size / sizeof (hccap_t);
11334 }
11335 else
11336 {
11337 hashes_avail = 1;
11338 }
11339 }
11340 else if (hashlist_mode == HL_MODE_FILE)
11341 {
11342 char *hashfile = myargv[optind];
11343
11344 data.hashfile = hashfile;
11345
11346 logfile_top_var_string ("target", hashfile);
11347
11348 FILE *fp = NULL;
11349
11350 if ((fp = fopen (hashfile, "rb")) == NULL)
11351 {
11352 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11353
11354 return (-1);
11355 }
11356
11357 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11358
11359 hashes_avail = count_lines (fp);
11360
11361 rewind (fp);
11362
11363 if (hashes_avail == 0)
11364 {
11365 log_error ("ERROR: hashfile is empty or corrupt");
11366
11367 fclose (fp);
11368
11369 return (-1);
11370 }
11371
11372 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11373
11374 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11375 {
11376 log_error ("ERROR: remove not supported in native hashfile-format mode");
11377
11378 fclose (fp);
11379
11380 return (-1);
11381 }
11382
11383 fclose (fp);
11384 }
11385 }
11386 else
11387 {
11388 hashlist_mode = HL_MODE_ARG;
11389
11390 hashes_avail = 1;
11391 }
11392
11393 if (hash_mode == 3000) hashes_avail *= 2;
11394
11395 data.hashlist_mode = hashlist_mode;
11396 data.hashlist_format = hashlist_format;
11397
11398 logfile_top_uint (hashlist_mode);
11399 logfile_top_uint (hashlist_format);
11400
11401 /**
11402 * load hashes, part II: allocate required memory, set pointers
11403 */
11404
11405 hash_t *hashes_buf = NULL;
11406 void *digests_buf = NULL;
11407 salt_t *salts_buf = NULL;
11408 void *esalts_buf = NULL;
11409
11410 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11411
11412 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11413
11414 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11415 {
11416 u32 hash_pos;
11417
11418 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11419 {
11420 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11421
11422 hashes_buf[hash_pos].hash_info = hash_info;
11423
11424 if (username && (remove || show || left))
11425 {
11426 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11427 }
11428
11429 if (benchmark)
11430 {
11431 hash_info->orighash = (char *) mymalloc (256);
11432 }
11433 }
11434 }
11435
11436 if (isSalted)
11437 {
11438 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11439
11440 if (esalt_size)
11441 {
11442 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11443 }
11444 }
11445 else
11446 {
11447 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11448 }
11449
11450 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11451 {
11452 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11453
11454 if (isSalted)
11455 {
11456 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11457
11458 if (esalt_size)
11459 {
11460 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11461 }
11462 }
11463 else
11464 {
11465 hashes_buf[hash_pos].salt = &salts_buf[0];
11466 }
11467 }
11468
11469 /**
11470 * load hashes, part III: parse hashes or generate them if benchmark
11471 */
11472
11473 uint hashes_cnt = 0;
11474
11475 if (benchmark == 0)
11476 {
11477 if (keyspace == 1)
11478 {
11479 // useless to read hash file for keyspace, cheat a little bit w/ optind
11480 }
11481 else if (hashes_avail == 0)
11482 {
11483 }
11484 else if (hashlist_mode == HL_MODE_ARG)
11485 {
11486 char *input_buf = myargv[optind];
11487
11488 uint input_len = strlen (input_buf);
11489
11490 logfile_top_var_string ("target", input_buf);
11491
11492 char *hash_buf = NULL;
11493 int hash_len = 0;
11494
11495 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11496
11497 bool hash_fmt_error = 0;
11498
11499 if (hash_len < 1) hash_fmt_error = 1;
11500 if (hash_buf == NULL) hash_fmt_error = 1;
11501
11502 if (hash_fmt_error)
11503 {
11504 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11505 }
11506 else
11507 {
11508 if (opts_type & OPTS_TYPE_HASH_COPY)
11509 {
11510 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11511
11512 hash_info_tmp->orighash = mystrdup (hash_buf);
11513 }
11514
11515 if (isSalted)
11516 {
11517 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11518 }
11519
11520 int parser_status = PARSER_OK;
11521
11522 if (hash_mode == 2500)
11523 {
11524 if (hash_len == 0)
11525 {
11526 log_error ("ERROR: hccap file not specified");
11527
11528 return (-1);
11529 }
11530
11531 hashlist_mode = HL_MODE_FILE;
11532
11533 data.hashlist_mode = hashlist_mode;
11534
11535 FILE *fp = fopen (hash_buf, "rb");
11536
11537 if (fp == NULL)
11538 {
11539 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11540
11541 return (-1);
11542 }
11543
11544 if (hashes_avail < 1)
11545 {
11546 log_error ("ERROR: hccap file is empty or corrupt");
11547
11548 fclose (fp);
11549
11550 return (-1);
11551 }
11552
11553 uint hccap_size = sizeof (hccap_t);
11554
11555 char *in = (char *) mymalloc (hccap_size);
11556
11557 while (!feof (fp))
11558 {
11559 int n = fread (in, hccap_size, 1, fp);
11560
11561 if (n != 1)
11562 {
11563 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11564
11565 break;
11566 }
11567
11568 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11569
11570 if (parser_status != PARSER_OK)
11571 {
11572 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11573
11574 continue;
11575 }
11576
11577 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11578
11579 if ((show == 1) || (left == 1))
11580 {
11581 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11582
11583 char *salt_ptr = (char *) tmp_salt->salt_buf;
11584
11585 int cur_pos = tmp_salt->salt_len;
11586 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11587
11588 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11589
11590 // do the appending task
11591
11592 snprintf (salt_ptr + cur_pos,
11593 rem_len,
11594 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11595 wpa->orig_mac1[0],
11596 wpa->orig_mac1[1],
11597 wpa->orig_mac1[2],
11598 wpa->orig_mac1[3],
11599 wpa->orig_mac1[4],
11600 wpa->orig_mac1[5],
11601 wpa->orig_mac2[0],
11602 wpa->orig_mac2[1],
11603 wpa->orig_mac2[2],
11604 wpa->orig_mac2[3],
11605 wpa->orig_mac2[4],
11606 wpa->orig_mac2[5]);
11607
11608 // memset () the remaining part of the salt
11609
11610 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11611 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11612
11613 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11614
11615 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11616 }
11617
11618 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);
11619 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);
11620
11621 hashes_cnt++;
11622 }
11623
11624 fclose (fp);
11625
11626 myfree (in);
11627 }
11628 else if (hash_mode == 3000)
11629 {
11630 if (hash_len == 32)
11631 {
11632 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11633
11634 hash_t *lm_hash_left = NULL;
11635
11636 if (parser_status == PARSER_OK)
11637 {
11638 lm_hash_left = &hashes_buf[hashes_cnt];
11639
11640 hashes_cnt++;
11641 }
11642 else
11643 {
11644 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11645 }
11646
11647 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11648
11649 hash_t *lm_hash_right = NULL;
11650
11651 if (parser_status == PARSER_OK)
11652 {
11653 lm_hash_right = &hashes_buf[hashes_cnt];
11654
11655 hashes_cnt++;
11656 }
11657 else
11658 {
11659 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11660 }
11661
11662 // show / left
11663
11664 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11665 {
11666 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);
11667 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);
11668 }
11669 }
11670 else
11671 {
11672 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11673
11674 if (parser_status == PARSER_OK)
11675 {
11676 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11677 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11678 }
11679
11680 if (parser_status == PARSER_OK)
11681 {
11682 hashes_cnt++;
11683 }
11684 else
11685 {
11686 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11687 }
11688 }
11689 }
11690 else
11691 {
11692 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11693
11694 if (parser_status == PARSER_OK)
11695 {
11696 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11697 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11698 }
11699
11700 if (parser_status == PARSER_OK)
11701 {
11702 hashes_cnt++;
11703 }
11704 else
11705 {
11706 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11707 }
11708 }
11709 }
11710 }
11711 else if (hashlist_mode == HL_MODE_FILE)
11712 {
11713 char *hashfile = data.hashfile;
11714
11715 FILE *fp;
11716
11717 if ((fp = fopen (hashfile, "rb")) == NULL)
11718 {
11719 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11720
11721 return (-1);
11722 }
11723
11724 uint line_num = 0;
11725
11726 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11727
11728 while (!feof (fp))
11729 {
11730 line_num++;
11731
11732 int line_len = fgetl (fp, line_buf);
11733
11734 if (line_len == 0) continue;
11735
11736 char *hash_buf = NULL;
11737 int hash_len = 0;
11738
11739 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11740
11741 bool hash_fmt_error = 0;
11742
11743 if (hash_len < 1) hash_fmt_error = 1;
11744 if (hash_buf == NULL) hash_fmt_error = 1;
11745
11746 if (hash_fmt_error)
11747 {
11748 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11749
11750 continue;
11751 }
11752
11753 if (username)
11754 {
11755 char *user_buf = NULL;
11756 int user_len = 0;
11757
11758 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11759
11760 if (remove || show)
11761 {
11762 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11763
11764 *user = (user_t *) mymalloc (sizeof (user_t));
11765
11766 user_t *user_ptr = *user;
11767
11768 if (user_buf != NULL)
11769 {
11770 user_ptr->user_name = mystrdup (user_buf);
11771 }
11772 else
11773 {
11774 user_ptr->user_name = mystrdup ("");
11775 }
11776
11777 user_ptr->user_len = user_len;
11778 }
11779 }
11780
11781 if (opts_type & OPTS_TYPE_HASH_COPY)
11782 {
11783 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11784
11785 hash_info_tmp->orighash = mystrdup (hash_buf);
11786 }
11787
11788 if (isSalted)
11789 {
11790 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11791 }
11792
11793 if (hash_mode == 3000)
11794 {
11795 if (hash_len == 32)
11796 {
11797 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11798
11799 if (parser_status < PARSER_GLOBAL_ZERO)
11800 {
11801 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11802
11803 continue;
11804 }
11805
11806 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11807
11808 hashes_cnt++;
11809
11810 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11811
11812 if (parser_status < PARSER_GLOBAL_ZERO)
11813 {
11814 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11815
11816 continue;
11817 }
11818
11819 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11820
11821 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);
11822
11823 hashes_cnt++;
11824
11825 // show / left
11826
11827 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);
11828 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);
11829 }
11830 else
11831 {
11832 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11833
11834 if (parser_status < PARSER_GLOBAL_ZERO)
11835 {
11836 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11837
11838 continue;
11839 }
11840
11841 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);
11842
11843 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11844 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11845
11846 hashes_cnt++;
11847 }
11848 }
11849 else
11850 {
11851 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11852
11853 if (parser_status < PARSER_GLOBAL_ZERO)
11854 {
11855 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11856
11857 continue;
11858 }
11859
11860 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);
11861
11862 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11863 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11864
11865 hashes_cnt++;
11866 }
11867 }
11868
11869 myfree (line_buf);
11870
11871 fclose (fp);
11872
11873 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11874
11875 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11876 }
11877 }
11878 else
11879 {
11880 if (isSalted)
11881 {
11882 hashes_buf[0].salt->salt_len = 8;
11883
11884 // special salt handling
11885
11886 switch (hash_mode)
11887 {
11888 case 1500: hashes_buf[0].salt->salt_len = 2;
11889 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11890 break;
11891 case 1731: hashes_buf[0].salt->salt_len = 4;
11892 break;
11893 case 2410: hashes_buf[0].salt->salt_len = 4;
11894 break;
11895 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11896 break;
11897 case 3100: hashes_buf[0].salt->salt_len = 1;
11898 break;
11899 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11900 break;
11901 case 5800: hashes_buf[0].salt->salt_len = 16;
11902 break;
11903 case 6800: hashes_buf[0].salt->salt_len = 32;
11904 break;
11905 case 8400: hashes_buf[0].salt->salt_len = 40;
11906 break;
11907 case 8800: hashes_buf[0].salt->salt_len = 16;
11908 break;
11909 case 8900: hashes_buf[0].salt->salt_len = 16;
11910 hashes_buf[0].salt->scrypt_N = 1024;
11911 hashes_buf[0].salt->scrypt_r = 1;
11912 hashes_buf[0].salt->scrypt_p = 1;
11913 break;
11914 case 9100: hashes_buf[0].salt->salt_len = 16;
11915 break;
11916 case 9300: hashes_buf[0].salt->salt_len = 14;
11917 hashes_buf[0].salt->scrypt_N = 16384;
11918 hashes_buf[0].salt->scrypt_r = 1;
11919 hashes_buf[0].salt->scrypt_p = 1;
11920 break;
11921 case 9400: hashes_buf[0].salt->salt_len = 16;
11922 break;
11923 case 9500: hashes_buf[0].salt->salt_len = 16;
11924 break;
11925 case 9600: hashes_buf[0].salt->salt_len = 16;
11926 break;
11927 case 9700: hashes_buf[0].salt->salt_len = 16;
11928 break;
11929 case 9710: hashes_buf[0].salt->salt_len = 16;
11930 break;
11931 case 9720: hashes_buf[0].salt->salt_len = 16;
11932 break;
11933 case 9800: hashes_buf[0].salt->salt_len = 16;
11934 break;
11935 case 9810: hashes_buf[0].salt->salt_len = 16;
11936 break;
11937 case 9820: hashes_buf[0].salt->salt_len = 16;
11938 break;
11939 case 10300: hashes_buf[0].salt->salt_len = 12;
11940 break;
11941 case 11500: hashes_buf[0].salt->salt_len = 4;
11942 break;
11943 case 11600: hashes_buf[0].salt->salt_len = 4;
11944 break;
11945 case 12400: hashes_buf[0].salt->salt_len = 4;
11946 break;
11947 case 12500: hashes_buf[0].salt->salt_len = 8;
11948 break;
11949 case 12600: hashes_buf[0].salt->salt_len = 64;
11950 break;
11951 }
11952
11953 // special esalt handling
11954
11955 switch (hash_mode)
11956 {
11957 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11958 break;
11959 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11960 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11961 break;
11962 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11963 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11964 break;
11965 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11966 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11967 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11968 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11969 break;
11970 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11971 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11972 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11973 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11974 break;
11975 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11976 break;
11977 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11978 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11979 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11980 break;
11981 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11982 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11983 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11984 break;
11985 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11986 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11987 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11988 break;
11989 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11990 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11991 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11992 break;
11993 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11994 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11995 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11996 break;
11997 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11998 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11999 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12000 break;
12001 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12002 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12003 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12004 break;
12005 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12006 break;
12007 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12008 break;
12009 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12010 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12011 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12012 break;
12013 }
12014 }
12015
12016 // set hashfile
12017
12018 switch (hash_mode)
12019 {
12020 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12021 break;
12022 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12023 break;
12024 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12025 break;
12026 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12027 break;
12028 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12029 break;
12030 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12031 break;
12032 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12033 break;
12034 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12035 break;
12036 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12037 break;
12038 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12039 break;
12040 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12041 break;
12042 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12043 break;
12044 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12045 break;
12046 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12047 break;
12048 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12049 break;
12050 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12051 break;
12052 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12053 break;
12054 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12055 break;
12056 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12057 break;
12058 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12059 break;
12060 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12061 break;
12062 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12063 break;
12064 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12065 break;
12066 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12067 break;
12068 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12069 break;
12070 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12071 break;
12072 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12073 break;
12074 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12075 break;
12076 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12077 break;
12078 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12079 break;
12080 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12081 break;
12082 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12083 break;
12084 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12085 break;
12086 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12087 break;
12088 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12089 break;
12090 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12091 break;
12092 }
12093
12094 // set default iterations
12095
12096 switch (hash_mode)
12097 {
12098 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12099 break;
12100 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12101 break;
12102 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12103 break;
12104 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12105 break;
12106 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12107 break;
12108 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12109 break;
12110 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12111 break;
12112 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12113 break;
12114 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12115 break;
12116 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12117 break;
12118 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12119 break;
12120 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12121 break;
12122 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12123 break;
12124 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12125 break;
12126 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12127 break;
12128 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12129 break;
12130 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12131 break;
12132 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12133 break;
12134 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12135 break;
12136 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12137 break;
12138 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12139 break;
12140 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12141 break;
12142 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12143 break;
12144 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12145 break;
12146 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12147 break;
12148 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12149 break;
12150 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12151 break;
12152 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12153 break;
12154 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12155 break;
12156 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12157 break;
12158 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12159 break;
12160 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12161 break;
12162 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12163 break;
12164 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12165 break;
12166 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12167 break;
12168 case 8900: hashes_buf[0].salt->salt_iter = 1;
12169 break;
12170 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12171 break;
12172 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12173 break;
12174 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12175 break;
12176 case 9300: hashes_buf[0].salt->salt_iter = 1;
12177 break;
12178 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12179 break;
12180 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12181 break;
12182 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12183 break;
12184 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12185 break;
12186 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12187 break;
12188 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12189 break;
12190 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12191 break;
12192 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12193 break;
12194 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12195 break;
12196 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12197 break;
12198 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12199 break;
12200 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12201 break;
12202 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12203 break;
12204 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12205 break;
12206 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12207 break;
12208 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12209 break;
12210 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12211 break;
12212 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12213 break;
12214 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12215 break;
12216 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12217 break;
12218 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12219 break;
12220 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12221 break;
12222 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12223 break;
12224 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12225 break;
12226 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12227 break;
12228 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12229 break;
12230 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12231 break;
12232 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12233 break;
12234 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12235 break;
12236 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12237 break;
12238 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12239 break;
12240 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12241 break;
12242 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12243 break;
12244 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12245 break;
12246 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12247 break;
12248 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12249 break;
12250 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12251 break;
12252 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12253 break;
12254 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12255 break;
12256 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12257 break;
12258 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12259 break;
12260 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12261 break;
12262 }
12263
12264 hashes_cnt = 1;
12265 }
12266
12267 if (show == 1 || left == 1)
12268 {
12269 for (uint i = 0; i < pot_cnt; i++)
12270 {
12271 pot_t *pot_ptr = &pot[i];
12272
12273 hash_t *hashes_buf = &pot_ptr->hash;
12274
12275 local_free (hashes_buf->digest);
12276
12277 if (isSalted)
12278 {
12279 local_free (hashes_buf->salt);
12280 }
12281 }
12282
12283 local_free (pot);
12284
12285 if (data.quiet == 0) log_info_nn ("");
12286
12287 return (0);
12288 }
12289
12290 if (keyspace == 0)
12291 {
12292 if (hashes_cnt == 0)
12293 {
12294 log_error ("ERROR: No hashes loaded");
12295
12296 return (-1);
12297 }
12298 }
12299
12300 /**
12301 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12302 */
12303
12304 if (data.outfile != NULL)
12305 {
12306 if (data.hashfile != NULL)
12307 {
12308 #ifdef _POSIX
12309 struct stat tmpstat_outfile;
12310 struct stat tmpstat_hashfile;
12311 #endif
12312
12313 #ifdef _WIN
12314 struct stat64 tmpstat_outfile;
12315 struct stat64 tmpstat_hashfile;
12316 #endif
12317
12318 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12319
12320 if (tmp_outfile_fp)
12321 {
12322 #ifdef _POSIX
12323 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12324 #endif
12325
12326 #ifdef _WIN
12327 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12328 #endif
12329
12330 fclose (tmp_outfile_fp);
12331 }
12332
12333 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12334
12335 if (tmp_hashfile_fp)
12336 {
12337 #ifdef _POSIX
12338 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12339 #endif
12340
12341 #ifdef _WIN
12342 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12343 #endif
12344
12345 fclose (tmp_hashfile_fp);
12346 }
12347
12348 if (tmp_outfile_fp && tmp_outfile_fp)
12349 {
12350 tmpstat_outfile.st_mode = 0;
12351 tmpstat_outfile.st_nlink = 0;
12352 tmpstat_outfile.st_uid = 0;
12353 tmpstat_outfile.st_gid = 0;
12354 tmpstat_outfile.st_rdev = 0;
12355 tmpstat_outfile.st_atime = 0;
12356
12357 tmpstat_hashfile.st_mode = 0;
12358 tmpstat_hashfile.st_nlink = 0;
12359 tmpstat_hashfile.st_uid = 0;
12360 tmpstat_hashfile.st_gid = 0;
12361 tmpstat_hashfile.st_rdev = 0;
12362 tmpstat_hashfile.st_atime = 0;
12363
12364 #ifdef _POSIX
12365 tmpstat_outfile.st_blksize = 0;
12366 tmpstat_outfile.st_blocks = 0;
12367
12368 tmpstat_hashfile.st_blksize = 0;
12369 tmpstat_hashfile.st_blocks = 0;
12370 #endif
12371
12372 #ifdef _POSIX
12373 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12374 {
12375 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12376
12377 return (-1);
12378 }
12379 #endif
12380
12381 #ifdef _WIN
12382 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12383 {
12384 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12385
12386 return (-1);
12387 }
12388 #endif
12389 }
12390 }
12391 }
12392
12393 /**
12394 * Remove duplicates
12395 */
12396
12397 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12398
12399 if (isSalted)
12400 {
12401 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12402 }
12403 else
12404 {
12405 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12406 }
12407
12408 uint hashes_cnt_orig = hashes_cnt;
12409
12410 hashes_cnt = 1;
12411
12412 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12413 {
12414 if (isSalted)
12415 {
12416 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12417 {
12418 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12419 }
12420 }
12421 else
12422 {
12423 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12424 }
12425
12426 if (hashes_pos > hashes_cnt)
12427 {
12428 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12429 }
12430
12431 hashes_cnt++;
12432 }
12433
12434 /**
12435 * Potfile removes
12436 */
12437
12438 uint potfile_remove_cracks = 0;
12439
12440 if (potfile_disable == 0)
12441 {
12442 hash_t hash_buf;
12443
12444 hash_buf.digest = mymalloc (dgst_size);
12445 hash_buf.salt = NULL;
12446 hash_buf.esalt = NULL;
12447 hash_buf.hash_info = NULL;
12448 hash_buf.cracked = 0;
12449
12450 if (isSalted)
12451 {
12452 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12453 }
12454
12455 if (esalt_size)
12456 {
12457 hash_buf.esalt = mymalloc (esalt_size);
12458 }
12459
12460 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12461
12462 // no solution for these special hash types (for instane because they use hashfile in output etc)
12463 if ((hash_mode != 5200) &&
12464 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12465 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12466 (hash_mode != 9000))
12467 {
12468 FILE *fp = fopen (potfile, "rb");
12469
12470 if (fp != NULL)
12471 {
12472 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12473
12474 // to be safe work with a copy (because of line_len loop, i etc)
12475 // moved up here because it's easier to handle continue case
12476 // it's just 64kb
12477
12478 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12479
12480 while (!feof (fp))
12481 {
12482 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12483
12484 if (ptr == NULL) break;
12485
12486 int line_len = strlen (line_buf);
12487
12488 if (line_len == 0) continue;
12489
12490 int iter = MAX_CUT_TRIES;
12491
12492 for (int i = line_len - 1; i && iter; i--, line_len--)
12493 {
12494 if (line_buf[i] != ':') continue;
12495
12496 if (isSalted)
12497 {
12498 memset (hash_buf.salt, 0, sizeof (salt_t));
12499 }
12500
12501 hash_t *found = NULL;
12502
12503 if (hash_mode == 6800)
12504 {
12505 if (i < 64) // 64 = 16 * uint in salt_buf[]
12506 {
12507 // manipulate salt_buf
12508 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12509
12510 hash_buf.salt->salt_len = i;
12511
12512 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12513 }
12514 }
12515 else if (hash_mode == 2500)
12516 {
12517 if (i < 64) // 64 = 16 * uint in salt_buf[]
12518 {
12519 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12520 // manipulate salt_buf
12521
12522 memcpy (line_buf_cpy, line_buf, i);
12523
12524 char *mac2_pos = strrchr (line_buf_cpy, ':');
12525
12526 if (mac2_pos == NULL) continue;
12527
12528 mac2_pos[0] = 0;
12529 mac2_pos++;
12530
12531 if (strlen (mac2_pos) != 12) continue;
12532
12533 char *mac1_pos = strrchr (line_buf_cpy, ':');
12534
12535 if (mac1_pos == NULL) continue;
12536
12537 mac1_pos[0] = 0;
12538 mac1_pos++;
12539
12540 if (strlen (mac1_pos) != 12) continue;
12541
12542 uint essid_length = mac1_pos - line_buf_cpy - 1;
12543
12544 // here we need the ESSID
12545 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12546
12547 hash_buf.salt->salt_len = essid_length;
12548
12549 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12550
12551 if (found)
12552 {
12553 wpa_t *wpa = (wpa_t *) found->esalt;
12554
12555 // compare hex string(s) vs binary MAC address(es)
12556
12557 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12558 {
12559 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12560 {
12561 found = NULL;
12562
12563 break;
12564 }
12565 }
12566
12567 // early skip ;)
12568 if (!found) continue;
12569
12570 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12571 {
12572 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12573 {
12574 found = NULL;
12575
12576 break;
12577 }
12578 }
12579 }
12580 }
12581 }
12582 else
12583 {
12584 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12585
12586 if (parser_status == PARSER_OK)
12587 {
12588 if (isSalted)
12589 {
12590 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12591 }
12592 else
12593 {
12594 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12595 }
12596 }
12597 }
12598
12599 if (found == NULL) continue;
12600
12601 if (!found->cracked) potfile_remove_cracks++;
12602
12603 found->cracked = 1;
12604
12605 if (found) break;
12606
12607 iter--;
12608 }
12609 }
12610
12611 myfree (line_buf_cpy);
12612
12613 myfree (line_buf);
12614
12615 fclose (fp);
12616 }
12617 }
12618
12619 if (esalt_size)
12620 {
12621 local_free (hash_buf.esalt);
12622 }
12623
12624 if (isSalted)
12625 {
12626 local_free (hash_buf.salt);
12627 }
12628
12629 local_free (hash_buf.digest);
12630 }
12631
12632 /**
12633 * Now generate all the buffers required for later
12634 */
12635
12636 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12637
12638 salt_t *salts_buf_new = NULL;
12639 void *esalts_buf_new = NULL;
12640
12641 if (isSalted)
12642 {
12643 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12644
12645 if (esalt_size)
12646 {
12647 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12648 }
12649 }
12650 else
12651 {
12652 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12653 }
12654
12655 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12656
12657 uint digests_cnt = hashes_cnt;
12658 uint digests_done = 0;
12659
12660 size_t size_digests = digests_cnt * dgst_size;
12661 size_t size_shown = digests_cnt * sizeof (uint);
12662
12663 uint *digests_shown = (uint *) mymalloc (size_shown);
12664 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12665
12666 uint salts_cnt = 0;
12667 uint salts_done = 0;
12668
12669 hashinfo_t **hash_info = NULL;
12670
12671 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12672 {
12673 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12674
12675 if (username && (remove || show))
12676 {
12677 uint user_pos;
12678
12679 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12680 {
12681 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12682
12683 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12684 }
12685 }
12686 }
12687
12688 uint *salts_shown = (uint *) mymalloc (size_shown);
12689
12690 salt_t *salt_buf;
12691
12692 {
12693 // copied from inner loop
12694
12695 salt_buf = &salts_buf_new[salts_cnt];
12696
12697 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12698
12699 if (esalt_size)
12700 {
12701 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12702 }
12703
12704 salt_buf->digests_cnt = 0;
12705 salt_buf->digests_done = 0;
12706 salt_buf->digests_offset = 0;
12707
12708 salts_cnt++;
12709 }
12710
12711 if (hashes_buf[0].cracked == 1)
12712 {
12713 digests_shown[0] = 1;
12714
12715 digests_done++;
12716
12717 salt_buf->digests_done++;
12718 }
12719
12720 salt_buf->digests_cnt++;
12721
12722 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12723
12724 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12725 {
12726 hash_info[0] = hashes_buf[0].hash_info;
12727 }
12728
12729 // copy from inner loop
12730
12731 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12732 {
12733 if (isSalted)
12734 {
12735 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12736 {
12737 salt_buf = &salts_buf_new[salts_cnt];
12738
12739 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12740
12741 if (esalt_size)
12742 {
12743 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12744 }
12745
12746 salt_buf->digests_cnt = 0;
12747 salt_buf->digests_done = 0;
12748 salt_buf->digests_offset = hashes_pos;
12749
12750 salts_cnt++;
12751 }
12752 }
12753
12754 if (hashes_buf[hashes_pos].cracked == 1)
12755 {
12756 digests_shown[hashes_pos] = 1;
12757
12758 digests_done++;
12759
12760 salt_buf->digests_done++;
12761 }
12762
12763 salt_buf->digests_cnt++;
12764
12765 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12766
12767 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12768 {
12769 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12770 }
12771 }
12772
12773 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12774 {
12775 salt_t *salt_buf = &salts_buf_new[salt_pos];
12776
12777 if (salt_buf->digests_done == salt_buf->digests_cnt)
12778 {
12779 salts_shown[salt_pos] = 1;
12780
12781 salts_done++;
12782 }
12783
12784 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12785 }
12786
12787 local_free (digests_buf);
12788 local_free (salts_buf);
12789 local_free (esalts_buf);
12790
12791 digests_buf = digests_buf_new;
12792 salts_buf = salts_buf_new;
12793 esalts_buf = esalts_buf_new;
12794
12795 local_free (hashes_buf);
12796
12797 /**
12798 * special modification not set from parser
12799 */
12800
12801 switch (hash_mode)
12802 {
12803 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12804 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12805 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12806 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12807 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12808 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12809 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12810 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12811 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12812 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12813 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12814 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12815 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12816 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12817 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12818 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12819 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12820 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12821 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12822 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12823 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12824 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12825 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12826 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12827 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12828 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12829 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12830 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12831 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12832 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12833 }
12834
12835 if (truecrypt_keyfiles)
12836 {
12837 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12838
12839 char *keyfiles = strdup (truecrypt_keyfiles);
12840
12841 char *keyfile = strtok (keyfiles, ",");
12842
12843 do
12844 {
12845 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12846
12847 } while ((keyfile = strtok (NULL, ",")) != NULL);
12848
12849 free (keyfiles);
12850 }
12851
12852 if (veracrypt_keyfiles)
12853 {
12854 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12855
12856 char *keyfiles = strdup (veracrypt_keyfiles);
12857
12858 char *keyfile = strtok (keyfiles, ",");
12859
12860 do
12861 {
12862 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12863
12864 } while ((keyfile = strtok (NULL, ",")) != NULL);
12865
12866 free (keyfiles);
12867 }
12868
12869 data.digests_cnt = digests_cnt;
12870 data.digests_done = digests_done;
12871 data.digests_buf = digests_buf;
12872 data.digests_shown = digests_shown;
12873 data.digests_shown_tmp = digests_shown_tmp;
12874
12875 data.salts_cnt = salts_cnt;
12876 data.salts_done = salts_done;
12877 data.salts_buf = salts_buf;
12878 data.salts_shown = salts_shown;
12879
12880 data.esalts_buf = esalts_buf;
12881 data.hash_info = hash_info;
12882
12883 /**
12884 * Automatic Optimizers
12885 */
12886
12887 if (salts_cnt == 1)
12888 opti_type |= OPTI_TYPE_SINGLE_SALT;
12889
12890 if (digests_cnt == 1)
12891 opti_type |= OPTI_TYPE_SINGLE_HASH;
12892
12893 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12894 opti_type |= OPTI_TYPE_NOT_ITERATED;
12895
12896 if (attack_mode == ATTACK_MODE_BF)
12897 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12898
12899 data.opti_type = opti_type;
12900
12901 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12902 {
12903 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12904 {
12905 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12906 {
12907 if (opts_type & OPTS_TYPE_ST_ADD80)
12908 {
12909 opts_type &= ~OPTS_TYPE_ST_ADD80;
12910 opts_type |= OPTS_TYPE_PT_ADD80;
12911 }
12912
12913 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12914 {
12915 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12916 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12917 }
12918
12919 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12920 {
12921 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12922 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12923 }
12924 }
12925 }
12926 }
12927
12928 /**
12929 * Some algorithm, like descrypt, can benefit from JIT compilation
12930 */
12931
12932 int force_jit_compilation = -1;
12933
12934 if (hash_mode == 8900)
12935 {
12936 force_jit_compilation = 8900;
12937 }
12938 else if (hash_mode == 9300)
12939 {
12940 force_jit_compilation = 8900;
12941 }
12942 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12943 {
12944 force_jit_compilation = 1500;
12945 }
12946
12947 /**
12948 * generate bitmap tables
12949 */
12950
12951 const uint bitmap_shift1 = 5;
12952 const uint bitmap_shift2 = 13;
12953
12954 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12955
12956 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12957 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12958 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12959 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12960 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12961 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12962 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12963 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12964
12965 uint bitmap_bits;
12966 uint bitmap_nums;
12967 uint bitmap_mask;
12968 uint bitmap_size;
12969
12970 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12971 {
12972 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12973
12974 bitmap_nums = 1 << bitmap_bits;
12975
12976 bitmap_mask = bitmap_nums - 1;
12977
12978 bitmap_size = bitmap_nums * sizeof (uint);
12979
12980 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12981
12982 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;
12983 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;
12984
12985 break;
12986 }
12987
12988 bitmap_nums = 1 << bitmap_bits;
12989
12990 bitmap_mask = bitmap_nums - 1;
12991
12992 bitmap_size = bitmap_nums * sizeof (uint);
12993
12994 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);
12995 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);
12996
12997 /**
12998 * prepare quick rule
12999 */
13000
13001 data.rule_buf_l = rule_buf_l;
13002 data.rule_buf_r = rule_buf_r;
13003
13004 int rule_len_l = (int) strlen (rule_buf_l);
13005 int rule_len_r = (int) strlen (rule_buf_r);
13006
13007 data.rule_len_l = rule_len_l;
13008 data.rule_len_r = rule_len_r;
13009
13010 /**
13011 * load rules
13012 */
13013
13014 uint *all_kernel_rules_cnt = NULL;
13015
13016 kernel_rule_t **all_kernel_rules_buf = NULL;
13017
13018 if (rp_files_cnt)
13019 {
13020 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13021
13022 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13023 }
13024
13025 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13026
13027 int rule_len = 0;
13028
13029 for (uint i = 0; i < rp_files_cnt; i++)
13030 {
13031 uint kernel_rules_avail = 0;
13032
13033 uint kernel_rules_cnt = 0;
13034
13035 kernel_rule_t *kernel_rules_buf = NULL;
13036
13037 char *rp_file = rp_files[i];
13038
13039 char in[BLOCK_SIZE] = { 0 };
13040 char out[BLOCK_SIZE] = { 0 };
13041
13042 FILE *fp = NULL;
13043
13044 uint rule_line = 0;
13045
13046 if ((fp = fopen (rp_file, "rb")) == NULL)
13047 {
13048 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13049
13050 return (-1);
13051 }
13052
13053 while (!feof (fp))
13054 {
13055 memset (rule_buf, 0, HCBUFSIZ);
13056
13057 rule_len = fgetl (fp, rule_buf);
13058
13059 rule_line++;
13060
13061 if (rule_len == 0) continue;
13062
13063 if (rule_buf[0] == '#') continue;
13064
13065 if (kernel_rules_avail == kernel_rules_cnt)
13066 {
13067 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13068
13069 kernel_rules_avail += INCR_RULES;
13070 }
13071
13072 memset (in, 0, BLOCK_SIZE);
13073 memset (out, 0, BLOCK_SIZE);
13074
13075 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13076
13077 if (result == -1)
13078 {
13079 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13080
13081 continue;
13082 }
13083
13084 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13085 {
13086 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13087
13088 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13089
13090 continue;
13091 }
13092
13093 /* its so slow
13094 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13095 {
13096 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13097
13098 continue;
13099 }
13100 */
13101
13102 kernel_rules_cnt++;
13103 }
13104
13105 fclose (fp);
13106
13107 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13108
13109 all_kernel_rules_buf[i] = kernel_rules_buf;
13110 }
13111
13112 /**
13113 * merge rules or automatic rule generator
13114 */
13115
13116 uint kernel_rules_cnt = 0;
13117
13118 kernel_rule_t *kernel_rules_buf = NULL;
13119
13120 if (attack_mode == ATTACK_MODE_STRAIGHT)
13121 {
13122 if (rp_files_cnt)
13123 {
13124 kernel_rules_cnt = 1;
13125
13126 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13127
13128 repeats[0] = kernel_rules_cnt;
13129
13130 for (uint i = 0; i < rp_files_cnt; i++)
13131 {
13132 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13133
13134 repeats[i + 1] = kernel_rules_cnt;
13135 }
13136
13137 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13138
13139 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13140
13141 for (uint i = 0; i < kernel_rules_cnt; i++)
13142 {
13143 uint out_pos = 0;
13144
13145 kernel_rule_t *out = &kernel_rules_buf[i];
13146
13147 for (uint j = 0; j < rp_files_cnt; j++)
13148 {
13149 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13150 uint in_pos;
13151
13152 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13153
13154 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13155 {
13156 if (out_pos == RULES_MAX - 1)
13157 {
13158 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13159
13160 break;
13161 }
13162
13163 out->cmds[out_pos] = in->cmds[in_pos];
13164 }
13165 }
13166 }
13167
13168 local_free (repeats);
13169 }
13170 else if (rp_gen)
13171 {
13172 uint kernel_rules_avail = 0;
13173
13174 while (kernel_rules_cnt < rp_gen)
13175 {
13176 if (kernel_rules_avail == kernel_rules_cnt)
13177 {
13178 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13179
13180 kernel_rules_avail += INCR_RULES;
13181 }
13182
13183 memset (rule_buf, 0, HCBUFSIZ);
13184
13185 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13186
13187 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13188
13189 kernel_rules_cnt++;
13190 }
13191 }
13192 }
13193
13194 myfree (rule_buf);
13195
13196 /**
13197 * generate NOP rules
13198 */
13199
13200 if (kernel_rules_cnt == 0)
13201 {
13202 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13203
13204 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13205
13206 kernel_rules_cnt++;
13207 }
13208
13209 data.kernel_rules_cnt = kernel_rules_cnt;
13210 data.kernel_rules_buf = kernel_rules_buf;
13211
13212 /**
13213 * OpenCL platforms: detect
13214 */
13215
13216 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13217 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13218
13219 cl_uint platforms_cnt = 0;
13220 cl_uint platform_devices_cnt = 0;
13221
13222 if (keyspace == 0)
13223 {
13224 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13225
13226 if (platforms_cnt == 0)
13227 {
13228 log_info ("");
13229 log_info ("ATTENTION! No OpenCL compatible platform found");
13230 log_info ("");
13231 log_info ("You're probably missing the OpenCL runtime installation");
13232 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13233 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13234 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13235 log_info ("");
13236
13237 return (-1);
13238 }
13239
13240 if (opencl_platforms_filter != (uint) -1)
13241 {
13242 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13243
13244 if (opencl_platforms_filter > platform_cnt_mask)
13245 {
13246 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13247
13248 return (-1);
13249 }
13250 }
13251 }
13252
13253 /**
13254 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13255 */
13256
13257 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13258 {
13259 cl_platform_id platform = platforms[platform_id];
13260
13261 char platform_vendor[INFOSZ] = { 0 };
13262
13263 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13264
13265 #ifdef HAVE_HWMON
13266 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13267 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13268 {
13269 // make sure that we do not directly control the fan for NVidia
13270
13271 gpu_temp_retain = 0;
13272
13273 data.gpu_temp_retain = gpu_temp_retain;
13274 }
13275 #endif // HAVE_NVML || HAVE_NVAPI
13276 #endif
13277 }
13278
13279 /**
13280 * OpenCL device types:
13281 * 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.
13282 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13283 */
13284
13285 if (opencl_device_types == NULL)
13286 {
13287 cl_device_type device_types_all = 0;
13288
13289 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13290 {
13291 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13292
13293 cl_platform_id platform = platforms[platform_id];
13294
13295 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13296
13297 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13298 {
13299 cl_device_id device = platform_devices[platform_devices_id];
13300
13301 cl_device_type device_type;
13302
13303 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13304
13305 device_types_all |= device_type;
13306 }
13307 }
13308
13309 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13310 {
13311 device_types_filter |= CL_DEVICE_TYPE_CPU;
13312 }
13313 }
13314
13315 /**
13316 * OpenCL devices: simply push all devices from all platforms into the same device array
13317 */
13318
13319 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13320
13321 data.devices_param = devices_param;
13322
13323 uint devices_cnt = 0;
13324
13325 uint devices_active = 0;
13326
13327 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13328 {
13329 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13330
13331 cl_platform_id platform = platforms[platform_id];
13332
13333 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13334
13335 char platform_vendor[INFOSZ] = { 0 };
13336
13337 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13338
13339 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13340 // this causes trouble with vendor id based macros
13341 // we'll assign generic to those without special optimization available
13342
13343 cl_uint platform_vendor_id = 0;
13344
13345 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13346 {
13347 platform_vendor_id = VENDOR_ID_AMD;
13348 }
13349 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13350 {
13351 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13352 }
13353 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13354 {
13355 platform_vendor_id = VENDOR_ID_APPLE;
13356 }
13357 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13358 {
13359 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13360 }
13361 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13362 {
13363 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13364 }
13365 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13366 {
13367 platform_vendor_id = VENDOR_ID_MESA;
13368 }
13369 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13370 {
13371 platform_vendor_id = VENDOR_ID_NV;
13372 }
13373 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13374 {
13375 platform_vendor_id = VENDOR_ID_POCL;
13376 }
13377 else
13378 {
13379 platform_vendor_id = VENDOR_ID_GENERIC;
13380 }
13381
13382 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13383 {
13384 size_t param_value_size = 0;
13385
13386 const uint device_id = devices_cnt;
13387
13388 hc_device_param_t *device_param = &data.devices_param[device_id];
13389
13390 device_param->platform_vendor_id = platform_vendor_id;
13391
13392 device_param->device = platform_devices[platform_devices_id];
13393
13394 device_param->device_id = device_id;
13395
13396 device_param->platform_devices_id = platform_devices_id;
13397
13398 // device_type
13399
13400 cl_device_type device_type;
13401
13402 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13403
13404 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13405
13406 device_param->device_type = device_type;
13407
13408 // device_name
13409
13410 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13411
13412 char *device_name = (char *) mymalloc (param_value_size);
13413
13414 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13415
13416 device_param->device_name = device_name;
13417
13418 // device_vendor
13419
13420 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13421
13422 char *device_vendor = (char *) mymalloc (param_value_size);
13423
13424 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13425
13426 device_param->device_vendor = device_vendor;
13427
13428 cl_uint device_vendor_id = 0;
13429
13430 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13431 {
13432 device_vendor_id = VENDOR_ID_AMD;
13433 }
13434 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13435 {
13436 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13437 }
13438 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13439 {
13440 device_vendor_id = VENDOR_ID_APPLE;
13441 }
13442 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13443 {
13444 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13445 }
13446 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13447 {
13448 device_vendor_id = VENDOR_ID_INTEL_SDK;
13449 }
13450 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13451 {
13452 device_vendor_id = VENDOR_ID_MESA;
13453 }
13454 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13455 {
13456 device_vendor_id = VENDOR_ID_NV;
13457 }
13458 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13459 {
13460 device_vendor_id = VENDOR_ID_POCL;
13461 }
13462 else
13463 {
13464 device_vendor_id = VENDOR_ID_GENERIC;
13465 }
13466
13467 device_param->device_vendor_id = device_vendor_id;
13468
13469 // tuning db
13470
13471 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13472
13473 // device_version
13474
13475 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13476
13477 char *device_version = (char *) mymalloc (param_value_size);
13478
13479 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13480
13481 device_param->device_version = device_version;
13482
13483 // device_opencl_version
13484
13485 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13486
13487 char *device_opencl_version = (char *) mymalloc (param_value_size);
13488
13489 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13490
13491 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13492
13493 myfree (device_opencl_version);
13494
13495 // vector_width
13496
13497 cl_uint vector_width;
13498
13499 if (opencl_vector_width_chgd == 0)
13500 {
13501 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13502 {
13503 if (opti_type & OPTI_TYPE_USES_BITS_64)
13504 {
13505 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13506 }
13507 else
13508 {
13509 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13510 }
13511 }
13512 else
13513 {
13514 vector_width = (cl_uint) tuningdb_entry->vector_width;
13515 }
13516 }
13517 else
13518 {
13519 vector_width = opencl_vector_width;
13520 }
13521
13522 if (vector_width > 16) vector_width = 16;
13523
13524 device_param->vector_width = vector_width;
13525
13526 // max_compute_units
13527
13528 cl_uint device_processors;
13529
13530 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13531
13532 device_param->device_processors = device_processors;
13533
13534 // device_maxmem_alloc
13535 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13536
13537 cl_ulong device_maxmem_alloc;
13538
13539 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13540
13541 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13542
13543 // device_global_mem
13544
13545 cl_ulong device_global_mem;
13546
13547 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13548
13549 device_param->device_global_mem = device_global_mem;
13550
13551 // max_work_group_size
13552
13553 size_t device_maxworkgroup_size;
13554
13555 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13556
13557 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13558
13559 // max_clock_frequency
13560
13561 cl_uint device_maxclock_frequency;
13562
13563 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13564
13565 device_param->device_maxclock_frequency = device_maxclock_frequency;
13566
13567 // device_endian_little
13568
13569 cl_bool device_endian_little;
13570
13571 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13572
13573 if (device_endian_little == CL_FALSE)
13574 {
13575 if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13576
13577 device_param->skipped = 1;
13578 }
13579
13580 // device_available
13581
13582 cl_bool device_available;
13583
13584 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13585
13586 if (device_available == CL_FALSE)
13587 {
13588 if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
13589
13590 device_param->skipped = 1;
13591 }
13592
13593 // device_compiler_available
13594
13595 cl_bool device_compiler_available;
13596
13597 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13598
13599 if (device_compiler_available == CL_FALSE)
13600 {
13601 if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13602
13603 device_param->skipped = 1;
13604 }
13605
13606 // device_execution_capabilities
13607
13608 cl_device_exec_capabilities device_execution_capabilities;
13609
13610 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13611
13612 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13613 {
13614 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13615
13616 device_param->skipped = 1;
13617 }
13618
13619 // device_extensions
13620
13621 size_t device_extensions_size;
13622
13623 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13624
13625 char *device_extensions = mymalloc (device_extensions_size + 1);
13626
13627 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13628
13629 if (strstr (device_extensions, "base_atomics") == 0)
13630 {
13631 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13632
13633 device_param->skipped = 1;
13634 }
13635
13636 if (strstr (device_extensions, "byte_addressable_store") == 0)
13637 {
13638 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13639
13640 device_param->skipped = 1;
13641 }
13642
13643 myfree (device_extensions);
13644
13645 // device_local_mem_size
13646
13647 cl_ulong device_local_mem_size;
13648
13649 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13650
13651 if (device_local_mem_size < 32768)
13652 {
13653 if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13654
13655 device_param->skipped = 1;
13656 }
13657
13658 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13659 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13660 // This results in both utilizing it for 50%
13661 // However, Intel has much better SIMD control over their own hardware
13662 // It makes sense to give them full control over their own hardware
13663
13664 if (device_type & CL_DEVICE_TYPE_CPU)
13665 {
13666 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13667 {
13668 if (data.quiet == 0) log_info ("Device #%u: WARNING: not native intel opencl platform", device_id + 1);
13669
13670 device_param->skipped = 1;
13671 }
13672 }
13673
13674 // skipped
13675
13676 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13677 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13678
13679 // driver_version
13680
13681 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13682
13683 char *driver_version = (char *) mymalloc (param_value_size);
13684
13685 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13686
13687 device_param->driver_version = driver_version;
13688
13689 // device_name_chksum
13690
13691 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13692
13693 #if __x86_64__
13694 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);
13695 #else
13696 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);
13697 #endif
13698
13699 uint device_name_digest[4] = { 0 };
13700
13701 md5_64 ((uint *) device_name_chksum, device_name_digest);
13702
13703 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13704
13705 device_param->device_name_chksum = device_name_chksum;
13706
13707 // device_processor_cores
13708
13709 if (device_type & CL_DEVICE_TYPE_CPU)
13710 {
13711 cl_uint device_processor_cores = 1;
13712
13713 device_param->device_processor_cores = device_processor_cores;
13714 }
13715
13716 if (device_type & CL_DEVICE_TYPE_GPU)
13717 {
13718 if (device_vendor_id == VENDOR_ID_AMD)
13719 {
13720 cl_uint device_processor_cores = 0;
13721
13722 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13723
13724 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13725
13726 device_param->device_processor_cores = device_processor_cores;
13727 }
13728 else if (device_vendor_id == VENDOR_ID_NV)
13729 {
13730 cl_uint kernel_exec_timeout = 0;
13731
13732 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13733
13734 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13735
13736 device_param->kernel_exec_timeout = kernel_exec_timeout;
13737
13738 cl_uint device_processor_cores = 0;
13739
13740 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13741
13742 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13743
13744 device_param->device_processor_cores = device_processor_cores;
13745
13746 cl_uint sm_minor = 0;
13747 cl_uint sm_major = 0;
13748
13749 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13750 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13751
13752 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13753 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13754
13755 device_param->sm_minor = sm_minor;
13756 device_param->sm_major = sm_major;
13757 }
13758 else
13759 {
13760 cl_uint device_processor_cores = 1;
13761
13762 device_param->device_processor_cores = device_processor_cores;
13763 }
13764 }
13765
13766 // display results
13767
13768 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13769 {
13770 if (machine_readable == 0)
13771 {
13772 if (device_param->skipped == 0)
13773 {
13774 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13775 device_id + 1,
13776 device_name,
13777 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13778 (unsigned int) (device_global_mem / 1024 / 1024),
13779 (unsigned int) device_processors);
13780 }
13781 else
13782 {
13783 log_info ("Device #%u: %s, skipped",
13784 device_id + 1,
13785 device_name);
13786 }
13787 }
13788 }
13789
13790 // common driver check
13791
13792 if (device_param->skipped == 0)
13793 {
13794 if (device_type & CL_DEVICE_TYPE_GPU)
13795 {
13796 if (platform_vendor_id == VENDOR_ID_AMD)
13797 {
13798 int catalyst_check = (force == 1) ? 0 : 1;
13799
13800 int catalyst_warn = 0;
13801
13802 int catalyst_broken = 0;
13803
13804 if (catalyst_check == 1)
13805 {
13806 catalyst_warn = 1;
13807
13808 // v14.9 and higher
13809 if (atoi (device_param->driver_version) >= 1573)
13810 {
13811 catalyst_warn = 0;
13812 }
13813
13814 catalyst_check = 0;
13815 }
13816
13817 if (catalyst_broken == 1)
13818 {
13819 log_info ("");
13820 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13821 log_info ("It will pass over cracked hashes and does not report them as cracked");
13822 log_info ("You are STRONGLY encouraged not to use it");
13823 log_info ("You can use --force to override this but do not post error reports if you do so");
13824 log_info ("");
13825
13826 return (-1);
13827 }
13828
13829 if (catalyst_warn == 1)
13830 {
13831 log_info ("");
13832 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13833 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13834 log_info ("See hashcat's homepage for official supported catalyst drivers");
13835 #ifdef _WIN
13836 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13837 #endif
13838 log_info ("You can use --force to override this but do not post error reports if you do so");
13839 log_info ("");
13840
13841 return (-1);
13842 }
13843 }
13844 else if (platform_vendor_id == VENDOR_ID_NV)
13845 {
13846 if (device_param->kernel_exec_timeout != 0)
13847 {
13848 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);
13849 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13850 }
13851 }
13852 }
13853
13854 /* turns out pocl still creates segfaults (because of llvm)
13855 if (device_type & CL_DEVICE_TYPE_CPU)
13856 {
13857 if (platform_vendor_id == VENDOR_ID_AMD)
13858 {
13859 if (force == 0)
13860 {
13861 log_info ("");
13862 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13863 log_info ("You are STRONGLY encouraged not to use it");
13864 log_info ("You can use --force to override this but do not post error reports if you do so");
13865 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13866 log_info ("");
13867
13868 return (-1);
13869 }
13870 }
13871 }
13872 */
13873
13874 /**
13875 * kernel accel and loops tuning db adjustment
13876 */
13877
13878 device_param->kernel_accel_min = 1;
13879 device_param->kernel_accel_max = 1024;
13880
13881 device_param->kernel_loops_min = 1;
13882 device_param->kernel_loops_max = 1024;
13883
13884 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13885
13886 if (tuningdb_entry)
13887 {
13888 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13889 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13890
13891 if (_kernel_accel)
13892 {
13893 device_param->kernel_accel_min = _kernel_accel;
13894 device_param->kernel_accel_max = _kernel_accel;
13895 }
13896
13897 if (_kernel_loops)
13898 {
13899 if (workload_profile == 1)
13900 {
13901 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13902 }
13903 else if (workload_profile == 2)
13904 {
13905 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13906 }
13907
13908 device_param->kernel_loops_min = _kernel_loops;
13909 device_param->kernel_loops_max = _kernel_loops;
13910 }
13911 }
13912
13913 // commandline parameters overwrite tuningdb entries
13914
13915 if (kernel_accel)
13916 {
13917 device_param->kernel_accel_min = kernel_accel;
13918 device_param->kernel_accel_max = kernel_accel;
13919 }
13920
13921 if (kernel_loops)
13922 {
13923 device_param->kernel_loops_min = kernel_loops;
13924 device_param->kernel_loops_max = kernel_loops;
13925 }
13926
13927 /**
13928 * activate device
13929 */
13930
13931 devices_active++;
13932 }
13933
13934 // next please
13935
13936 devices_cnt++;
13937 }
13938 }
13939
13940 if (keyspace == 0 && devices_active == 0)
13941 {
13942 log_error ("ERROR: No devices found/left");
13943
13944 return (-1);
13945 }
13946
13947 // 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)
13948
13949 if (devices_filter != (uint) -1)
13950 {
13951 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13952
13953 if (devices_filter > devices_cnt_mask)
13954 {
13955 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13956
13957 return (-1);
13958 }
13959 }
13960
13961 data.devices_cnt = devices_cnt;
13962
13963 data.devices_active = devices_active;
13964
13965 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13966 {
13967 if (machine_readable == 0)
13968 {
13969 log_info ("");
13970 }
13971 }
13972
13973 /**
13974 * HM devices: init
13975 */
13976
13977 #ifdef HAVE_HWMON
13978 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13979 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0 } };
13980 #endif
13981
13982 #ifdef HAVE_ADL
13983 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0 } };
13984 #endif
13985
13986 if (gpu_temp_disable == 0)
13987 {
13988 #if defined(WIN) && defined(HAVE_NVAPI)
13989 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13990
13991 if (nvapi_init (nvapi) == 0)
13992 data.hm_nv = nvapi;
13993
13994 if (data.hm_nv)
13995 {
13996 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13997 {
13998 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13999
14000 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14001
14002 int tmp_out = 0;
14003
14004 for (int i = 0; i < tmp_in; i++)
14005 {
14006 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14007 }
14008
14009 for (int i = 0; i < tmp_out; i++)
14010 {
14011 NV_GPU_COOLER_SETTINGS pCoolerSettings;
14012
14013 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
14014
14015 if (hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, hm_adapters_nv[i].adapter_index.nv, 0, &pCoolerSettings) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
14016 }
14017 }
14018 }
14019 #endif // WIN && HAVE_NVAPI
14020
14021 #if defined(LINUX) && defined(HAVE_NVML)
14022 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14023
14024 if (nvml_init (nvml) == 0)
14025 data.hm_nv = nvml;
14026
14027 if (data.hm_nv)
14028 {
14029 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
14030 {
14031 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
14032
14033 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14034
14035 int tmp_out = 0;
14036
14037 for (int i = 0; i < tmp_in; i++)
14038 {
14039 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14040 }
14041
14042 for (int i = 0; i < tmp_out; i++)
14043 {
14044 unsigned int speed;
14045
14046 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
14047 }
14048 }
14049 }
14050 #endif // LINUX && HAVE_NVML
14051
14052 data.hm_amd = NULL;
14053
14054 #ifdef HAVE_ADL
14055 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14056
14057 if (adl_init (adl) == 0)
14058 data.hm_amd = adl;
14059
14060 if (data.hm_amd)
14061 {
14062 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14063 {
14064 // total number of adapters
14065
14066 int hm_adapters_num;
14067
14068 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
14069
14070 // adapter info
14071
14072 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
14073
14074 if (lpAdapterInfo == NULL) return (-1);
14075
14076 // get a list (of ids of) valid/usable adapters
14077
14078 int num_adl_adapters = 0;
14079
14080 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14081
14082 if (num_adl_adapters > 0)
14083 {
14084 hc_thread_mutex_lock (mux_adl);
14085
14086 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
14087
14088 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14089
14090 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14091 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14092
14093 hc_thread_mutex_unlock (mux_adl);
14094 }
14095
14096 myfree (valid_adl_device_list);
14097 myfree (lpAdapterInfo);
14098 }
14099 }
14100 #endif // HAVE_ADL
14101
14102 if (data.hm_amd == NULL && data.hm_nv == NULL)
14103 {
14104 gpu_temp_disable = 1;
14105 }
14106 }
14107
14108 /**
14109 * OpenCL devices: allocate buffer for device specific information
14110 */
14111
14112 #ifdef HAVE_HWMON
14113 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14114
14115 #ifdef HAVE_ADL
14116 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14117
14118 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14119 #endif // ADL
14120 #endif
14121
14122 /**
14123 * enable custom signal handler(s)
14124 */
14125
14126 if (benchmark == 0)
14127 {
14128 hc_signal (sigHandler_default);
14129 }
14130 else
14131 {
14132 hc_signal (sigHandler_benchmark);
14133 }
14134
14135 /**
14136 * User-defined GPU temp handling
14137 */
14138
14139 #ifdef HAVE_HWMON
14140 if (gpu_temp_disable == 1)
14141 {
14142 gpu_temp_abort = 0;
14143 gpu_temp_retain = 0;
14144 }
14145
14146 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14147 {
14148 if (gpu_temp_abort < gpu_temp_retain)
14149 {
14150 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14151
14152 return (-1);
14153 }
14154 }
14155
14156 data.gpu_temp_disable = gpu_temp_disable;
14157 data.gpu_temp_abort = gpu_temp_abort;
14158 data.gpu_temp_retain = gpu_temp_retain;
14159 #endif
14160
14161 /**
14162 * inform the user
14163 */
14164
14165 if (data.quiet == 0)
14166 {
14167 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14168
14169 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);
14170
14171 if (attack_mode == ATTACK_MODE_STRAIGHT)
14172 {
14173 log_info ("Rules: %u", kernel_rules_cnt);
14174 }
14175
14176 if (opti_type)
14177 {
14178 log_info ("Applicable Optimizers:");
14179
14180 for (uint i = 0; i < 32; i++)
14181 {
14182 const uint opti_bit = 1u << i;
14183
14184 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14185 }
14186 }
14187
14188 /**
14189 * Watchdog and Temperature balance
14190 */
14191
14192 #ifdef HAVE_HWMON
14193 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
14194 {
14195 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14196 }
14197
14198 if (gpu_temp_abort == 0)
14199 {
14200 log_info ("Watchdog: Temperature abort trigger disabled");
14201 }
14202 else
14203 {
14204 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14205 }
14206
14207 if (gpu_temp_retain == 0)
14208 {
14209 log_info ("Watchdog: Temperature retain trigger disabled");
14210 }
14211 else
14212 {
14213 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14214 }
14215
14216 if (data.quiet == 0) log_info ("");
14217 #endif
14218 }
14219
14220 /**
14221 * HM devices: copy
14222 */
14223
14224 if (gpu_temp_disable == 0)
14225 {
14226 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14227 {
14228 hc_device_param_t *device_param = &data.devices_param[device_id];
14229
14230 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14231
14232 if (device_param->skipped) continue;
14233
14234 const uint platform_devices_id = device_param->platform_devices_id;
14235
14236 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14237 if (device_param->device_vendor_id == VENDOR_ID_NV)
14238 {
14239 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14240 }
14241 #endif
14242
14243 #ifdef HAVE_ADL
14244 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14245 {
14246 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14247 }
14248 #endif
14249 }
14250 }
14251
14252 /**
14253 * Temporary fix:
14254 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14255 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14256 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14257 * Driver / ADL bug?
14258 */
14259
14260 #ifdef HAVE_ADL
14261 if (powertune_enable == 1)
14262 {
14263 hc_thread_mutex_lock (mux_adl);
14264
14265 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14266 {
14267 hc_device_param_t *device_param = &data.devices_param[device_id];
14268
14269 if (device_param->skipped) continue;
14270
14271 if (data.hm_device[device_id].od_version == 6)
14272 {
14273 // set powertune value only
14274
14275 int powertune_supported = 0;
14276
14277 int ADL_rc = 0;
14278
14279 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14280 {
14281 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14282
14283 return (-1);
14284 }
14285
14286 if (powertune_supported != 0)
14287 {
14288 // powertune set
14289 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14290
14291 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14292 {
14293 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14294
14295 return (-1);
14296 }
14297
14298 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14299 {
14300 log_error ("ERROR: Failed to set new ADL PowerControl values");
14301
14302 return (-1);
14303 }
14304 }
14305 }
14306 }
14307
14308 hc_thread_mutex_unlock (mux_adl);
14309 }
14310 #endif // HAVE_ADK
14311 #endif // HAVE_HWMON
14312
14313 #ifdef DEBUG
14314 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14315 #endif
14316
14317 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14318
14319 uint kernel_power_all = 0;
14320
14321 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14322 {
14323 /**
14324 * host buffer
14325 */
14326
14327 hc_device_param_t *device_param = &data.devices_param[device_id];
14328
14329 if (device_param->skipped) continue;
14330
14331 /**
14332 * device properties
14333 */
14334
14335 const char *device_name_chksum = device_param->device_name_chksum;
14336 const u32 device_processors = device_param->device_processors;
14337 const u32 device_processor_cores = device_param->device_processor_cores;
14338
14339 /**
14340 * create context for each device
14341 */
14342
14343 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14344
14345 /**
14346 * create command-queue
14347 */
14348
14349 // not supported with NV
14350 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14351
14352 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14353
14354 /**
14355 * kernel threads: some algorithms need a fixed kernel-threads count
14356 * because of shared memory usage or bitslice
14357 * there needs to be some upper limit, otherwise there's too much overhead
14358 */
14359
14360 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14361
14362 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14363 {
14364 kernel_threads = KERNEL_THREADS_MAX_CPU;
14365 }
14366
14367 if (hash_mode == 1500) kernel_threads = 64; // DES
14368 if (hash_mode == 3000) kernel_threads = 64; // DES
14369 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14370 if (hash_mode == 7500) kernel_threads = 64; // RC4
14371 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14372 if (hash_mode == 9700) kernel_threads = 64; // RC4
14373 if (hash_mode == 9710) kernel_threads = 64; // RC4
14374 if (hash_mode == 9800) kernel_threads = 64; // RC4
14375 if (hash_mode == 9810) kernel_threads = 64; // RC4
14376 if (hash_mode == 10400) kernel_threads = 64; // RC4
14377 if (hash_mode == 10410) kernel_threads = 64; // RC4
14378 if (hash_mode == 10500) kernel_threads = 64; // RC4
14379 if (hash_mode == 13100) kernel_threads = 64; // RC4
14380
14381 /**
14382 * create input buffers on device : calculate size of fixed memory buffers
14383 */
14384
14385 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14386 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14387
14388 device_param->size_root_css = size_root_css;
14389 device_param->size_markov_css = size_markov_css;
14390
14391 size_t size_results = sizeof (uint);
14392
14393 device_param->size_results = size_results;
14394
14395 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14396 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14397
14398 size_t size_plains = digests_cnt * sizeof (plain_t);
14399 size_t size_salts = salts_cnt * sizeof (salt_t);
14400 size_t size_esalts = salts_cnt * esalt_size;
14401
14402 device_param->size_plains = size_plains;
14403 device_param->size_digests = size_digests;
14404 device_param->size_shown = size_shown;
14405 device_param->size_salts = size_salts;
14406
14407 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14408 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14409 size_t size_tm = 32 * sizeof (bs_word_t);
14410
14411 // scryptV stuff
14412
14413 size_t size_scryptV = 1;
14414
14415 if ((hash_mode == 8900) || (hash_mode == 9300))
14416 {
14417 uint tmto_start = 0;
14418 uint tmto_stop = 10;
14419
14420 if (scrypt_tmto)
14421 {
14422 tmto_start = scrypt_tmto;
14423 }
14424 else
14425 {
14426 // in case the user did not specify the tmto manually
14427 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14428 // but set the lower end only in case the user has a device with too less memory
14429
14430 if (hash_mode == 8900)
14431 {
14432 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14433 {
14434 tmto_start = 1;
14435 }
14436 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14437 {
14438 tmto_start = 2;
14439 }
14440 }
14441 else if (hash_mode == 9300)
14442 {
14443 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14444 {
14445 tmto_start = 2;
14446 }
14447 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14448 {
14449 tmto_start = 2;
14450 }
14451 }
14452 }
14453
14454 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14455 {
14456 // TODO: in theory the following calculation needs to be done per salt, not global
14457 // we assume all hashes have the same scrypt settings
14458
14459 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14460
14461 size_scryptV /= 1 << tmto;
14462
14463 size_scryptV *= device_processors * device_processor_cores;
14464
14465 if (size_scryptV > device_param->device_maxmem_alloc)
14466 {
14467 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14468
14469 continue;
14470 }
14471
14472 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14473 {
14474 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14475 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14476 }
14477
14478 break;
14479 }
14480
14481 if (data.salts_buf[0].scrypt_phy == 0)
14482 {
14483 log_error ("ERROR: can't allocate enough device memory");
14484
14485 return -1;
14486 }
14487
14488 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14489 }
14490
14491 /**
14492 * some algorithms need a fixed kernel-loops count
14493 */
14494
14495 if (hash_mode == 1500)
14496 {
14497 const u32 kernel_loops_fixed = 1024;
14498
14499 device_param->kernel_loops_min = kernel_loops_fixed;
14500 device_param->kernel_loops_max = kernel_loops_fixed;
14501 }
14502
14503 if (hash_mode == 3000)
14504 {
14505 const u32 kernel_loops_fixed = 1024;
14506
14507 device_param->kernel_loops_min = kernel_loops_fixed;
14508 device_param->kernel_loops_max = kernel_loops_fixed;
14509 }
14510
14511 if (hash_mode == 8900)
14512 {
14513 const u32 kernel_loops_fixed = 1;
14514
14515 device_param->kernel_loops_min = kernel_loops_fixed;
14516 device_param->kernel_loops_max = kernel_loops_fixed;
14517 }
14518
14519 if (hash_mode == 9300)
14520 {
14521 const u32 kernel_loops_fixed = 1;
14522
14523 device_param->kernel_loops_min = kernel_loops_fixed;
14524 device_param->kernel_loops_max = kernel_loops_fixed;
14525 }
14526
14527 if (hash_mode == 12500)
14528 {
14529 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14530
14531 device_param->kernel_loops_min = kernel_loops_fixed;
14532 device_param->kernel_loops_max = kernel_loops_fixed;
14533 }
14534
14535 /**
14536 * some algorithms have a maximum kernel-loops count
14537 */
14538
14539 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14540 {
14541 u32 innerloop_cnt = 0;
14542
14543 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14544 {
14545 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14546 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14547 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14548 }
14549 else
14550 {
14551 innerloop_cnt = data.salts_buf[0].salt_iter;
14552 }
14553
14554 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14555 (innerloop_cnt <= device_param->kernel_loops_max))
14556 {
14557 device_param->kernel_loops_max = innerloop_cnt;
14558 }
14559 }
14560
14561 u32 kernel_accel_min = device_param->kernel_accel_min;
14562 u32 kernel_accel_max = device_param->kernel_accel_max;
14563
14564 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14565
14566 size_t size_pws = 4;
14567 size_t size_tmps = 4;
14568 size_t size_hooks = 4;
14569
14570 while (kernel_accel_max >= kernel_accel_min)
14571 {
14572 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14573
14574 // size_pws
14575
14576 size_pws = kernel_power_max * sizeof (pw_t);
14577
14578 // size_tmps
14579
14580 switch (hash_mode)
14581 {
14582 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14583 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14584 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14585 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14586 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14587 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14588 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14589 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14590 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14591 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14592 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14593 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14594 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14595 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14596 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14597 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14598 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14599 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14600 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14601 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14602 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14603 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14604 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14605 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14606 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14607 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14608 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14609 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14610 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14611 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14612 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14613 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14614 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14615 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14616 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14617 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14618 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14619 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14620 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14621 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14622 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14623 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14624 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14625 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14626 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14627 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14628 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14629 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14630 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14631 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14632 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14633 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14634 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14635 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14636 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14637 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14638 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14639 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14640 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14641 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14642 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14643 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14644 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14645 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14646 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14647 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14648 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14649 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14650 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14651 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14652 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14653 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14654 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14655 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14656 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14657 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14658 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14659 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14660 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14661 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14662 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14663 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14664 };
14665
14666 // size_hooks
14667
14668 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14669 {
14670 // none yet
14671 }
14672
14673 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14674 // if not, decrease amplifier and try again
14675
14676 int skip = 0;
14677
14678 const u64 size_total
14679 = bitmap_size
14680 + bitmap_size
14681 + bitmap_size
14682 + bitmap_size
14683 + bitmap_size
14684 + bitmap_size
14685 + bitmap_size
14686 + bitmap_size
14687 + size_bfs
14688 + size_combs
14689 + size_digests
14690 + size_esalts
14691 + size_hooks
14692 + size_markov_css
14693 + size_plains
14694 + size_pws
14695 + size_pws // not a bug
14696 + size_results
14697 + size_root_css
14698 + size_rules
14699 + size_rules_c
14700 + size_salts
14701 + size_scryptV
14702 + size_shown
14703 + size_tm
14704 + size_tmps;
14705
14706 // Don't ask me, ask AMD!
14707
14708 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14709 if (size_total > device_param->device_global_mem) skip = 1;
14710
14711 if (skip == 1)
14712 {
14713 kernel_accel_max--;
14714
14715 continue;
14716 }
14717
14718 break;
14719 }
14720
14721 /*
14722 if (kernel_accel_max == 0)
14723 {
14724 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14725
14726 return -1;
14727 }
14728 */
14729
14730 device_param->kernel_accel_min = kernel_accel_min;
14731 device_param->kernel_accel_max = kernel_accel_max;
14732
14733 /*
14734 if (kernel_accel_max < kernel_accel)
14735 {
14736 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14737
14738 device_param->kernel_accel = kernel_accel_max;
14739 }
14740 */
14741
14742 device_param->size_bfs = size_bfs;
14743 device_param->size_combs = size_combs;
14744 device_param->size_rules = size_rules;
14745 device_param->size_rules_c = size_rules_c;
14746 device_param->size_pws = size_pws;
14747 device_param->size_tmps = size_tmps;
14748 device_param->size_hooks = size_hooks;
14749
14750 // do not confuse kernel_accel_max with kernel_accel here
14751
14752 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14753
14754 device_param->kernel_threads = kernel_threads;
14755 device_param->kernel_power_user = kernel_power;
14756
14757 kernel_power_all += kernel_power;
14758
14759 /**
14760 * default building options
14761 */
14762
14763 char build_opts[1024] = { 0 };
14764
14765 // we don't have sm_* on vendors not NV but it doesn't matter
14766
14767 #if _WIN
14768 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);
14769 #else
14770 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);
14771 #endif
14772
14773 char build_opts_new[1024] = { 0 };
14774
14775 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);
14776
14777 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14778
14779 /*
14780 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14781 {
14782 // we do vectorizing much better than the auto-vectorizer
14783
14784 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14785
14786 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14787 }
14788 */
14789
14790 #ifdef DEBUG
14791 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14792 #endif
14793
14794 /**
14795 * main kernel
14796 */
14797
14798 {
14799 /**
14800 * kernel source filename
14801 */
14802
14803 char source_file[256] = { 0 };
14804
14805 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14806
14807 struct stat sst;
14808
14809 if (stat (source_file, &sst) == -1)
14810 {
14811 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14812
14813 return -1;
14814 }
14815
14816 /**
14817 * kernel cached filename
14818 */
14819
14820 char cached_file[256] = { 0 };
14821
14822 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14823
14824 int cached = 1;
14825
14826 struct stat cst;
14827
14828 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14829 {
14830 cached = 0;
14831 }
14832
14833 /**
14834 * kernel compile or load
14835 */
14836
14837 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14838
14839 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14840
14841 if (force_jit_compilation == -1)
14842 {
14843 if (cached == 0)
14844 {
14845 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14846
14847 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14848
14849 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14850
14851 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14852
14853 #ifdef DEBUG
14854 size_t build_log_size = 0;
14855
14856 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14857
14858 if (build_log_size > 1)
14859 {
14860 char *build_log = (char *) malloc (build_log_size + 1);
14861
14862 memset (build_log, 0, build_log_size + 1);
14863
14864 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14865
14866 puts (build_log);
14867
14868 free (build_log);
14869 }
14870 #endif
14871
14872 if (rc != 0)
14873 {
14874 device_param->skipped = true;
14875
14876 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14877
14878 continue;
14879 }
14880
14881 size_t binary_size;
14882
14883 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14884
14885 u8 *binary = (u8 *) mymalloc (binary_size);
14886
14887 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14888
14889 writeProgramBin (cached_file, binary, binary_size);
14890
14891 local_free (binary);
14892 }
14893 else
14894 {
14895 #ifdef DEBUG
14896 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14897 #endif
14898
14899 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14900
14901 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14902
14903 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14904 }
14905 }
14906 else
14907 {
14908 #ifdef DEBUG
14909 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14910 #endif
14911
14912 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14913
14914 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14915
14916 char build_opts_update[1024] = { 0 };
14917
14918 if (force_jit_compilation == 1500)
14919 {
14920 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14921 }
14922 else if (force_jit_compilation == 8900)
14923 {
14924 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);
14925 }
14926 else
14927 {
14928 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14929 }
14930
14931 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14932
14933 #ifdef DEBUG
14934 size_t build_log_size = 0;
14935
14936 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14937
14938 if (build_log_size > 1)
14939 {
14940 char *build_log = (char *) malloc (build_log_size + 1);
14941
14942 memset (build_log, 0, build_log_size + 1);
14943
14944 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14945
14946 puts (build_log);
14947
14948 free (build_log);
14949 }
14950 #endif
14951
14952 if (rc != 0)
14953 {
14954 device_param->skipped = true;
14955
14956 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14957 }
14958 }
14959
14960 local_free (kernel_lengths);
14961 local_free (kernel_sources[0]);
14962 local_free (kernel_sources);
14963 }
14964
14965 /**
14966 * word generator kernel
14967 */
14968
14969 if (attack_mode != ATTACK_MODE_STRAIGHT)
14970 {
14971 /**
14972 * kernel mp source filename
14973 */
14974
14975 char source_file[256] = { 0 };
14976
14977 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14978
14979 struct stat sst;
14980
14981 if (stat (source_file, &sst) == -1)
14982 {
14983 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14984
14985 return -1;
14986 }
14987
14988 /**
14989 * kernel mp cached filename
14990 */
14991
14992 char cached_file[256] = { 0 };
14993
14994 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14995
14996 int cached = 1;
14997
14998 struct stat cst;
14999
15000 if (stat (cached_file, &cst) == -1)
15001 {
15002 cached = 0;
15003 }
15004
15005 /**
15006 * kernel compile or load
15007 */
15008
15009 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15010
15011 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15012
15013 if (cached == 0)
15014 {
15015 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15016 if (quiet == 0) log_info ("");
15017
15018 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15019
15020 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15021
15022 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15023
15024 if (rc != 0)
15025 {
15026 device_param->skipped = true;
15027
15028 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15029
15030 continue;
15031 }
15032
15033 size_t binary_size;
15034
15035 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15036
15037 u8 *binary = (u8 *) mymalloc (binary_size);
15038
15039 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15040
15041 writeProgramBin (cached_file, binary, binary_size);
15042
15043 local_free (binary);
15044 }
15045 else
15046 {
15047 #ifdef DEBUG
15048 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15049 #endif
15050
15051 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15052
15053 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15054
15055 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15056 }
15057
15058 local_free (kernel_lengths);
15059 local_free (kernel_sources[0]);
15060 local_free (kernel_sources);
15061 }
15062
15063 /**
15064 * amplifier kernel
15065 */
15066
15067 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15068 {
15069
15070 }
15071 else
15072 {
15073 /**
15074 * kernel amp source filename
15075 */
15076
15077 char source_file[256] = { 0 };
15078
15079 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15080
15081 struct stat sst;
15082
15083 if (stat (source_file, &sst) == -1)
15084 {
15085 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15086
15087 return -1;
15088 }
15089
15090 /**
15091 * kernel amp cached filename
15092 */
15093
15094 char cached_file[256] = { 0 };
15095
15096 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15097
15098 int cached = 1;
15099
15100 struct stat cst;
15101
15102 if (stat (cached_file, &cst) == -1)
15103 {
15104 cached = 0;
15105 }
15106
15107 /**
15108 * kernel compile or load
15109 */
15110
15111 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15112
15113 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15114
15115 if (cached == 0)
15116 {
15117 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15118 if (quiet == 0) log_info ("");
15119
15120 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15121
15122 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15123
15124 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15125
15126 if (rc != 0)
15127 {
15128 device_param->skipped = true;
15129
15130 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15131
15132 continue;
15133 }
15134
15135 size_t binary_size;
15136
15137 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15138
15139 u8 *binary = (u8 *) mymalloc (binary_size);
15140
15141 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15142
15143 writeProgramBin (cached_file, binary, binary_size);
15144
15145 local_free (binary);
15146 }
15147 else
15148 {
15149 #ifdef DEBUG
15150 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15151 #endif
15152
15153 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15154
15155 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15156
15157 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15158 }
15159
15160 local_free (kernel_lengths);
15161 local_free (kernel_sources[0]);
15162 local_free (kernel_sources);
15163 }
15164
15165 // some algorithm collide too fast, make that impossible
15166
15167 if (benchmark == 1)
15168 {
15169 ((uint *) digests_buf)[0] = -1;
15170 ((uint *) digests_buf)[1] = -1;
15171 ((uint *) digests_buf)[2] = -1;
15172 ((uint *) digests_buf)[3] = -1;
15173 }
15174
15175 /**
15176 * global buffers
15177 */
15178
15179 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15180 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15181 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15182 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15183 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15184 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15185 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15186 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15187 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15188 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15189 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15190 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15191 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15192 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15193 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15194 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15195 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15196 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15197
15198 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);
15199 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);
15200 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);
15201 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);
15202 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);
15203 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);
15204 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);
15205 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);
15206 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15207 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15208 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15209
15210 /**
15211 * special buffers
15212 */
15213
15214 if (attack_kern == ATTACK_KERN_STRAIGHT)
15215 {
15216 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15217 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15218
15219 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15220 }
15221 else if (attack_kern == ATTACK_KERN_COMBI)
15222 {
15223 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15224 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15225 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15226 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15227 }
15228 else if (attack_kern == ATTACK_KERN_BF)
15229 {
15230 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15231 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15232 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15233 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15234 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15235 }
15236
15237 if (size_esalts)
15238 {
15239 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15240
15241 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15242 }
15243
15244 /**
15245 * main host data
15246 */
15247
15248 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15249
15250 device_param->pws_buf = pws_buf;
15251
15252 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15253
15254 device_param->combs_buf = combs_buf;
15255
15256 void *hooks_buf = mymalloc (size_hooks);
15257
15258 device_param->hooks_buf = hooks_buf;
15259
15260 /**
15261 * kernel args
15262 */
15263
15264 device_param->kernel_params_buf32[21] = bitmap_mask;
15265 device_param->kernel_params_buf32[22] = bitmap_shift1;
15266 device_param->kernel_params_buf32[23] = bitmap_shift2;
15267 device_param->kernel_params_buf32[24] = 0; // salt_pos
15268 device_param->kernel_params_buf32[25] = 0; // loop_pos
15269 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15270 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15271 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15272 device_param->kernel_params_buf32[29] = 0; // digests_offset
15273 device_param->kernel_params_buf32[30] = 0; // combs_mode
15274 device_param->kernel_params_buf32[31] = 0; // gid_max
15275
15276 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15277 ? &device_param->d_pws_buf
15278 : &device_param->d_pws_amp_buf;
15279 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15280 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15281 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15282 device_param->kernel_params[ 4] = &device_param->d_tmps;
15283 device_param->kernel_params[ 5] = &device_param->d_hooks;
15284 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15285 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15286 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15287 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15288 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15289 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15290 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15291 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15292 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15293 device_param->kernel_params[15] = &device_param->d_digests_buf;
15294 device_param->kernel_params[16] = &device_param->d_digests_shown;
15295 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15296 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15297 device_param->kernel_params[19] = &device_param->d_result;
15298 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15299 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15300 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15301 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15302 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15303 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15304 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15305 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15306 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15307 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15308 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15309 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15310
15311 device_param->kernel_params_mp_buf64[3] = 0;
15312 device_param->kernel_params_mp_buf32[4] = 0;
15313 device_param->kernel_params_mp_buf32[5] = 0;
15314 device_param->kernel_params_mp_buf32[6] = 0;
15315 device_param->kernel_params_mp_buf32[7] = 0;
15316 device_param->kernel_params_mp_buf32[8] = 0;
15317
15318 device_param->kernel_params_mp[0] = NULL;
15319 device_param->kernel_params_mp[1] = NULL;
15320 device_param->kernel_params_mp[2] = NULL;
15321 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15322 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15323 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15324 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15325 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15326 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15327
15328 device_param->kernel_params_mp_l_buf64[3] = 0;
15329 device_param->kernel_params_mp_l_buf32[4] = 0;
15330 device_param->kernel_params_mp_l_buf32[5] = 0;
15331 device_param->kernel_params_mp_l_buf32[6] = 0;
15332 device_param->kernel_params_mp_l_buf32[7] = 0;
15333 device_param->kernel_params_mp_l_buf32[8] = 0;
15334 device_param->kernel_params_mp_l_buf32[9] = 0;
15335
15336 device_param->kernel_params_mp_l[0] = NULL;
15337 device_param->kernel_params_mp_l[1] = NULL;
15338 device_param->kernel_params_mp_l[2] = NULL;
15339 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15340 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15341 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15342 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15343 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15344 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15345 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15346
15347 device_param->kernel_params_mp_r_buf64[3] = 0;
15348 device_param->kernel_params_mp_r_buf32[4] = 0;
15349 device_param->kernel_params_mp_r_buf32[5] = 0;
15350 device_param->kernel_params_mp_r_buf32[6] = 0;
15351 device_param->kernel_params_mp_r_buf32[7] = 0;
15352 device_param->kernel_params_mp_r_buf32[8] = 0;
15353
15354 device_param->kernel_params_mp_r[0] = NULL;
15355 device_param->kernel_params_mp_r[1] = NULL;
15356 device_param->kernel_params_mp_r[2] = NULL;
15357 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15358 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15359 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15360 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15361 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15362 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15363
15364 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15365 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15366
15367 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15368 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15369 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15370 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15371 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15372 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15373 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15374
15375 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15376 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15377
15378 device_param->kernel_params_memset_buf32[1] = 0; // value
15379 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15380
15381 device_param->kernel_params_memset[0] = NULL;
15382 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15383 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15384
15385 /**
15386 * kernel name
15387 */
15388
15389 size_t kernel_wgs_tmp;
15390
15391 char kernel_name[64] = { 0 };
15392
15393 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15394 {
15395 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15396 {
15397 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15398
15399 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15400
15401 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15402
15403 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15404
15405 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15406
15407 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15408 }
15409 else
15410 {
15411 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15412
15413 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15414
15415 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15416
15417 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15418
15419 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15420
15421 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15422 }
15423
15424 if (data.attack_mode == ATTACK_MODE_BF)
15425 {
15426 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15427 {
15428 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15429
15430 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15431
15432 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);
15433 }
15434 }
15435 }
15436 else
15437 {
15438 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15439
15440 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15441
15442 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15443
15444 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15445
15446 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15447
15448 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15449
15450 if (opts_type & OPTS_TYPE_HOOK12)
15451 {
15452 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15453
15454 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15455
15456 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);
15457 }
15458
15459 if (opts_type & OPTS_TYPE_HOOK23)
15460 {
15461 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15462
15463 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15464
15465 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);
15466 }
15467 }
15468
15469 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);
15470 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);
15471 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);
15472
15473 for (uint i = 0; i <= 20; i++)
15474 {
15475 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15476 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15477 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15478
15479 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15480 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15481 }
15482
15483 for (uint i = 21; i <= 31; i++)
15484 {
15485 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15486 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15487 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15488
15489 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15490 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15491 }
15492
15493 // GPU memset
15494
15495 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15496
15497 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);
15498
15499 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15500 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15501 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15502
15503 // MP start
15504
15505 if (attack_mode == ATTACK_MODE_BF)
15506 {
15507 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15508 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15509
15510 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);
15511 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);
15512
15513 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15514 {
15515 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15516 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15517 }
15518 }
15519 else if (attack_mode == ATTACK_MODE_HYBRID1)
15520 {
15521 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15522
15523 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);
15524 }
15525 else if (attack_mode == ATTACK_MODE_HYBRID2)
15526 {
15527 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15528
15529 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);
15530 }
15531
15532 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15533 {
15534 // nothing to do
15535 }
15536 else
15537 {
15538 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15539
15540 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);
15541 }
15542
15543 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15544 {
15545 // nothing to do
15546 }
15547 else
15548 {
15549 for (uint i = 0; i < 5; i++)
15550 {
15551 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15552 }
15553
15554 for (uint i = 5; i < 7; i++)
15555 {
15556 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15557 }
15558 }
15559
15560 // maybe this has been updated by clGetKernelWorkGroupInfo()
15561 // value can only be decreased, so we don't need to reallocate buffers
15562
15563 device_param->kernel_threads = kernel_threads;
15564
15565 // zero some data buffers
15566
15567 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15568 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15569 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15570 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15571 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15572 run_kernel_bzero (device_param, device_param->d_result, size_results);
15573
15574 /**
15575 * special buffers
15576 */
15577
15578 if (attack_kern == ATTACK_KERN_STRAIGHT)
15579 {
15580 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15581 }
15582 else if (attack_kern == ATTACK_KERN_COMBI)
15583 {
15584 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15585 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15586 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15587 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15588 }
15589 else if (attack_kern == ATTACK_KERN_BF)
15590 {
15591 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15592 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15593 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15594 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15595 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15596 }
15597
15598 /**
15599 * Store thermal target temperature so we can send a notice to user
15600 */
15601
15602 #if defined(HAVE_HWMON)
15603 if (gpu_temp_disable == 0)
15604 {
15605 const int gpu_temp_threshold_slowdown = hm_get_threshold_slowdown_with_device_id (device_id);
15606
15607 data.hm_device[device_id].gpu_temp_threshold_slowdown = (gpu_temp_threshold_slowdown == -1) ? 100000 : gpu_temp_threshold_slowdown;
15608 }
15609 #endif
15610
15611 /**
15612 * Store initial fanspeed if gpu_temp_retain is enabled
15613 */
15614
15615 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15616 int gpu_temp_retain_set = 0;
15617
15618 if (gpu_temp_disable == 0)
15619 {
15620 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15621 {
15622 hc_thread_mutex_lock (mux_adl);
15623
15624 if (data.hm_device[device_id].fan_supported == 1)
15625 {
15626 if (gpu_temp_retain_chgd == 0)
15627 {
15628 uint cur_temp = 0;
15629 uint default_temp = 0;
15630
15631 int ADL_rc = hm_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
15632
15633 if (ADL_rc == ADL_OK)
15634 {
15635 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15636
15637 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15638
15639 // special case with multi gpu setups: always use minimum retain
15640
15641 if (gpu_temp_retain_set == 0)
15642 {
15643 gpu_temp_retain = gpu_temp_retain_target;
15644 gpu_temp_retain_set = 1;
15645 }
15646 else
15647 {
15648 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15649 }
15650
15651 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15652 }
15653 }
15654
15655 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15656
15657 temp_retain_fanspeed_value[device_id] = fan_speed;
15658
15659 if (fan_speed == -1)
15660 {
15661 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15662
15663 temp_retain_fanspeed_value[device_id] = 0;
15664 }
15665 }
15666
15667 hc_thread_mutex_unlock (mux_adl);
15668 }
15669 }
15670
15671 /**
15672 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15673 */
15674
15675 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15676 {
15677 hc_thread_mutex_lock (mux_adl);
15678
15679 if (data.hm_device[device_id].od_version == 6)
15680 {
15681 int ADL_rc;
15682
15683 // check powertune capabilities first, if not available then skip device
15684
15685 int powertune_supported = 0;
15686
15687 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15688 {
15689 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15690
15691 return (-1);
15692 }
15693
15694 if (powertune_supported != 0)
15695 {
15696 // powercontrol settings
15697
15698 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15699
15700 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15701 {
15702 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15703 }
15704
15705 if (ADL_rc != ADL_OK)
15706 {
15707 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15708
15709 return (-1);
15710 }
15711
15712 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15713 {
15714 log_error ("ERROR: Failed to set new ADL PowerControl values");
15715
15716 return (-1);
15717 }
15718
15719 // clocks
15720
15721 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15722
15723 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15724
15725 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
15726 {
15727 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15728
15729 return (-1);
15730 }
15731
15732 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15733
15734 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15735
15736 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15737 {
15738 log_error ("ERROR: Failed to get ADL device capabilities");
15739
15740 return (-1);
15741 }
15742
15743 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15744 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15745
15746 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15747 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15748
15749 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15750 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15751
15752 // warning if profile has too low max values
15753
15754 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15755 {
15756 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15757 }
15758
15759 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15760 {
15761 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15762 }
15763
15764 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15765
15766 performance_state->iNumberOfPerformanceLevels = 2;
15767
15768 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15769 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15770 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15771 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15772
15773 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
15774 {
15775 log_info ("ERROR: Failed to set ADL performance state");
15776
15777 return (-1);
15778 }
15779
15780 local_free (performance_state);
15781 }
15782 }
15783
15784 hc_thread_mutex_unlock (mux_adl);
15785 }
15786 #endif // HAVE_HWMON && HAVE_ADL
15787 }
15788
15789 data.kernel_power_all = kernel_power_all;
15790
15791 if (data.quiet == 0) log_info_nn ("");
15792
15793 /**
15794 * In benchmark-mode, inform user which algorithm is checked
15795 */
15796
15797 if (benchmark == 1)
15798 {
15799 if (machine_readable == 0)
15800 {
15801 quiet = 0;
15802
15803 data.quiet = quiet;
15804
15805 char *hash_type = strhashtype (data.hash_mode); // not a bug
15806
15807 log_info ("Hashtype: %s", hash_type);
15808 log_info ("");
15809 }
15810 }
15811
15812 /**
15813 * keep track of the progress
15814 */
15815
15816 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15817 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15818 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15819
15820 /**
15821 * open filehandles
15822 */
15823
15824 #if _WIN
15825 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15826 {
15827 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15828
15829 return (-1);
15830 }
15831
15832 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15833 {
15834 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15835
15836 return (-1);
15837 }
15838
15839 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15840 {
15841 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15842
15843 return (-1);
15844 }
15845 #endif
15846
15847 /**
15848 * dictionary pad
15849 */
15850
15851 segment_size *= (1024 * 1024);
15852
15853 data.segment_size = segment_size;
15854
15855 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15856
15857 wl_data->buf = (char *) mymalloc (segment_size);
15858 wl_data->avail = segment_size;
15859 wl_data->incr = segment_size;
15860 wl_data->cnt = 0;
15861 wl_data->pos = 0;
15862
15863 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15864
15865 data.wordlist_mode = wordlist_mode;
15866
15867 cs_t *css_buf = NULL;
15868 uint css_cnt = 0;
15869 uint dictcnt = 0;
15870 uint maskcnt = 1;
15871 char **masks = NULL;
15872 char **dictfiles = NULL;
15873
15874 uint mask_from_file = 0;
15875
15876 if (attack_mode == ATTACK_MODE_STRAIGHT)
15877 {
15878 if (wordlist_mode == WL_MODE_FILE)
15879 {
15880 int wls_left = myargc - (optind + 1);
15881
15882 for (int i = 0; i < wls_left; i++)
15883 {
15884 char *l0_filename = myargv[optind + 1 + i];
15885
15886 struct stat l0_stat;
15887
15888 if (stat (l0_filename, &l0_stat) == -1)
15889 {
15890 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15891
15892 return (-1);
15893 }
15894
15895 uint is_dir = S_ISDIR (l0_stat.st_mode);
15896
15897 if (is_dir == 0)
15898 {
15899 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15900
15901 dictcnt++;
15902
15903 dictfiles[dictcnt - 1] = l0_filename;
15904 }
15905 else
15906 {
15907 // do not allow --keyspace w/ a directory
15908
15909 if (keyspace == 1)
15910 {
15911 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15912
15913 return (-1);
15914 }
15915
15916 char **dictionary_files = NULL;
15917
15918 dictionary_files = scan_directory (l0_filename);
15919
15920 if (dictionary_files != NULL)
15921 {
15922 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15923
15924 for (int d = 0; dictionary_files[d] != NULL; d++)
15925 {
15926 char *l1_filename = dictionary_files[d];
15927
15928 struct stat l1_stat;
15929
15930 if (stat (l1_filename, &l1_stat) == -1)
15931 {
15932 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15933
15934 return (-1);
15935 }
15936
15937 if (S_ISREG (l1_stat.st_mode))
15938 {
15939 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15940
15941 dictcnt++;
15942
15943 dictfiles[dictcnt - 1] = strdup (l1_filename);
15944 }
15945 }
15946 }
15947
15948 local_free (dictionary_files);
15949 }
15950 }
15951
15952 if (dictcnt < 1)
15953 {
15954 log_error ("ERROR: No usable dictionary file found.");
15955
15956 return (-1);
15957 }
15958 }
15959 else if (wordlist_mode == WL_MODE_STDIN)
15960 {
15961 dictcnt = 1;
15962 }
15963 }
15964 else if (attack_mode == ATTACK_MODE_COMBI)
15965 {
15966 // display
15967
15968 char *dictfile1 = myargv[optind + 1 + 0];
15969 char *dictfile2 = myargv[optind + 1 + 1];
15970
15971 // find the bigger dictionary and use as base
15972
15973 FILE *fp1 = NULL;
15974 FILE *fp2 = NULL;
15975
15976 struct stat tmp_stat;
15977
15978 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15979 {
15980 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15981
15982 return (-1);
15983 }
15984
15985 if (stat (dictfile1, &tmp_stat) == -1)
15986 {
15987 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15988
15989 fclose (fp1);
15990
15991 return (-1);
15992 }
15993
15994 if (S_ISDIR (tmp_stat.st_mode))
15995 {
15996 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15997
15998 fclose (fp1);
15999
16000 return (-1);
16001 }
16002
16003 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16004 {
16005 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16006
16007 fclose (fp1);
16008
16009 return (-1);
16010 }
16011
16012 if (stat (dictfile2, &tmp_stat) == -1)
16013 {
16014 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16015
16016 fclose (fp1);
16017 fclose (fp2);
16018
16019 return (-1);
16020 }
16021
16022 if (S_ISDIR (tmp_stat.st_mode))
16023 {
16024 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16025
16026 fclose (fp1);
16027 fclose (fp2);
16028
16029 return (-1);
16030 }
16031
16032 data.combs_cnt = 1;
16033
16034 data.quiet = 1;
16035
16036 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16037
16038 data.quiet = quiet;
16039
16040 if (words1_cnt == 0)
16041 {
16042 log_error ("ERROR: %s: empty file", dictfile1);
16043
16044 fclose (fp1);
16045 fclose (fp2);
16046
16047 return (-1);
16048 }
16049
16050 data.combs_cnt = 1;
16051
16052 data.quiet = 1;
16053
16054 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16055
16056 data.quiet = quiet;
16057
16058 if (words2_cnt == 0)
16059 {
16060 log_error ("ERROR: %s: empty file", dictfile2);
16061
16062 fclose (fp1);
16063 fclose (fp2);
16064
16065 return (-1);
16066 }
16067
16068 fclose (fp1);
16069 fclose (fp2);
16070
16071 data.dictfile = dictfile1;
16072 data.dictfile2 = dictfile2;
16073
16074 if (words1_cnt >= words2_cnt)
16075 {
16076 data.combs_cnt = words2_cnt;
16077 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16078
16079 dictfiles = &data.dictfile;
16080
16081 dictcnt = 1;
16082 }
16083 else
16084 {
16085 data.combs_cnt = words1_cnt;
16086 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16087
16088 dictfiles = &data.dictfile2;
16089
16090 dictcnt = 1;
16091
16092 // we also have to switch wordlist related rules!
16093
16094 char *tmpc = data.rule_buf_l;
16095
16096 data.rule_buf_l = data.rule_buf_r;
16097 data.rule_buf_r = tmpc;
16098
16099 int tmpi = data.rule_len_l;
16100
16101 data.rule_len_l = data.rule_len_r;
16102 data.rule_len_r = tmpi;
16103 }
16104 }
16105 else if (attack_mode == ATTACK_MODE_BF)
16106 {
16107 char *mask = NULL;
16108
16109 maskcnt = 0;
16110
16111 if (benchmark == 0)
16112 {
16113 mask = myargv[optind + 1];
16114
16115 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16116
16117 if ((optind + 2) <= myargc)
16118 {
16119 struct stat file_stat;
16120
16121 if (stat (mask, &file_stat) == -1)
16122 {
16123 maskcnt = 1;
16124
16125 masks[maskcnt - 1] = mystrdup (mask);
16126 }
16127 else
16128 {
16129 int wls_left = myargc - (optind + 1);
16130
16131 uint masks_avail = INCR_MASKS;
16132
16133 for (int i = 0; i < wls_left; i++)
16134 {
16135 if (i != 0)
16136 {
16137 mask = myargv[optind + 1 + i];
16138
16139 if (stat (mask, &file_stat) == -1)
16140 {
16141 log_error ("ERROR: %s: %s", mask, strerror (errno));
16142
16143 return (-1);
16144 }
16145 }
16146
16147 uint is_file = S_ISREG (file_stat.st_mode);
16148
16149 if (is_file == 1)
16150 {
16151 FILE *mask_fp;
16152
16153 if ((mask_fp = fopen (mask, "r")) == NULL)
16154 {
16155 log_error ("ERROR: %s: %s", mask, strerror (errno));
16156
16157 return (-1);
16158 }
16159
16160 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16161
16162 while (!feof (mask_fp))
16163 {
16164 memset (line_buf, 0, HCBUFSIZ);
16165
16166 int line_len = fgetl (mask_fp, line_buf);
16167
16168 if (line_len == 0) continue;
16169
16170 if (line_buf[0] == '#') continue;
16171
16172 if (masks_avail == maskcnt)
16173 {
16174 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16175
16176 masks_avail += INCR_MASKS;
16177 }
16178
16179 masks[maskcnt] = mystrdup (line_buf);
16180
16181 maskcnt++;
16182 }
16183
16184 myfree (line_buf);
16185
16186 fclose (mask_fp);
16187 }
16188 else
16189 {
16190 log_error ("ERROR: %s: unsupported file-type", mask);
16191
16192 return (-1);
16193 }
16194 }
16195
16196 mask_from_file = 1;
16197 }
16198 }
16199 else
16200 {
16201 custom_charset_1 = (char *) "?l?d?u";
16202 custom_charset_2 = (char *) "?l?d";
16203 custom_charset_3 = (char *) "?l?d*!$@_";
16204
16205 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16206 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16207 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16208
16209 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16210
16211 wordlist_mode = WL_MODE_MASK;
16212
16213 data.wordlist_mode = wordlist_mode;
16214
16215 increment = 1;
16216
16217 maskcnt = 1;
16218 }
16219 }
16220 else
16221 {
16222 /**
16223 * generate full masks and charsets
16224 */
16225
16226 masks = (char **) mymalloc (sizeof (char *));
16227
16228 switch (hash_mode)
16229 {
16230 case 1731: pw_min = 5;
16231 pw_max = 5;
16232 mask = mystrdup ("?b?b?b?b?b");
16233 break;
16234 case 12500: pw_min = 5;
16235 pw_max = 5;
16236 mask = mystrdup ("?b?b?b?b?b");
16237 break;
16238 default: pw_min = 7;
16239 pw_max = 7;
16240 mask = mystrdup ("?b?b?b?b?b?b?b");
16241 break;
16242 }
16243
16244 maskcnt = 1;
16245
16246 masks[maskcnt - 1] = mystrdup (mask);
16247
16248 wordlist_mode = WL_MODE_MASK;
16249
16250 data.wordlist_mode = wordlist_mode;
16251
16252 increment = 1;
16253 }
16254
16255 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16256
16257 if (increment)
16258 {
16259 if (increment_min > pw_min) pw_min = increment_min;
16260
16261 if (increment_max < pw_max) pw_max = increment_max;
16262 }
16263 }
16264 else if (attack_mode == ATTACK_MODE_HYBRID1)
16265 {
16266 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16267
16268 // display
16269
16270 char *mask = myargv[myargc - 1];
16271
16272 maskcnt = 0;
16273
16274 masks = (char **) mymalloc (1 * sizeof (char *));
16275
16276 // mod
16277
16278 struct stat file_stat;
16279
16280 if (stat (mask, &file_stat) == -1)
16281 {
16282 maskcnt = 1;
16283
16284 masks[maskcnt - 1] = mystrdup (mask);
16285 }
16286 else
16287 {
16288 uint is_file = S_ISREG (file_stat.st_mode);
16289
16290 if (is_file == 1)
16291 {
16292 FILE *mask_fp;
16293
16294 if ((mask_fp = fopen (mask, "r")) == NULL)
16295 {
16296 log_error ("ERROR: %s: %s", mask, strerror (errno));
16297
16298 return (-1);
16299 }
16300
16301 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16302
16303 uint masks_avail = 1;
16304
16305 while (!feof (mask_fp))
16306 {
16307 memset (line_buf, 0, HCBUFSIZ);
16308
16309 int line_len = fgetl (mask_fp, line_buf);
16310
16311 if (line_len == 0) continue;
16312
16313 if (line_buf[0] == '#') continue;
16314
16315 if (masks_avail == maskcnt)
16316 {
16317 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16318
16319 masks_avail += INCR_MASKS;
16320 }
16321
16322 masks[maskcnt] = mystrdup (line_buf);
16323
16324 maskcnt++;
16325 }
16326
16327 myfree (line_buf);
16328
16329 fclose (mask_fp);
16330
16331 mask_from_file = 1;
16332 }
16333 else
16334 {
16335 maskcnt = 1;
16336
16337 masks[maskcnt - 1] = mystrdup (mask);
16338 }
16339 }
16340
16341 // base
16342
16343 int wls_left = myargc - (optind + 2);
16344
16345 for (int i = 0; i < wls_left; i++)
16346 {
16347 char *filename = myargv[optind + 1 + i];
16348
16349 struct stat file_stat;
16350
16351 if (stat (filename, &file_stat) == -1)
16352 {
16353 log_error ("ERROR: %s: %s", filename, strerror (errno));
16354
16355 return (-1);
16356 }
16357
16358 uint is_dir = S_ISDIR (file_stat.st_mode);
16359
16360 if (is_dir == 0)
16361 {
16362 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16363
16364 dictcnt++;
16365
16366 dictfiles[dictcnt - 1] = filename;
16367 }
16368 else
16369 {
16370 // do not allow --keyspace w/ a directory
16371
16372 if (keyspace == 1)
16373 {
16374 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16375
16376 return (-1);
16377 }
16378
16379 char **dictionary_files = NULL;
16380
16381 dictionary_files = scan_directory (filename);
16382
16383 if (dictionary_files != NULL)
16384 {
16385 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16386
16387 for (int d = 0; dictionary_files[d] != NULL; d++)
16388 {
16389 char *l1_filename = dictionary_files[d];
16390
16391 struct stat l1_stat;
16392
16393 if (stat (l1_filename, &l1_stat) == -1)
16394 {
16395 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16396
16397 return (-1);
16398 }
16399
16400 if (S_ISREG (l1_stat.st_mode))
16401 {
16402 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16403
16404 dictcnt++;
16405
16406 dictfiles[dictcnt - 1] = strdup (l1_filename);
16407 }
16408 }
16409 }
16410
16411 local_free (dictionary_files);
16412 }
16413 }
16414
16415 if (dictcnt < 1)
16416 {
16417 log_error ("ERROR: No usable dictionary file found.");
16418
16419 return (-1);
16420 }
16421
16422 if (increment)
16423 {
16424 maskcnt = 0;
16425
16426 uint mask_min = increment_min; // we can't reject smaller masks here
16427 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16428
16429 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16430 {
16431 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16432
16433 if (cur_mask == NULL) break;
16434
16435 masks[maskcnt] = cur_mask;
16436
16437 maskcnt++;
16438
16439 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16440 }
16441 }
16442 }
16443 else if (attack_mode == ATTACK_MODE_HYBRID2)
16444 {
16445 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16446
16447 // display
16448
16449 char *mask = myargv[optind + 1 + 0];
16450
16451 maskcnt = 0;
16452
16453 masks = (char **) mymalloc (1 * sizeof (char *));
16454
16455 // mod
16456
16457 struct stat file_stat;
16458
16459 if (stat (mask, &file_stat) == -1)
16460 {
16461 maskcnt = 1;
16462
16463 masks[maskcnt - 1] = mystrdup (mask);
16464 }
16465 else
16466 {
16467 uint is_file = S_ISREG (file_stat.st_mode);
16468
16469 if (is_file == 1)
16470 {
16471 FILE *mask_fp;
16472
16473 if ((mask_fp = fopen (mask, "r")) == NULL)
16474 {
16475 log_error ("ERROR: %s: %s", mask, strerror (errno));
16476
16477 return (-1);
16478 }
16479
16480 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16481
16482 uint masks_avail = 1;
16483
16484 while (!feof (mask_fp))
16485 {
16486 memset (line_buf, 0, HCBUFSIZ);
16487
16488 int line_len = fgetl (mask_fp, line_buf);
16489
16490 if (line_len == 0) continue;
16491
16492 if (line_buf[0] == '#') continue;
16493
16494 if (masks_avail == maskcnt)
16495 {
16496 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16497
16498 masks_avail += INCR_MASKS;
16499 }
16500
16501 masks[maskcnt] = mystrdup (line_buf);
16502
16503 maskcnt++;
16504 }
16505
16506 myfree (line_buf);
16507
16508 fclose (mask_fp);
16509
16510 mask_from_file = 1;
16511 }
16512 else
16513 {
16514 maskcnt = 1;
16515
16516 masks[maskcnt - 1] = mystrdup (mask);
16517 }
16518 }
16519
16520 // base
16521
16522 int wls_left = myargc - (optind + 2);
16523
16524 for (int i = 0; i < wls_left; i++)
16525 {
16526 char *filename = myargv[optind + 2 + i];
16527
16528 struct stat file_stat;
16529
16530 if (stat (filename, &file_stat) == -1)
16531 {
16532 log_error ("ERROR: %s: %s", filename, strerror (errno));
16533
16534 return (-1);
16535 }
16536
16537 uint is_dir = S_ISDIR (file_stat.st_mode);
16538
16539 if (is_dir == 0)
16540 {
16541 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16542
16543 dictcnt++;
16544
16545 dictfiles[dictcnt - 1] = filename;
16546 }
16547 else
16548 {
16549 // do not allow --keyspace w/ a directory
16550
16551 if (keyspace == 1)
16552 {
16553 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16554
16555 return (-1);
16556 }
16557
16558 char **dictionary_files = NULL;
16559
16560 dictionary_files = scan_directory (filename);
16561
16562 if (dictionary_files != NULL)
16563 {
16564 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16565
16566 for (int d = 0; dictionary_files[d] != NULL; d++)
16567 {
16568 char *l1_filename = dictionary_files[d];
16569
16570 struct stat l1_stat;
16571
16572 if (stat (l1_filename, &l1_stat) == -1)
16573 {
16574 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16575
16576 return (-1);
16577 }
16578
16579 if (S_ISREG (l1_stat.st_mode))
16580 {
16581 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16582
16583 dictcnt++;
16584
16585 dictfiles[dictcnt - 1] = strdup (l1_filename);
16586 }
16587 }
16588 }
16589
16590 local_free (dictionary_files);
16591 }
16592 }
16593
16594 if (dictcnt < 1)
16595 {
16596 log_error ("ERROR: No usable dictionary file found.");
16597
16598 return (-1);
16599 }
16600
16601 if (increment)
16602 {
16603 maskcnt = 0;
16604
16605 uint mask_min = increment_min; // we can't reject smaller masks here
16606 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16607
16608 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16609 {
16610 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16611
16612 if (cur_mask == NULL) break;
16613
16614 masks[maskcnt] = cur_mask;
16615
16616 maskcnt++;
16617
16618 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16619 }
16620 }
16621 }
16622
16623 data.pw_min = pw_min;
16624 data.pw_max = pw_max;
16625
16626 /**
16627 * weak hash check
16628 */
16629
16630 if (weak_hash_threshold >= salts_cnt)
16631 {
16632 hc_device_param_t *device_param = NULL;
16633
16634 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16635 {
16636 device_param = &data.devices_param[device_id];
16637
16638 if (device_param->skipped) continue;
16639
16640 break;
16641 }
16642
16643 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16644
16645 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16646 {
16647 weak_hash_check (device_param, salt_pos);
16648 }
16649
16650 // Display hack, guarantee that there is at least one \r before real start
16651
16652 //if (data.quiet == 0) log_info ("");
16653 }
16654
16655 /**
16656 * status and monitor threads
16657 */
16658
16659 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16660
16661 hc_thread_t i_thread = 0;
16662
16663 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16664 {
16665 hc_thread_create (i_thread, thread_keypress, &benchmark);
16666 }
16667
16668 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16669
16670 uint ni_threads_cnt = 0;
16671
16672 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16673
16674 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16675
16676 ni_threads_cnt++;
16677
16678 /**
16679 * Outfile remove
16680 */
16681
16682 if (keyspace == 0)
16683 {
16684 if (outfile_check_timer != 0)
16685 {
16686 if (data.outfile_check_directory != NULL)
16687 {
16688 if ((hash_mode != 5200) &&
16689 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16690 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16691 (hash_mode != 9000))
16692 {
16693 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16694
16695 ni_threads_cnt++;
16696 }
16697 else
16698 {
16699 outfile_check_timer = 0;
16700 }
16701 }
16702 else
16703 {
16704 outfile_check_timer = 0;
16705 }
16706 }
16707 }
16708
16709 /**
16710 * Inform the user if we got some hashes remove because of the pot file remove feature
16711 */
16712
16713 if (data.quiet == 0)
16714 {
16715 if (potfile_remove_cracks > 0)
16716 {
16717 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16718 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16719 }
16720 }
16721
16722 data.outfile_check_timer = outfile_check_timer;
16723
16724 /**
16725 * main loop
16726 */
16727
16728 char **induction_dictionaries = NULL;
16729
16730 int induction_dictionaries_cnt = 0;
16731
16732 hcstat_table_t *root_table_buf = NULL;
16733 hcstat_table_t *markov_table_buf = NULL;
16734
16735 uint initial_restore_done = 0;
16736
16737 data.maskcnt = maskcnt;
16738
16739 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16740 {
16741 if (data.devices_status == STATUS_CRACKED) break;
16742
16743 data.devices_status = STATUS_INIT;
16744
16745 if (maskpos > rd->maskpos)
16746 {
16747 rd->dictpos = 0;
16748 }
16749
16750 rd->maskpos = maskpos;
16751 data.maskpos = maskpos;
16752
16753 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16754 {
16755 char *mask = masks[maskpos];
16756
16757 if (mask_from_file == 1)
16758 {
16759 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16760
16761 char *str_ptr;
16762 uint str_pos;
16763
16764 uint mask_offset = 0;
16765
16766 uint separator_cnt;
16767
16768 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16769 {
16770 str_ptr = strstr (mask + mask_offset, ",");
16771
16772 if (str_ptr == NULL) break;
16773
16774 str_pos = str_ptr - mask;
16775
16776 // escaped separator, i.e. "\,"
16777
16778 if (str_pos > 0)
16779 {
16780 if (mask[str_pos - 1] == '\\')
16781 {
16782 separator_cnt --;
16783
16784 mask_offset = str_pos + 1;
16785
16786 continue;
16787 }
16788 }
16789
16790 // reset the offset
16791
16792 mask_offset = 0;
16793
16794 mask[str_pos] = '\0';
16795
16796 switch (separator_cnt)
16797 {
16798 case 0:
16799 mp_reset_usr (mp_usr, 0);
16800
16801 custom_charset_1 = mask;
16802 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16803 break;
16804
16805 case 1:
16806 mp_reset_usr (mp_usr, 1);
16807
16808 custom_charset_2 = mask;
16809 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16810 break;
16811
16812 case 2:
16813 mp_reset_usr (mp_usr, 2);
16814
16815 custom_charset_3 = mask;
16816 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16817 break;
16818
16819 case 3:
16820 mp_reset_usr (mp_usr, 3);
16821
16822 custom_charset_4 = mask;
16823 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16824 break;
16825 }
16826
16827 mask = mask + str_pos + 1;
16828 }
16829 }
16830
16831 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16832 {
16833 if (maskpos > 0)
16834 {
16835 local_free (css_buf);
16836 local_free (data.root_css_buf);
16837 local_free (data.markov_css_buf);
16838
16839 local_free (masks[maskpos - 1]);
16840 }
16841
16842 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16843
16844 data.mask = mask;
16845 data.css_cnt = css_cnt;
16846 data.css_buf = css_buf;
16847
16848 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16849
16850 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16851
16852 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16853 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16854
16855 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16856
16857 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16858
16859 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16860 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16861
16862 data.root_css_buf = root_css_buf;
16863 data.markov_css_buf = markov_css_buf;
16864
16865 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16866
16867 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16868
16869 local_free (root_table_buf);
16870 local_free (markov_table_buf);
16871
16872 // args
16873
16874 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16875 {
16876 hc_device_param_t *device_param = &data.devices_param[device_id];
16877
16878 if (device_param->skipped) continue;
16879
16880 device_param->kernel_params_mp[0] = &device_param->d_combs;
16881 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16882 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16883
16884 device_param->kernel_params_mp_buf64[3] = 0;
16885 device_param->kernel_params_mp_buf32[4] = css_cnt;
16886 device_param->kernel_params_mp_buf32[5] = 0;
16887 device_param->kernel_params_mp_buf32[6] = 0;
16888 device_param->kernel_params_mp_buf32[7] = 0;
16889
16890 if (attack_mode == ATTACK_MODE_HYBRID1)
16891 {
16892 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16893 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16894 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16895 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16896 }
16897 else if (attack_mode == ATTACK_MODE_HYBRID2)
16898 {
16899 device_param->kernel_params_mp_buf32[5] = 0;
16900 device_param->kernel_params_mp_buf32[6] = 0;
16901 device_param->kernel_params_mp_buf32[7] = 0;
16902 }
16903
16904 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]);
16905 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]);
16906 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]);
16907
16908 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);
16909 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);
16910 }
16911 }
16912 else if (attack_mode == ATTACK_MODE_BF)
16913 {
16914 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16915
16916 if (increment)
16917 {
16918 for (uint i = 0; i < dictcnt; i++)
16919 {
16920 local_free (dictfiles[i]);
16921 }
16922
16923 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16924 {
16925 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16926
16927 if (l1_filename == NULL) break;
16928
16929 dictcnt++;
16930
16931 dictfiles[dictcnt - 1] = l1_filename;
16932 }
16933 }
16934 else
16935 {
16936 dictcnt++;
16937
16938 dictfiles[dictcnt - 1] = mask;
16939 }
16940
16941 if (dictcnt == 0)
16942 {
16943 log_error ("ERROR: Mask is too small");
16944
16945 return (-1);
16946 }
16947 }
16948 }
16949
16950 free (induction_dictionaries);
16951
16952 // induction_dictionaries_cnt = 0; // implied
16953
16954 if (attack_mode != ATTACK_MODE_BF)
16955 {
16956 if (keyspace == 0)
16957 {
16958 induction_dictionaries = scan_directory (induction_directory);
16959
16960 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16961 }
16962 }
16963
16964 if (induction_dictionaries_cnt)
16965 {
16966 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16967 }
16968
16969 /**
16970 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16971 */
16972 if (keyspace == 1)
16973 {
16974 if ((maskcnt > 1) || (dictcnt > 1))
16975 {
16976 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16977
16978 return (-1);
16979 }
16980 }
16981
16982 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16983 {
16984 char *subid = logfile_generate_subid ();
16985
16986 data.subid = subid;
16987
16988 logfile_sub_msg ("START");
16989
16990 data.devices_status = STATUS_INIT;
16991
16992 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16993 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16994 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16995
16996 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16997
16998 data.cpt_pos = 0;
16999
17000 data.cpt_start = time (NULL);
17001
17002 data.cpt_total = 0;
17003
17004 if (data.restore == 0)
17005 {
17006 rd->words_cur = skip;
17007
17008 skip = 0;
17009
17010 data.skip = 0;
17011 }
17012
17013 data.ms_paused = 0;
17014
17015 data.words_cur = rd->words_cur;
17016
17017 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17018 {
17019 hc_device_param_t *device_param = &data.devices_param[device_id];
17020
17021 if (device_param->skipped) continue;
17022
17023 device_param->speed_pos = 0;
17024
17025 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17026 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17027
17028 device_param->exec_pos = 0;
17029
17030 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17031
17032 device_param->kernel_power = device_param->kernel_power_user;
17033
17034 device_param->outerloop_pos = 0;
17035 device_param->outerloop_left = 0;
17036 device_param->innerloop_pos = 0;
17037 device_param->innerloop_left = 0;
17038
17039 // some more resets:
17040
17041 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17042
17043 device_param->pws_cnt = 0;
17044
17045 device_param->words_off = 0;
17046 device_param->words_done = 0;
17047 }
17048
17049 data.kernel_power_div = 0;
17050
17051 // figure out some workload
17052
17053 if (attack_mode == ATTACK_MODE_STRAIGHT)
17054 {
17055 if (data.wordlist_mode == WL_MODE_FILE)
17056 {
17057 char *dictfile = NULL;
17058
17059 if (induction_dictionaries_cnt)
17060 {
17061 dictfile = induction_dictionaries[0];
17062 }
17063 else
17064 {
17065 dictfile = dictfiles[dictpos];
17066 }
17067
17068 data.dictfile = dictfile;
17069
17070 logfile_sub_string (dictfile);
17071
17072 for (uint i = 0; i < rp_files_cnt; i++)
17073 {
17074 logfile_sub_var_string ("rulefile", rp_files[i]);
17075 }
17076
17077 FILE *fd2 = fopen (dictfile, "rb");
17078
17079 if (fd2 == NULL)
17080 {
17081 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17082
17083 return (-1);
17084 }
17085
17086 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17087
17088 fclose (fd2);
17089
17090 if (data.words_cnt == 0)
17091 {
17092 if (data.devices_status == STATUS_CRACKED) break;
17093 if (data.devices_status == STATUS_ABORTED) break;
17094
17095 dictpos++;
17096
17097 continue;
17098 }
17099 }
17100 }
17101 else if (attack_mode == ATTACK_MODE_COMBI)
17102 {
17103 char *dictfile = data.dictfile;
17104 char *dictfile2 = data.dictfile2;
17105
17106 logfile_sub_string (dictfile);
17107 logfile_sub_string (dictfile2);
17108
17109 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17110 {
17111 FILE *fd2 = fopen (dictfile, "rb");
17112
17113 if (fd2 == NULL)
17114 {
17115 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17116
17117 return (-1);
17118 }
17119
17120 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17121
17122 fclose (fd2);
17123 }
17124 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17125 {
17126 FILE *fd2 = fopen (dictfile2, "rb");
17127
17128 if (fd2 == NULL)
17129 {
17130 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17131
17132 return (-1);
17133 }
17134
17135 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17136
17137 fclose (fd2);
17138 }
17139
17140 if (data.words_cnt == 0)
17141 {
17142 if (data.devices_status == STATUS_CRACKED) break;
17143 if (data.devices_status == STATUS_ABORTED) break;
17144
17145 dictpos++;
17146
17147 continue;
17148 }
17149 }
17150 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17151 {
17152 char *dictfile = NULL;
17153
17154 if (induction_dictionaries_cnt)
17155 {
17156 dictfile = induction_dictionaries[0];
17157 }
17158 else
17159 {
17160 dictfile = dictfiles[dictpos];
17161 }
17162
17163 data.dictfile = dictfile;
17164
17165 char *mask = data.mask;
17166
17167 logfile_sub_string (dictfile);
17168 logfile_sub_string (mask);
17169
17170 FILE *fd2 = fopen (dictfile, "rb");
17171
17172 if (fd2 == NULL)
17173 {
17174 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17175
17176 return (-1);
17177 }
17178
17179 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17180
17181 fclose (fd2);
17182
17183 if (data.words_cnt == 0)
17184 {
17185 if (data.devices_status == STATUS_CRACKED) break;
17186 if (data.devices_status == STATUS_ABORTED) break;
17187
17188 dictpos++;
17189
17190 continue;
17191 }
17192 }
17193 else if (attack_mode == ATTACK_MODE_BF)
17194 {
17195 local_free (css_buf);
17196 local_free (data.root_css_buf);
17197 local_free (data.markov_css_buf);
17198
17199 char *mask = dictfiles[dictpos];
17200
17201 logfile_sub_string (mask);
17202
17203 // base
17204
17205 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17206
17207 if (opts_type & OPTS_TYPE_PT_UNICODE)
17208 {
17209 uint css_cnt_unicode = css_cnt * 2;
17210
17211 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17212
17213 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17214 {
17215 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17216
17217 css_buf_unicode[j + 1].cs_buf[0] = 0;
17218 css_buf_unicode[j + 1].cs_len = 1;
17219 }
17220
17221 free (css_buf);
17222
17223 css_buf = css_buf_unicode;
17224 css_cnt = css_cnt_unicode;
17225 }
17226
17227 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17228
17229 uint mask_min = pw_min;
17230 uint mask_max = pw_max;
17231
17232 if (opts_type & OPTS_TYPE_PT_UNICODE)
17233 {
17234 mask_min *= 2;
17235 mask_max *= 2;
17236 }
17237
17238 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17239 {
17240 if (css_cnt < mask_min)
17241 {
17242 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17243 }
17244
17245 if (css_cnt > mask_max)
17246 {
17247 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17248 }
17249
17250 // skip to next mask
17251
17252 dictpos++;
17253
17254 rd->dictpos = dictpos;
17255
17256 logfile_sub_msg ("STOP");
17257
17258 continue;
17259 }
17260
17261 uint save_css_cnt = css_cnt;
17262
17263 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17264 {
17265 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17266 {
17267 uint salt_len = (uint) data.salts_buf[0].salt_len;
17268 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17269
17270 uint css_cnt_salt = css_cnt + salt_len;
17271
17272 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17273
17274 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17275
17276 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17277 {
17278 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17279 css_buf_salt[j].cs_len = 1;
17280 }
17281
17282 free (css_buf);
17283
17284 css_buf = css_buf_salt;
17285 css_cnt = css_cnt_salt;
17286 }
17287 }
17288
17289 data.mask = mask;
17290 data.css_cnt = css_cnt;
17291 data.css_buf = css_buf;
17292
17293 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17294
17295 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17296
17297 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17298
17299 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17300 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17301
17302 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17303
17304 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17305
17306 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17307 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17308
17309 data.root_css_buf = root_css_buf;
17310 data.markov_css_buf = markov_css_buf;
17311
17312 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17313
17314 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17315
17316 local_free (root_table_buf);
17317 local_free (markov_table_buf);
17318
17319 // copy + args
17320
17321 uint css_cnt_l = css_cnt;
17322 uint css_cnt_r;
17323
17324 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17325 {
17326 if (save_css_cnt < 6)
17327 {
17328 css_cnt_r = 1;
17329 }
17330 else if (save_css_cnt == 6)
17331 {
17332 css_cnt_r = 2;
17333 }
17334 else
17335 {
17336 if (opts_type & OPTS_TYPE_PT_UNICODE)
17337 {
17338 if (save_css_cnt == 8 || save_css_cnt == 10)
17339 {
17340 css_cnt_r = 2;
17341 }
17342 else
17343 {
17344 css_cnt_r = 4;
17345 }
17346 }
17347 else
17348 {
17349 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17350 {
17351 css_cnt_r = 3;
17352 }
17353 else
17354 {
17355 css_cnt_r = 4;
17356 }
17357 }
17358 }
17359 }
17360 else
17361 {
17362 css_cnt_r = 1;
17363
17364 /* unfinished code?
17365 int sum = css_buf[css_cnt_r - 1].cs_len;
17366
17367 for (uint i = 1; i < 4 && i < css_cnt; i++)
17368 {
17369 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17370
17371 css_cnt_r++;
17372
17373 sum *= css_buf[css_cnt_r - 1].cs_len;
17374 }
17375 */
17376 }
17377
17378 css_cnt_l -= css_cnt_r;
17379
17380 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17381
17382 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17383 {
17384 hc_device_param_t *device_param = &data.devices_param[device_id];
17385
17386 if (device_param->skipped) continue;
17387
17388 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17389 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17390 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17391
17392 device_param->kernel_params_mp_l_buf64[3] = 0;
17393 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17394 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17395 device_param->kernel_params_mp_l_buf32[6] = 0;
17396 device_param->kernel_params_mp_l_buf32[7] = 0;
17397 device_param->kernel_params_mp_l_buf32[8] = 0;
17398
17399 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17400 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17401 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17402 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17403
17404 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17405 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17406 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17407
17408 device_param->kernel_params_mp_r_buf64[3] = 0;
17409 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17410 device_param->kernel_params_mp_r_buf32[5] = 0;
17411 device_param->kernel_params_mp_r_buf32[6] = 0;
17412 device_param->kernel_params_mp_r_buf32[7] = 0;
17413
17414 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]);
17415 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]);
17416 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]);
17417
17418 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]);
17419 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]);
17420 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]);
17421
17422 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);
17423 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);
17424 }
17425 }
17426
17427 u64 words_base = data.words_cnt;
17428
17429 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17430 {
17431 if (data.kernel_rules_cnt)
17432 {
17433 words_base /= data.kernel_rules_cnt;
17434 }
17435 }
17436 else if (data.attack_kern == ATTACK_KERN_COMBI)
17437 {
17438 if (data.combs_cnt)
17439 {
17440 words_base /= data.combs_cnt;
17441 }
17442 }
17443 else if (data.attack_kern == ATTACK_KERN_BF)
17444 {
17445 if (data.bfs_cnt)
17446 {
17447 words_base /= data.bfs_cnt;
17448 }
17449 }
17450
17451 data.words_base = words_base;
17452
17453 if (keyspace == 1)
17454 {
17455 log_info ("%llu", (unsigned long long int) words_base);
17456
17457 return (0);
17458 }
17459
17460 if (data.words_cur > data.words_base)
17461 {
17462 log_error ("ERROR: restore value greater keyspace");
17463
17464 return (-1);
17465 }
17466
17467 if (data.words_cur)
17468 {
17469 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17470 {
17471 for (uint i = 0; i < data.salts_cnt; i++)
17472 {
17473 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17474 }
17475 }
17476 else if (data.attack_kern == ATTACK_KERN_COMBI)
17477 {
17478 for (uint i = 0; i < data.salts_cnt; i++)
17479 {
17480 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17481 }
17482 }
17483 else if (data.attack_kern == ATTACK_KERN_BF)
17484 {
17485 for (uint i = 0; i < data.salts_cnt; i++)
17486 {
17487 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17488 }
17489 }
17490 }
17491
17492 /*
17493 * Inform user about possible slow speeds
17494 */
17495
17496 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17497 {
17498 if (data.words_base < kernel_power_all)
17499 {
17500 if (quiet == 0)
17501 {
17502 log_info ("ATTENTION!");
17503 log_info (" The wordlist or mask you are using is too small.");
17504 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17505 log_info (" The cracking speed will drop.");
17506 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17507 log_info ("");
17508 }
17509 }
17510 }
17511
17512 /*
17513 * Update loopback file
17514 */
17515
17516 if (loopback == 1)
17517 {
17518 time_t now;
17519
17520 time (&now);
17521
17522 uint random_num = get_random_num (0, 9999);
17523
17524 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17525
17526 data.loopback_file = loopback_file;
17527 }
17528
17529 /*
17530 * Update dictionary statistic
17531 */
17532
17533 if (keyspace == 0)
17534 {
17535 dictstat_fp = fopen (dictstat, "wb");
17536
17537 if (dictstat_fp)
17538 {
17539 lock_file (dictstat_fp);
17540
17541 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17542
17543 fclose (dictstat_fp);
17544 }
17545 }
17546
17547 data.devices_status = STATUS_RUNNING;
17548
17549 if (initial_restore_done == 0)
17550 {
17551 if (data.restore_disable == 0) cycle_restore ();
17552
17553 initial_restore_done = 1;
17554 }
17555
17556 hc_timer_set (&data.timer_running);
17557
17558 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17559 {
17560 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17561 {
17562 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17563 if (quiet == 0) fflush (stdout);
17564 }
17565 }
17566 else if (wordlist_mode == WL_MODE_STDIN)
17567 {
17568 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17569 if (data.quiet == 0) log_info ("");
17570 }
17571
17572 time_t runtime_start;
17573
17574 time (&runtime_start);
17575
17576 data.runtime_start = runtime_start;
17577
17578 /**
17579 * create cracker threads
17580 */
17581
17582 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17583
17584 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17585 {
17586 hc_device_param_t *device_param = &devices_param[device_id];
17587
17588 if (wordlist_mode == WL_MODE_STDIN)
17589 {
17590 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17591 }
17592 else
17593 {
17594 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17595 }
17596 }
17597
17598 // wait for crack threads to exit
17599
17600 hc_thread_wait (data.devices_cnt, c_threads);
17601
17602 local_free (c_threads);
17603
17604 data.restore = 0;
17605
17606 // finalize task
17607
17608 logfile_sub_var_uint ("status-after-work", data.devices_status);
17609
17610 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17611
17612 if (data.devices_status == STATUS_CRACKED) break;
17613 if (data.devices_status == STATUS_ABORTED) break;
17614
17615 if (data.devices_status == STATUS_BYPASS)
17616 {
17617 data.devices_status = STATUS_RUNNING;
17618 }
17619
17620 if (induction_dictionaries_cnt)
17621 {
17622 unlink (induction_dictionaries[0]);
17623 }
17624
17625 free (induction_dictionaries);
17626
17627 if (attack_mode != ATTACK_MODE_BF)
17628 {
17629 induction_dictionaries = scan_directory (induction_directory);
17630
17631 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17632 }
17633
17634 if (benchmark == 0)
17635 {
17636 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17637 {
17638 if (quiet == 0) clear_prompt ();
17639
17640 if (quiet == 0) log_info ("");
17641
17642 if (status == 1)
17643 {
17644 status_display ();
17645 }
17646 else
17647 {
17648 if (quiet == 0) status_display ();
17649 }
17650
17651 if (quiet == 0) log_info ("");
17652 }
17653 }
17654
17655 if (attack_mode == ATTACK_MODE_BF)
17656 {
17657 dictpos++;
17658
17659 rd->dictpos = dictpos;
17660 }
17661 else
17662 {
17663 if (induction_dictionaries_cnt)
17664 {
17665 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17666 }
17667 else
17668 {
17669 dictpos++;
17670
17671 rd->dictpos = dictpos;
17672 }
17673 }
17674
17675 time_t runtime_stop;
17676
17677 time (&runtime_stop);
17678
17679 data.runtime_stop = runtime_stop;
17680
17681 logfile_sub_uint (runtime_start);
17682 logfile_sub_uint (runtime_stop);
17683
17684 logfile_sub_msg ("STOP");
17685
17686 global_free (subid);
17687 }
17688
17689 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17690
17691 if (data.devices_status == STATUS_CRACKED) break;
17692 if (data.devices_status == STATUS_ABORTED) break;
17693 if (data.devices_status == STATUS_QUIT) break;
17694
17695 if (data.devices_status == STATUS_BYPASS)
17696 {
17697 data.devices_status = STATUS_RUNNING;
17698 }
17699 }
17700
17701 // 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
17702
17703 if (attack_mode == ATTACK_MODE_STRAIGHT)
17704 {
17705 if (data.wordlist_mode == WL_MODE_FILE)
17706 {
17707 if (data.dictfile == NULL)
17708 {
17709 if (dictfiles != NULL)
17710 {
17711 data.dictfile = dictfiles[0];
17712
17713 hc_timer_set (&data.timer_running);
17714 }
17715 }
17716 }
17717 }
17718 // NOTE: combi is okay because it is already set beforehand
17719 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17720 {
17721 if (data.dictfile == NULL)
17722 {
17723 if (dictfiles != NULL)
17724 {
17725 hc_timer_set (&data.timer_running);
17726
17727 data.dictfile = dictfiles[0];
17728 }
17729 }
17730 }
17731 else if (attack_mode == ATTACK_MODE_BF)
17732 {
17733 if (data.mask == NULL)
17734 {
17735 hc_timer_set (&data.timer_running);
17736
17737 data.mask = masks[0];
17738 }
17739 }
17740
17741 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17742 {
17743 data.devices_status = STATUS_EXHAUSTED;
17744 }
17745
17746 // if cracked / aborted remove last induction dictionary
17747
17748 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17749 {
17750 struct stat induct_stat;
17751
17752 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17753 {
17754 unlink (induction_dictionaries[file_pos]);
17755 }
17756 }
17757
17758 // wait for non-interactive threads
17759
17760 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17761 {
17762 hc_thread_wait (1, &ni_threads[thread_idx]);
17763 }
17764
17765 local_free (ni_threads);
17766
17767 // wait for interactive threads
17768
17769 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17770 {
17771 hc_thread_wait (1, &i_thread);
17772 }
17773
17774 // we dont need restore file anymore
17775 if (data.restore_disable == 0)
17776 {
17777 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17778 {
17779 unlink (eff_restore_file);
17780 unlink (new_restore_file);
17781 }
17782 else
17783 {
17784 cycle_restore ();
17785 }
17786 }
17787
17788 // finally save left hashes
17789
17790 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17791 {
17792 save_hash ();
17793 }
17794
17795 /**
17796 * Clean up
17797 */
17798
17799 if (benchmark == 1)
17800 {
17801 status_benchmark ();
17802
17803 if (machine_readable == 0)
17804 {
17805 log_info ("");
17806 }
17807 }
17808 else
17809 {
17810 if (quiet == 0) clear_prompt ();
17811
17812 if (quiet == 0) log_info ("");
17813
17814 if (status == 1)
17815 {
17816 status_display ();
17817 }
17818 else
17819 {
17820 if (quiet == 0) status_display ();
17821 }
17822
17823 if (quiet == 0) log_info ("");
17824 }
17825
17826 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17827 {
17828 hc_device_param_t *device_param = &data.devices_param[device_id];
17829
17830 if (device_param->skipped) continue;
17831
17832 local_free (device_param->combs_buf);
17833
17834 local_free (device_param->hooks_buf);
17835
17836 local_free (device_param->device_name);
17837
17838 local_free (device_param->device_name_chksum);
17839
17840 local_free (device_param->device_version);
17841
17842 local_free (device_param->driver_version);
17843
17844 if (device_param->pws_buf) myfree (device_param->pws_buf);
17845 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17846 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17847 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17848 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17849 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17850 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17851 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17852 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17853 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17854 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17855 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17856 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17857 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17858 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17859 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17860 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17861 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17862 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17863 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17864 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17865 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17866 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17867 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17868 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17869 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17870 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17871 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17872 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17873
17874 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17875 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17876 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17877 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17878 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17879 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17880 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17881 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17882 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17883 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17884 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17885
17886 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17887 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17888 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17889
17890 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17891 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17892 }
17893
17894 // reset default fan speed
17895
17896 #ifdef HAVE_HWMON
17897 if (gpu_temp_disable == 0)
17898 {
17899 #ifdef HAVE_ADL
17900 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17901 {
17902 hc_thread_mutex_lock (mux_adl);
17903
17904 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17905 {
17906 hc_device_param_t *device_param = &data.devices_param[device_id];
17907
17908 if (device_param->skipped) continue;
17909
17910 if (data.hm_device[device_id].fan_supported == 1)
17911 {
17912 int fanspeed = temp_retain_fanspeed_value[device_id];
17913
17914 if (fanspeed == -1) continue;
17915
17916 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17917
17918 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17919 }
17920 }
17921
17922 hc_thread_mutex_unlock (mux_adl);
17923 }
17924 #endif // HAVE_ADL
17925 }
17926
17927 #ifdef HAVE_ADL
17928 // reset power tuning
17929
17930 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17931 {
17932 hc_thread_mutex_lock (mux_adl);
17933
17934 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17935 {
17936 hc_device_param_t *device_param = &data.devices_param[device_id];
17937
17938 if (device_param->skipped) continue;
17939
17940 if (data.hm_device[device_id].od_version == 6)
17941 {
17942 // check powertune capabilities first, if not available then skip device
17943
17944 int powertune_supported = 0;
17945
17946 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17947 {
17948 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17949
17950 return (-1);
17951 }
17952
17953 if (powertune_supported != 0)
17954 {
17955 // powercontrol settings
17956
17957 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK)
17958 {
17959 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17960
17961 return (-1);
17962 }
17963
17964 // clocks
17965
17966 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17967
17968 performance_state->iNumberOfPerformanceLevels = 2;
17969
17970 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17971 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17972 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17973 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17974
17975 if ((hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
17976 {
17977 log_info ("ERROR: Failed to restore ADL performance state");
17978
17979 return (-1);
17980 }
17981
17982 local_free (performance_state);
17983 }
17984 }
17985 }
17986
17987 hc_thread_mutex_unlock (mux_adl);
17988 }
17989 #endif // HAVE_ADL
17990
17991 if (gpu_temp_disable == 0)
17992 {
17993 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17994 if (data.hm_nv)
17995 {
17996 #if defined(LINUX) && defined(HAVE_NVML)
17997
17998 hm_NVML_nvmlShutdown (data.hm_nv);
17999
18000 nvml_close (data.hm_nv);
18001
18002 #elif defined(WIN) && (HAVE_NVAPI)
18003
18004 hm_NvAPI_Unload (data.hm_nv);
18005
18006 nvapi_close (data.hm_nv);
18007
18008 #endif
18009
18010 data.hm_nv = NULL;
18011 }
18012 #endif
18013
18014 #ifdef HAVE_ADL
18015 if (data.hm_amd)
18016 {
18017 hm_ADL_Main_Control_Destroy (data.hm_amd);
18018
18019 adl_close (data.hm_amd);
18020 data.hm_amd = NULL;
18021 }
18022 #endif
18023 }
18024 #endif // HAVE_HWMON
18025
18026 // free memory
18027
18028 local_free (masks);
18029
18030 local_free (dictstat_base);
18031
18032 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18033 {
18034 pot_t *pot_ptr = &pot[pot_pos];
18035
18036 hash_t *hash = &pot_ptr->hash;
18037
18038 local_free (hash->digest);
18039
18040 if (isSalted)
18041 {
18042 local_free (hash->salt);
18043 }
18044 }
18045
18046 local_free (pot);
18047
18048 local_free (all_kernel_rules_cnt);
18049 local_free (all_kernel_rules_buf);
18050
18051 local_free (wl_data->buf);
18052 local_free (wl_data);
18053
18054 local_free (bitmap_s1_a);
18055 local_free (bitmap_s1_b);
18056 local_free (bitmap_s1_c);
18057 local_free (bitmap_s1_d);
18058 local_free (bitmap_s2_a);
18059 local_free (bitmap_s2_b);
18060 local_free (bitmap_s2_c);
18061 local_free (bitmap_s2_d);
18062
18063 #ifdef HAVE_HWMON
18064 local_free (temp_retain_fanspeed_value);
18065 #ifdef HAVE_ADL
18066 local_free (od_clock_mem_status);
18067 local_free (od_power_control_status);
18068 #endif // ADL
18069 #endif
18070
18071 global_free (devices_param);
18072
18073 global_free (kernel_rules_buf);
18074
18075 global_free (root_css_buf);
18076 global_free (markov_css_buf);
18077
18078 global_free (digests_buf);
18079 global_free (digests_shown);
18080 global_free (digests_shown_tmp);
18081
18082 global_free (salts_buf);
18083 global_free (salts_shown);
18084
18085 global_free (esalts_buf);
18086
18087 global_free (words_progress_done);
18088 global_free (words_progress_rejected);
18089 global_free (words_progress_restored);
18090
18091 if (pot_fp) fclose (pot_fp);
18092
18093 if (data.devices_status == STATUS_QUIT) break;
18094 }
18095
18096 // destroy others mutex
18097
18098 hc_thread_mutex_delete (mux_dispatcher);
18099 hc_thread_mutex_delete (mux_counter);
18100 hc_thread_mutex_delete (mux_display);
18101 hc_thread_mutex_delete (mux_adl);
18102
18103 // free memory
18104
18105 local_free (eff_restore_file);
18106 local_free (new_restore_file);
18107
18108 local_free (rd);
18109
18110 // tuning db
18111
18112 tuning_db_destroy (tuning_db);
18113
18114 // loopback
18115
18116 local_free (loopback_file);
18117
18118 if (loopback == 1) unlink (loopback_file);
18119
18120 // induction directory
18121
18122 if (induction_dir == NULL)
18123 {
18124 if (attack_mode != ATTACK_MODE_BF)
18125 {
18126 if (rmdir (induction_directory) == -1)
18127 {
18128 if (errno == ENOENT)
18129 {
18130 // good, we can ignore
18131 }
18132 else if (errno == ENOTEMPTY)
18133 {
18134 // good, we can ignore
18135 }
18136 else
18137 {
18138 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18139
18140 return (-1);
18141 }
18142 }
18143
18144 local_free (induction_directory);
18145 }
18146 }
18147
18148 // outfile-check directory
18149
18150 if (outfile_check_dir == NULL)
18151 {
18152 if (rmdir (outfile_check_directory) == -1)
18153 {
18154 if (errno == ENOENT)
18155 {
18156 // good, we can ignore
18157 }
18158 else if (errno == ENOTEMPTY)
18159 {
18160 // good, we can ignore
18161 }
18162 else
18163 {
18164 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18165
18166 return (-1);
18167 }
18168 }
18169
18170 local_free (outfile_check_directory);
18171 }
18172
18173 time_t proc_stop;
18174
18175 time (&proc_stop);
18176
18177 logfile_top_uint (proc_start);
18178 logfile_top_uint (proc_stop);
18179
18180 logfile_top_msg ("STOP");
18181
18182 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18183 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18184
18185 if (data.ocl) ocl_close (data.ocl);
18186
18187 if (data.devices_status == STATUS_ABORTED) return 2;
18188 if (data.devices_status == STATUS_QUIT) return 2;
18189 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18190 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18191 if (data.devices_status == STATUS_CRACKED) return 0;
18192
18193 return -1;
18194 }
Hashcat additions to support pwdhash