projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix autotune in case of rule-based attack is used
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define MACHINE_READABLE 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 0
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 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 " --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) |",
415 #endif
416 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
417 " -s, --skip | Num | Skip X words from the start | -s 1000000",
418 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
419 " --keyspace | | Show keyspace base:mod values and quit |",
420 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
421 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
422 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
423 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
424 " --generate-rules-func-min | Num | Force min X funcs per rule |",
425 " --generate-rules-func-max | Num | Force max X funcs per rule |",
426 " --generate-rules-seed | Num | Force RNG seed set to X |",
427 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
428 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
429 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
430 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
431 " -i, --increment | | Enable mask increment mode |",
432 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
433 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
434 "",
435 "- [ Hash modes ] -",
436 "",
437 " # | Name | Category",
438 " ======+==================================================+======================================",
439 " 900 | MD4 | Raw Hash",
440 " 0 | MD5 | Raw Hash",
441 " 5100 | Half MD5 | Raw Hash",
442 " 100 | SHA1 | Raw Hash",
443 " 10800 | SHA-384 | Raw Hash",
444 " 1400 | SHA-256 | Raw Hash",
445 " 1700 | SHA-512 | Raw Hash",
446 " 5000 | SHA-3(Keccak) | Raw Hash",
447 " 10100 | SipHash | Raw Hash",
448 " 6000 | RipeMD160 | Raw Hash",
449 " 6100 | Whirlpool | Raw Hash",
450 " 6900 | GOST R 34.11-94 | Raw Hash",
451 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
452 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
453 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
454 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
455 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
456 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
457 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
458 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
459 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
460 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
461 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
462 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
463 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
464 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
465 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
466 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
467 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
468 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
469 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
471 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
472 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
473 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
474 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
475 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
476 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
477 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
478 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
479 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
480 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
481 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
482 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
483 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
484 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
485 " 400 | phpass | Generic KDF",
486 " 8900 | scrypt | Generic KDF",
487 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
488 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
489 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
490 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
491 " 23 | Skype | Network protocols",
492 " 2500 | WPA/WPA2 | Network protocols",
493 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
494 " 5300 | IKE-PSK MD5 | Network protocols",
495 " 5400 | IKE-PSK SHA1 | Network protocols",
496 " 5500 | NetNTLMv1 | Network protocols",
497 " 5500 | NetNTLMv1 + ESS | Network protocols",
498 " 5600 | NetNTLMv2 | Network protocols",
499 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
500 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
501 " 8300 | DNSSEC (NSEC3) | Network protocols",
502 " 10200 | Cram MD5 | Network protocols",
503 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
504 " 11200 | MySQL CRAM (SHA1) | Network protocols",
505 " 11400 | SIP digest authentication (MD5) | Network protocols",
506 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
507 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
508 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
509 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
510 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
511 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
512 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
513 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
514 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
515 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
516 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
517 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
518 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
519 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
520 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
521 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
522 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
523 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
524 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
525 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
526 " 12 | PostgreSQL | Database Server",
527 " 131 | MSSQL(2000) | Database Server",
528 " 132 | MSSQL(2005) | Database Server",
529 " 1731 | MSSQL(2012) | Database Server",
530 " 1731 | MSSQL(2014) | Database Server",
531 " 200 | MySQL323 | Database Server",
532 " 300 | MySQL4.1/MySQL5 | Database Server",
533 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
534 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
535 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
536 " 8000 | Sybase ASE | Database Server",
537 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
538 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
539 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
540 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
541 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
542 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
543 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
544 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
545 " 11500 | CRC32 | Checksums",
546 " 3000 | LM | Operating-Systems",
547 " 1000 | NTLM | Operating-Systems",
548 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
549 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
550 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
551 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
552 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
553 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
554 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
555 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
556 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
557 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
558 " 1722 | OSX v10.7 | Operating-Systems",
559 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
560 " 6300 | AIX {smd5} | Operating-Systems",
561 " 6700 | AIX {ssha1} | Operating-Systems",
562 " 6400 | AIX {ssha256} | Operating-Systems",
563 " 6500 | AIX {ssha512} | Operating-Systems",
564 " 2400 | Cisco-PIX | Operating-Systems",
565 " 2410 | Cisco-ASA | Operating-Systems",
566 " 500 | Cisco-IOS $1$ | Operating-Systems",
567 " 5700 | Cisco-IOS $4$ | Operating-Systems",
568 " 9200 | Cisco-IOS $8$ | Operating-Systems",
569 " 9300 | Cisco-IOS $9$ | Operating-Systems",
570 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
571 " 501 | Juniper IVE | Operating-Systems",
572 " 5800 | Android PIN | Operating-Systems",
573 " 8100 | Citrix Netscaler | Operating-Systems",
574 " 8500 | RACF | Operating-Systems",
575 " 7200 | GRUB 2 | Operating-Systems",
576 " 9900 | Radmin2 | Operating-Systems",
577 " 125 | ArubaOS | Operating-Systems",
578 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
579 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
580 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
581 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
582 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
583 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
584 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
585 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
586 " 11600 | 7-Zip | Archives",
587 " 12500 | RAR3-hp | Archives",
588 " 13000 | RAR5 | Archives",
589 " 13200 | AxCrypt | Archives",
590 " 13300 | AxCrypt in memory SHA1 | Archives",
591 " 13600 | WinZip | Archives",
592 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
593 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
594 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
595 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
596 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
597 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
598 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
599 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
600 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
601 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
602 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
603 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
604 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
605 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
606 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
607 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
608 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
609 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
610 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
611 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
612 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
613 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
614 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
615 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
616 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
617 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
618 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
619 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
620 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
621 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
622 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
623 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
624 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
625 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
626 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
627 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
628 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
629 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
630 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
631 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
632 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
633 " 9400 | MS Office 2007 | Documents",
634 " 9500 | MS Office 2010 | Documents",
635 " 9600 | MS Office 2013 | Documents",
636 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
637 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
638 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
639 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
640 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
641 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
642 " 9000 | Password Safe v2 | Password Managers",
643 " 5200 | Password Safe v3 | Password Managers",
644 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
645 " 6600 | 1Password, agilekeychain | Password Managers",
646 " 8200 | 1Password, cloudkeychain | Password Managers",
647 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
648 " 12700 | Blockchain, My Wallet | Password Managers",
649 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
650 "",
651 "- [ Outfile Formats ] -",
652 "",
653 " # | Format",
654 " ===+========",
655 " 1 | hash[:salt]",
656 " 2 | plain",
657 " 3 | hash[:salt]:plain",
658 " 4 | hex_plain",
659 " 5 | hash[:salt]:hex_plain",
660 " 6 | plain:hex_plain",
661 " 7 | hash[:salt]:plain:hex_plain",
662 " 8 | crackpos",
663 " 9 | hash[:salt]:crack_pos",
664 " 10 | plain:crack_pos",
665 " 11 | hash[:salt]:plain:crack_pos",
666 " 12 | hex_plain:crack_pos",
667 " 13 | hash[:salt]:hex_plain:crack_pos",
668 " 14 | plain:hex_plain:crack_pos",
669 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
670 "",
671 "- [ Rule Debugging Modes ] -",
672 "",
673 " # | Format",
674 " ===+========",
675 " 1 | Finding-Rule",
676 " 2 | Original-Word",
677 " 3 | Original-Word:Finding-Rule",
678 " 4 | Original-Word:Finding-Rule:Processed-Word",
679 "",
680 "- [ Attack Modes ] -",
681 "",
682 " # | Mode",
683 " ===+======",
684 " 0 | Straight",
685 " 1 | Combination",
686 " 3 | Brute-force",
687 " 6 | Hybrid Wordlist + Mask",
688 " 7 | Hybrid Mask + Wordlist",
689 "",
690 "- [ Built-in Charsets ] -",
691 "",
692 " ? | Charset",
693 " ===+=========",
694 " l | abcdefghijklmnopqrstuvwxyz",
695 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
696 " d | 0123456789",
697 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
698 " a | ?l?u?d?s",
699 " b | 0x00 - 0xff",
700 "",
701 "- [ OpenCL Device Types ] -",
702 "",
703 " # | Device Type",
704 " ===+=============",
705 " 1 | CPU",
706 " 2 | GPU",
707 " 3 | FPGA, DSP, Co-Processor",
708 "",
709 "- [ Workload Profiles ] -",
710 "",
711 " # | Performance | Runtime | Power Consumption | Desktop Impact",
712 " ===+=============+=========+===================+=================",
713 " 1 | Low | 2 ms | Low | Minimal",
714 " 2 | Default | 12 ms | Economic | Noticeable",
715 " 3 | High | 96 ms | High | Unresponsive",
716 " 4 | Nightmare | 480 ms | Insane | Headless",
717 "",
718 "If you have no idea what just happened then visit the following pages:",
719 "",
720 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
721 "* https://hashcat.net/wiki/#frequently_asked_questions",
722 "",
723 NULL
724 };
725
726 /**
727 * hashcat specific functions
728 */
729
730 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
731 {
732 int exec_pos = (int) device_param->exec_pos - last_num_entries;
733
734 if (exec_pos < 0) exec_pos += EXEC_CACHE;
735
736 double exec_ms_sum = 0;
737
738 int exec_ms_cnt = 0;
739
740 for (int i = 0; i < last_num_entries; i++)
741 {
742 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
743
744 if (exec_ms)
745 {
746 exec_ms_sum += exec_ms;
747
748 exec_ms_cnt++;
749 }
750 }
751
752 if (exec_ms_cnt == 0) return 0;
753
754 return exec_ms_sum / exec_ms_cnt;
755 }
756
757 void status_display_machine_readable ()
758 {
759 FILE *out = stdout;
760
761 fprintf (out, "STATUS\t%u\t", data.devices_status);
762
763 /**
764 * speed new
765 */
766
767 fprintf (out, "SPEED\t");
768
769 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
770 {
771 hc_device_param_t *device_param = &data.devices_param[device_id];
772
773 if (device_param->skipped) continue;
774
775 u64 speed_cnt = 0;
776 double speed_ms = 0;
777
778 for (int i = 0; i < SPEED_CACHE; i++)
779 {
780 speed_cnt += device_param->speed_cnt[i];
781 speed_ms += device_param->speed_ms[i];
782 }
783
784 speed_cnt /= SPEED_CACHE;
785 speed_ms /= SPEED_CACHE;
786
787 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
788 }
789
790 /**
791 * exec time
792 */
793
794 fprintf (out, "EXEC_RUNTIME\t");
795
796 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
797 {
798 hc_device_param_t *device_param = &data.devices_param[device_id];
799
800 if (device_param->skipped) continue;
801
802 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
803
804 fprintf (out, "%f\t", exec_ms_avg);
805 }
806
807 /**
808 * words_cur
809 */
810
811 u64 words_cur = get_lowest_words_done ();
812
813 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
814
815 /**
816 * counter
817 */
818
819 u64 progress_total = data.words_cnt * data.salts_cnt;
820
821 u64 all_done = 0;
822 u64 all_rejected = 0;
823 u64 all_restored = 0;
824
825 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
826 {
827 all_done += data.words_progress_done[salt_pos];
828 all_rejected += data.words_progress_rejected[salt_pos];
829 all_restored += data.words_progress_restored[salt_pos];
830 }
831
832 u64 progress_cur = all_restored + all_done + all_rejected;
833 u64 progress_end = progress_total;
834
835 u64 progress_skip = 0;
836
837 if (data.skip)
838 {
839 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
840
841 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
842 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
843 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
844 }
845
846 if (data.limit)
847 {
848 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
849
850 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
851 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
852 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
853 }
854
855 u64 progress_cur_relative_skip = progress_cur - progress_skip;
856 u64 progress_end_relative_skip = progress_end - progress_skip;
857
858 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
859
860 /**
861 * cracks
862 */
863
864 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
865 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
866
867 /**
868 * temperature
869 */
870
871 #ifdef HAVE_HWMON
872 if (data.gpu_temp_disable == 0)
873 {
874 fprintf (out, "TEMP\t");
875
876 hc_thread_mutex_lock (mux_adl);
877
878 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
879 {
880 hc_device_param_t *device_param = &data.devices_param[device_id];
881
882 if (device_param->skipped) continue;
883
884 int temp = hm_get_temperature_with_device_id (device_id);
885
886 fprintf (out, "%d\t", temp);
887 }
888
889 hc_thread_mutex_unlock (mux_adl);
890 }
891 #endif // HAVE_HWMON
892
893 /**
894 * flush
895 */
896
897 #ifdef _WIN
898 fputc ('\r', out);
899 fputc ('\n', out);
900 #endif
901
902 #ifdef _POSIX
903 fputc ('\n', out);
904 #endif
905
906 fflush (out);
907 }
908
909 void status_display ()
910 {
911 if (data.devices_status == STATUS_INIT) return;
912 if (data.devices_status == STATUS_STARTING) return;
913 if (data.devices_status == STATUS_BYPASS) return;
914
915 if (data.machine_readable == 1)
916 {
917 status_display_machine_readable ();
918
919 return;
920 }
921
922 char tmp_buf[1000] = { 0 };
923
924 uint tmp_len = 0;
925
926 log_info ("Session.Name...: %s", data.session);
927
928 char *status_type = strstatus (data.devices_status);
929
930 uint hash_mode = data.hash_mode;
931
932 char *hash_type = strhashtype (hash_mode); // not a bug
933
934 log_info ("Status.........: %s", status_type);
935
936 /**
937 * show rules
938 */
939
940 if (data.rp_files_cnt)
941 {
942 uint i;
943
944 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
945 {
946 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
947 }
948
949 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
950
951 log_info ("Rules.Type.....: %s", tmp_buf);
952
953 tmp_len = 0;
954 }
955
956 if (data.rp_gen)
957 {
958 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
959
960 if (data.rp_gen_seed)
961 {
962 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
963 }
964 }
965
966 /**
967 * show input
968 */
969
970 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
971 {
972 if (data.wordlist_mode == WL_MODE_FILE)
973 {
974 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
975 }
976 else if (data.wordlist_mode == WL_MODE_STDIN)
977 {
978 log_info ("Input.Mode.....: Pipe");
979 }
980 }
981 else if (data.attack_mode == ATTACK_MODE_COMBI)
982 {
983 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
984 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
985 }
986 else if (data.attack_mode == ATTACK_MODE_BF)
987 {
988 char *mask = data.mask;
989
990 if (mask != NULL)
991 {
992 uint mask_len = data.css_cnt;
993
994 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
995
996 if (mask_len > 0)
997 {
998 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
999 {
1000 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1001 {
1002 mask_len -= data.salts_buf[0].salt_len;
1003 }
1004 }
1005
1006 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1007
1008 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1009 }
1010
1011 if (data.maskcnt > 1)
1012 {
1013 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1014
1015 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1016 }
1017
1018 log_info ("Input.Mode.....: %s", tmp_buf);
1019 }
1020
1021 tmp_len = 0;
1022 }
1023 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1024 {
1025 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1026 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1027 }
1028 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1029 {
1030 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1031 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1032 }
1033
1034 if (data.digests_cnt == 1)
1035 {
1036 if (data.hash_mode == 2500)
1037 {
1038 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1039
1040 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1041 (char *) data.salts_buf[0].salt_buf,
1042 wpa->orig_mac1[0],
1043 wpa->orig_mac1[1],
1044 wpa->orig_mac1[2],
1045 wpa->orig_mac1[3],
1046 wpa->orig_mac1[4],
1047 wpa->orig_mac1[5],
1048 wpa->orig_mac2[0],
1049 wpa->orig_mac2[1],
1050 wpa->orig_mac2[2],
1051 wpa->orig_mac2[3],
1052 wpa->orig_mac2[4],
1053 wpa->orig_mac2[5]);
1054 }
1055 else if (data.hash_mode == 5200)
1056 {
1057 log_info ("Hash.Target....: File (%s)", data.hashfile);
1058 }
1059 else if (data.hash_mode == 9000)
1060 {
1061 log_info ("Hash.Target....: File (%s)", data.hashfile);
1062 }
1063 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1064 {
1065 log_info ("Hash.Target....: File (%s)", data.hashfile);
1066 }
1067 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1068 {
1069 log_info ("Hash.Target....: File (%s)", data.hashfile);
1070 }
1071 else
1072 {
1073 char out_buf[HCBUFSIZ] = { 0 };
1074
1075 ascii_digest (out_buf, 0, 0);
1076
1077 // limit length
1078 if (strlen (out_buf) > 40)
1079 {
1080 out_buf[41] = '.';
1081 out_buf[42] = '.';
1082 out_buf[43] = '.';
1083 out_buf[44] = 0;
1084 }
1085
1086 log_info ("Hash.Target....: %s", out_buf);
1087 }
1088 }
1089 else
1090 {
1091 if (data.hash_mode == 3000)
1092 {
1093 char out_buf1[32] = { 0 };
1094 char out_buf2[32] = { 0 };
1095
1096 ascii_digest (out_buf1, 0, 0);
1097 ascii_digest (out_buf2, 0, 1);
1098
1099 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1100 }
1101 else
1102 {
1103 log_info ("Hash.Target....: File (%s)", data.hashfile);
1104 }
1105 }
1106
1107 log_info ("Hash.Type......: %s", hash_type);
1108
1109 /**
1110 * speed new
1111 */
1112
1113 u64 speed_cnt[DEVICES_MAX] = { 0 };
1114 double speed_ms[DEVICES_MAX] = { 0 };
1115
1116 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1117 {
1118 hc_device_param_t *device_param = &data.devices_param[device_id];
1119
1120 if (device_param->skipped) continue;
1121
1122 speed_cnt[device_id] = 0;
1123 speed_ms[device_id] = 0;
1124
1125 for (int i = 0; i < SPEED_CACHE; i++)
1126 {
1127 speed_cnt[device_id] += device_param->speed_cnt[i];
1128 speed_ms[device_id] += device_param->speed_ms[i];
1129 }
1130
1131 speed_cnt[device_id] /= SPEED_CACHE;
1132 speed_ms[device_id] /= SPEED_CACHE;
1133 }
1134
1135 double hashes_all_ms = 0;
1136
1137 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1138
1139 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1140 {
1141 hc_device_param_t *device_param = &data.devices_param[device_id];
1142
1143 if (device_param->skipped) continue;
1144
1145 hashes_dev_ms[device_id] = 0;
1146
1147 if (speed_ms[device_id])
1148 {
1149 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1150
1151 hashes_all_ms += hashes_dev_ms[device_id];
1152 }
1153 }
1154
1155 /**
1156 * exec time
1157 */
1158
1159 double exec_all_ms[DEVICES_MAX] = { 0 };
1160
1161 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1162 {
1163 hc_device_param_t *device_param = &data.devices_param[device_id];
1164
1165 if (device_param->skipped) continue;
1166
1167 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1168
1169 exec_all_ms[device_id] = exec_ms_avg;
1170 }
1171
1172 /**
1173 * timers
1174 */
1175
1176 double ms_running = 0;
1177
1178 hc_timer_get (data.timer_running, ms_running);
1179
1180 double ms_paused = data.ms_paused;
1181
1182 if (data.devices_status == STATUS_PAUSED)
1183 {
1184 double ms_paused_tmp = 0;
1185
1186 hc_timer_get (data.timer_paused, ms_paused_tmp);
1187
1188 ms_paused += ms_paused_tmp;
1189 }
1190
1191 #ifdef WIN
1192
1193 __time64_t sec_run = ms_running / 1000;
1194
1195 #else
1196
1197 time_t sec_run = ms_running / 1000;
1198
1199 #endif
1200
1201 if (sec_run)
1202 {
1203 char display_run[32] = { 0 };
1204
1205 struct tm tm_run;
1206
1207 struct tm *tmp = NULL;
1208
1209 #ifdef WIN
1210
1211 tmp = _gmtime64 (&sec_run);
1212
1213 #else
1214
1215 tmp = gmtime (&sec_run);
1216
1217 #endif
1218
1219 if (tmp != NULL)
1220 {
1221 memset (&tm_run, 0, sizeof (tm_run));
1222
1223 memcpy (&tm_run, tmp, sizeof (tm_run));
1224
1225 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1226
1227 char *start = ctime (&data.proc_start);
1228
1229 size_t start_len = strlen (start);
1230
1231 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1232 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1233
1234 log_info ("Time.Started...: %s (%s)", start, display_run);
1235 }
1236 }
1237 else
1238 {
1239 log_info ("Time.Started...: 0 secs");
1240 }
1241
1242 /**
1243 * counters
1244 */
1245
1246 u64 progress_total = data.words_cnt * data.salts_cnt;
1247
1248 u64 all_done = 0;
1249 u64 all_rejected = 0;
1250 u64 all_restored = 0;
1251
1252 u64 progress_noneed = 0;
1253
1254 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1255 {
1256 all_done += data.words_progress_done[salt_pos];
1257 all_rejected += data.words_progress_rejected[salt_pos];
1258 all_restored += data.words_progress_restored[salt_pos];
1259
1260 // Important for ETA only
1261
1262 if (data.salts_shown[salt_pos] == 1)
1263 {
1264 const u64 all = data.words_progress_done[salt_pos]
1265 + data.words_progress_rejected[salt_pos]
1266 + data.words_progress_restored[salt_pos];
1267
1268 const u64 left = data.words_cnt - all;
1269
1270 progress_noneed += left;
1271 }
1272 }
1273
1274 u64 progress_cur = all_restored + all_done + all_rejected;
1275 u64 progress_end = progress_total;
1276
1277 u64 progress_skip = 0;
1278
1279 if (data.skip)
1280 {
1281 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1282
1283 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1284 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1285 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1286 }
1287
1288 if (data.limit)
1289 {
1290 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1291
1292 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1293 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1294 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1295 }
1296
1297 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1298 u64 progress_end_relative_skip = progress_end - progress_skip;
1299
1300 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1301 {
1302 if (data.devices_status != STATUS_CRACKED)
1303 {
1304 #ifdef WIN
1305 __time64_t sec_etc = 0;
1306 #else
1307 time_t sec_etc = 0;
1308 #endif
1309
1310 if (hashes_all_ms)
1311 {
1312 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1313
1314 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1315
1316 sec_etc = ms_left / 1000;
1317 }
1318
1319 if (sec_etc == 0)
1320 {
1321 //log_info ("Time.Estimated.: 0 secs");
1322 }
1323 else if ((u64) sec_etc > ETC_MAX)
1324 {
1325 log_info ("Time.Estimated.: > 10 Years");
1326 }
1327 else
1328 {
1329 char display_etc[32] = { 0 };
1330
1331 struct tm tm_etc;
1332
1333 struct tm *tmp = NULL;
1334
1335 #ifdef WIN
1336
1337 tmp = _gmtime64 (&sec_etc);
1338
1339 #else
1340
1341 tmp = gmtime (&sec_etc);
1342
1343 #endif
1344
1345 if (tmp != NULL)
1346 {
1347 memset (&tm_etc, 0, sizeof (tm_etc));
1348
1349 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1350
1351 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1352
1353 time_t now;
1354
1355 time (&now);
1356
1357 now += sec_etc;
1358
1359 char *etc = ctime (&now);
1360
1361 size_t etc_len = strlen (etc);
1362
1363 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1364 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1365
1366 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1367 }
1368 }
1369 }
1370 }
1371
1372 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1373 {
1374 hc_device_param_t *device_param = &data.devices_param[device_id];
1375
1376 if (device_param->skipped) continue;
1377
1378 char display_dev_cur[16] = { 0 };
1379
1380 strncpy (display_dev_cur, "0.00", 4);
1381
1382 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1383
1384 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1385 }
1386
1387 char display_all_cur[16] = { 0 };
1388
1389 strncpy (display_all_cur, "0.00", 4);
1390
1391 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1392
1393 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1394
1395 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1396 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1397
1398 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);
1399
1400 // crack-per-time
1401
1402 if (data.digests_cnt > 100)
1403 {
1404 time_t now = time (NULL);
1405
1406 int cpt_cur_min = 0;
1407 int cpt_cur_hour = 0;
1408 int cpt_cur_day = 0;
1409
1410 for (int i = 0; i < CPT_BUF; i++)
1411 {
1412 const uint cracked = data.cpt_buf[i].cracked;
1413 const time_t timestamp = data.cpt_buf[i].timestamp;
1414
1415 if ((timestamp + 60) > now)
1416 {
1417 cpt_cur_min += cracked;
1418 }
1419
1420 if ((timestamp + 3600) > now)
1421 {
1422 cpt_cur_hour += cracked;
1423 }
1424
1425 if ((timestamp + 86400) > now)
1426 {
1427 cpt_cur_day += cracked;
1428 }
1429 }
1430
1431 double ms_real = ms_running - ms_paused;
1432
1433 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1434 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1435 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1436
1437 if ((data.cpt_start + 86400) < now)
1438 {
1439 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1440 cpt_cur_min,
1441 cpt_cur_hour,
1442 cpt_cur_day,
1443 cpt_avg_min,
1444 cpt_avg_hour,
1445 cpt_avg_day);
1446 }
1447 else if ((data.cpt_start + 3600) < now)
1448 {
1449 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1450 cpt_cur_min,
1451 cpt_cur_hour,
1452 cpt_avg_min,
1453 cpt_avg_hour,
1454 cpt_avg_day);
1455 }
1456 else if ((data.cpt_start + 60) < now)
1457 {
1458 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1459 cpt_cur_min,
1460 cpt_avg_min,
1461 cpt_avg_hour,
1462 cpt_avg_day);
1463 }
1464 else
1465 {
1466 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1467 cpt_avg_min,
1468 cpt_avg_hour,
1469 cpt_avg_day);
1470 }
1471 }
1472
1473 // Restore point
1474
1475 u64 restore_point = get_lowest_words_done ();
1476
1477 u64 restore_total = data.words_base;
1478
1479 float percent_restore = 0;
1480
1481 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1482
1483 if (progress_end_relative_skip)
1484 {
1485 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1486 {
1487 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1488 float percent_rejected = 0.0;
1489
1490 if (progress_cur)
1491 {
1492 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1493 }
1494
1495 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);
1496 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1497
1498 if (data.restore_disable == 0)
1499 {
1500 if (percent_finished != 1)
1501 {
1502 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1503 }
1504 }
1505 }
1506 }
1507 else
1508 {
1509 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1510 {
1511 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1512 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1513
1514 if (data.restore_disable == 0)
1515 {
1516 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1517 }
1518 }
1519 else
1520 {
1521 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1522 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1523
1524 // --restore not allowed if stdin is used -- really? why?
1525
1526 //if (data.restore_disable == 0)
1527 //{
1528 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1529 //}
1530 }
1531 }
1532
1533 #ifdef HAVE_HWMON
1534 if (data.gpu_temp_disable == 0)
1535 {
1536 hc_thread_mutex_lock (mux_adl);
1537
1538 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1539 {
1540 hc_device_param_t *device_param = &data.devices_param[device_id];
1541
1542 if (device_param->skipped) continue;
1543
1544 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1545 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1546 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1547 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1548 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1549 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1550 // not working
1551 //const int num_throttle = hm_get_throttle_with_device_id (device_id);
1552
1553 char output_buf[256] = { 0 };
1554
1555 int output_len = 0;
1556
1557 if (num_temperature >= 0)
1558 {
1559 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1560
1561 output_len = strlen (output_buf);
1562 }
1563
1564 if (num_fanspeed >= 0)
1565 {
1566 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1567
1568 output_len = strlen (output_buf);
1569 }
1570
1571 if (num_utilization >= 0)
1572 {
1573 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1574
1575 output_len = strlen (output_buf);
1576 }
1577
1578 if (num_corespeed >= 0)
1579 {
1580 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1581
1582 output_len = strlen (output_buf);
1583 }
1584
1585 if (num_memoryspeed >= 0)
1586 {
1587 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1588
1589 output_len = strlen (output_buf);
1590 }
1591
1592 if (num_buslanes >= 0)
1593 {
1594 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1595
1596 output_len = strlen (output_buf);
1597 }
1598
1599 /*
1600 if (num_throttle >= 0)
1601 {
1602 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Throttle:%u", num_throttle);
1603
1604 output_len = strlen (output_buf);
1605 }
1606 */
1607
1608 if (output_len == 0)
1609 {
1610 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1611
1612 output_len = strlen (output_buf);
1613 }
1614
1615 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1616 }
1617
1618 hc_thread_mutex_unlock (mux_adl);
1619 }
1620 #endif // HAVE_HWMON
1621 }
1622
1623 static void status_benchmark_automate ()
1624 {
1625 u64 speed_cnt[DEVICES_MAX] = { 0 };
1626 double speed_ms[DEVICES_MAX] = { 0 };
1627
1628 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1629 {
1630 hc_device_param_t *device_param = &data.devices_param[device_id];
1631
1632 if (device_param->skipped) continue;
1633
1634 speed_cnt[device_id] = device_param->speed_cnt[0];
1635 speed_ms[device_id] = device_param->speed_ms[0];
1636 }
1637
1638 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1639
1640 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1641 {
1642 hc_device_param_t *device_param = &data.devices_param[device_id];
1643
1644 if (device_param->skipped) continue;
1645
1646 hashes_dev_ms[device_id] = 0;
1647
1648 if (speed_ms[device_id])
1649 {
1650 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1651 }
1652 }
1653
1654 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1655 {
1656 hc_device_param_t *device_param = &data.devices_param[device_id];
1657
1658 if (device_param->skipped) continue;
1659
1660 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1661 }
1662 }
1663
1664 static void status_benchmark ()
1665 {
1666 if (data.devices_status == STATUS_INIT) return;
1667 if (data.devices_status == STATUS_STARTING) return;
1668 if (data.devices_status == STATUS_BYPASS) return;
1669
1670 if (data.machine_readable == 1)
1671 {
1672 status_benchmark_automate ();
1673
1674 return;
1675 }
1676
1677 u64 speed_cnt[DEVICES_MAX] = { 0 };
1678 double speed_ms[DEVICES_MAX] = { 0 };
1679
1680 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1681 {
1682 hc_device_param_t *device_param = &data.devices_param[device_id];
1683
1684 if (device_param->skipped) continue;
1685
1686 speed_cnt[device_id] = device_param->speed_cnt[0];
1687 speed_ms[device_id] = device_param->speed_ms[0];
1688 }
1689
1690 double hashes_all_ms = 0;
1691
1692 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1693
1694 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1695 {
1696 hc_device_param_t *device_param = &data.devices_param[device_id];
1697
1698 if (device_param->skipped) continue;
1699
1700 hashes_dev_ms[device_id] = 0;
1701
1702 if (speed_ms[device_id])
1703 {
1704 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1705
1706 hashes_all_ms += hashes_dev_ms[device_id];
1707 }
1708 }
1709
1710 /**
1711 * exec time
1712 */
1713
1714 double exec_all_ms[DEVICES_MAX] = { 0 };
1715
1716 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1717 {
1718 hc_device_param_t *device_param = &data.devices_param[device_id];
1719
1720 if (device_param->skipped) continue;
1721
1722 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1723
1724 exec_all_ms[device_id] = exec_ms_avg;
1725 }
1726
1727 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1728 {
1729 hc_device_param_t *device_param = &data.devices_param[device_id];
1730
1731 if (device_param->skipped) continue;
1732
1733 char display_dev_cur[16] = { 0 };
1734
1735 strncpy (display_dev_cur, "0.00", 4);
1736
1737 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1738
1739 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1740 }
1741
1742 char display_all_cur[16] = { 0 };
1743
1744 strncpy (display_all_cur, "0.00", 4);
1745
1746 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1747
1748 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1749 }
1750
1751 /**
1752 * hashcat -only- functions
1753 */
1754
1755 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1756 {
1757 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1758 {
1759 if (attack_kern == ATTACK_KERN_STRAIGHT)
1760 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1761 else if (attack_kern == ATTACK_KERN_COMBI)
1762 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1763 else if (attack_kern == ATTACK_KERN_BF)
1764 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1765 }
1766 else
1767 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1768 }
1769
1770 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)
1771 {
1772 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1773 {
1774 if (attack_kern == ATTACK_KERN_STRAIGHT)
1775 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1776 else if (attack_kern == ATTACK_KERN_COMBI)
1777 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1778 else if (attack_kern == ATTACK_KERN_BF)
1779 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1780 }
1781 else
1782 {
1783 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1784 }
1785 }
1786
1787 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1788 {
1789 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1790 {
1791 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1792 }
1793 else
1794 {
1795 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1796 }
1797 }
1798
1799 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)
1800 {
1801 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1802 {
1803 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1804 }
1805 else
1806 {
1807 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1808 }
1809 }
1810
1811 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1812 {
1813 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1814 }
1815
1816 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1817 {
1818 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1819 }
1820
1821 static uint convert_from_hex (char *line_buf, const uint line_len)
1822 {
1823 if (line_len & 1) return (line_len); // not in hex
1824
1825 if (data.hex_wordlist == 1)
1826 {
1827 uint i;
1828 uint j;
1829
1830 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1831 {
1832 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1833 }
1834
1835 memset (line_buf + i, 0, line_len - i);
1836
1837 return (i);
1838 }
1839 else if (line_len >= 6) // $HEX[] = 6
1840 {
1841 if (line_buf[0] != '$') return (line_len);
1842 if (line_buf[1] != 'H') return (line_len);
1843 if (line_buf[2] != 'E') return (line_len);
1844 if (line_buf[3] != 'X') return (line_len);
1845 if (line_buf[4] != '[') return (line_len);
1846 if (line_buf[line_len - 1] != ']') return (line_len);
1847
1848 uint i;
1849 uint j;
1850
1851 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1852 {
1853 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1854 }
1855
1856 memset (line_buf + i, 0, line_len - i);
1857
1858 return (i);
1859 }
1860
1861 return (line_len);
1862 }
1863
1864 static void clear_prompt ()
1865 {
1866 fputc ('\r', stdout);
1867
1868 for (size_t i = 0; i < strlen (PROMPT); i++)
1869 {
1870 fputc (' ', stdout);
1871 }
1872
1873 fputc ('\r', stdout);
1874
1875 fflush (stdout);
1876 }
1877
1878 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1879 {
1880 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);
1881 }
1882
1883 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1884 {
1885 char *outfile = data.outfile;
1886 uint quiet = data.quiet;
1887 FILE *pot_fp = data.pot_fp;
1888 uint loopback = data.loopback;
1889 uint debug_mode = data.debug_mode;
1890 char *debug_file = data.debug_file;
1891
1892 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1893 int debug_rule_len = 0; // -1 error
1894 uint debug_plain_len = 0;
1895
1896 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1897
1898 // hash
1899
1900 char out_buf[HCBUFSIZ] = { 0 };
1901
1902 const u32 salt_pos = plain->salt_pos;
1903 const u32 digest_pos = plain->digest_pos; // relative
1904 const u32 gidvid = plain->gidvid;
1905 const u32 il_pos = plain->il_pos;
1906
1907 ascii_digest (out_buf, salt_pos, digest_pos);
1908
1909 // plain
1910
1911 u64 crackpos = device_param->words_off;
1912
1913 uint plain_buf[16] = { 0 };
1914
1915 u8 *plain_ptr = (u8 *) plain_buf;
1916
1917 unsigned int plain_len = 0;
1918
1919 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1920 {
1921 pw_t pw;
1922
1923 gidd_to_pw_t (device_param, gidvid, &pw);
1924
1925 for (int i = 0; i < 16; i++)
1926 {
1927 plain_buf[i] = pw.i[i];
1928 }
1929
1930 plain_len = pw.pw_len;
1931
1932 const uint off = device_param->innerloop_pos + il_pos;
1933
1934 if (debug_mode > 0)
1935 {
1936 debug_rule_len = 0;
1937
1938 // save rule
1939 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1940 {
1941 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1942
1943 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1944 }
1945
1946 // save plain
1947 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1948 {
1949 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1950
1951 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1952
1953 debug_plain_len = plain_len;
1954 }
1955 }
1956
1957 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1958
1959 crackpos += gidvid;
1960 crackpos *= data.kernel_rules_cnt;
1961 crackpos += device_param->innerloop_pos + il_pos;
1962
1963 if (plain_len > data.pw_max) plain_len = data.pw_max;
1964 }
1965 else if (data.attack_mode == ATTACK_MODE_COMBI)
1966 {
1967 pw_t pw;
1968
1969 gidd_to_pw_t (device_param, gidvid, &pw);
1970
1971 for (int i = 0; i < 16; i++)
1972 {
1973 plain_buf[i] = pw.i[i];
1974 }
1975
1976 plain_len = pw.pw_len;
1977
1978 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1979 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1980
1981 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1982 {
1983 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1984 }
1985 else
1986 {
1987 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1988
1989 memcpy (plain_ptr, comb_buf, comb_len);
1990 }
1991
1992 plain_len += comb_len;
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_BF)
2004 {
2005 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2006 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2007
2008 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2009 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2010
2011 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2012 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2013
2014 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2015 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2016
2017 plain_len = data.css_cnt;
2018
2019 crackpos += gidvid;
2020 crackpos *= data.bfs_cnt;
2021 crackpos += device_param->innerloop_pos + il_pos;
2022 }
2023 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2024 {
2025 pw_t pw;
2026
2027 gidd_to_pw_t (device_param, gidvid, &pw);
2028
2029 for (int i = 0; i < 16; i++)
2030 {
2031 plain_buf[i] = pw.i[i];
2032 }
2033
2034 plain_len = pw.pw_len;
2035
2036 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2037
2038 uint start = 0;
2039 uint stop = device_param->kernel_params_mp_buf32[4];
2040
2041 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2042
2043 plain_len += start + stop;
2044
2045 crackpos += gidvid;
2046 crackpos *= data.combs_cnt;
2047 crackpos += device_param->innerloop_pos + il_pos;
2048
2049 if (data.pw_max != PW_DICTMAX1)
2050 {
2051 if (plain_len > data.pw_max) plain_len = data.pw_max;
2052 }
2053 }
2054 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2055 {
2056 pw_t pw;
2057
2058 gidd_to_pw_t (device_param, gidvid, &pw);
2059
2060 for (int i = 0; i < 16; i++)
2061 {
2062 plain_buf[i] = pw.i[i];
2063 }
2064
2065 plain_len = pw.pw_len;
2066
2067 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2068
2069 uint start = 0;
2070 uint stop = device_param->kernel_params_mp_buf32[4];
2071
2072 memmove (plain_ptr + stop, plain_ptr, plain_len);
2073
2074 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2075
2076 plain_len += start + stop;
2077
2078 crackpos += gidvid;
2079 crackpos *= data.combs_cnt;
2080 crackpos += device_param->innerloop_pos + il_pos;
2081
2082 if (data.pw_max != PW_DICTMAX1)
2083 {
2084 if (plain_len > data.pw_max) plain_len = data.pw_max;
2085 }
2086 }
2087
2088 if (data.attack_mode == ATTACK_MODE_BF)
2089 {
2090 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2091 {
2092 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2093 {
2094 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2095 {
2096 plain_len = plain_len - data.salts_buf[0].salt_len;
2097 }
2098 }
2099
2100 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2101 {
2102 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2103 {
2104 plain_ptr[j] = plain_ptr[i];
2105 }
2106
2107 plain_len = plain_len / 2;
2108 }
2109 }
2110 }
2111
2112 // if enabled, update also the potfile
2113
2114 if (pot_fp)
2115 {
2116 lock_file (pot_fp);
2117
2118 fprintf (pot_fp, "%s:", out_buf);
2119
2120 format_plain (pot_fp, plain_ptr, plain_len, 1);
2121
2122 fputc ('\n', pot_fp);
2123
2124 fflush (pot_fp);
2125
2126 unlock_file (pot_fp);
2127 }
2128
2129 // outfile
2130
2131 FILE *out_fp = NULL;
2132
2133 if (outfile != NULL)
2134 {
2135 if ((out_fp = fopen (outfile, "ab")) == NULL)
2136 {
2137 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2138
2139 out_fp = stdout;
2140 }
2141
2142 lock_file (out_fp);
2143 }
2144 else
2145 {
2146 out_fp = stdout;
2147
2148 if (quiet == 0) clear_prompt ();
2149 }
2150
2151 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2152
2153 if (outfile != NULL)
2154 {
2155 if (out_fp != stdout)
2156 {
2157 fclose (out_fp);
2158 }
2159 }
2160 else
2161 {
2162 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2163 {
2164 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2165 {
2166 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2167 if (quiet == 0) fflush (stdout);
2168 }
2169 }
2170 }
2171
2172 // loopback
2173
2174 if (loopback)
2175 {
2176 char *loopback_file = data.loopback_file;
2177
2178 FILE *fb_fp = NULL;
2179
2180 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2181 {
2182 lock_file (fb_fp);
2183
2184 format_plain (fb_fp, plain_ptr, plain_len, 1);
2185
2186 fputc ('\n', fb_fp);
2187
2188 fclose (fb_fp);
2189 }
2190 }
2191
2192 // (rule) debug mode
2193
2194 // the next check implies that:
2195 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2196 // - debug_mode > 0
2197
2198 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2199 {
2200 if (debug_rule_len < 0) debug_rule_len = 0;
2201
2202 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2203
2204 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2205
2206 if ((quiet == 0) && (debug_file == NULL))
2207 {
2208 fprintf (stdout, "%s", PROMPT);
2209
2210 fflush (stdout);
2211 }
2212 }
2213 }
2214
2215 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2216 {
2217 salt_t *salt_buf = &data.salts_buf[salt_pos];
2218
2219 u32 num_cracked;
2220
2221 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2222
2223 if (num_cracked)
2224 {
2225 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2226
2227 log_info_nn ("");
2228
2229 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2230
2231 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);
2232
2233 uint cpt_cracked = 0;
2234
2235 for (uint i = 0; i < num_cracked; i++)
2236 {
2237 const uint hash_pos = cracked[i].hash_pos;
2238
2239 if (data.digests_shown[hash_pos] == 1) continue;
2240
2241 hc_thread_mutex_lock (mux_display);
2242
2243 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2244 {
2245 data.digests_shown[hash_pos] = 1;
2246
2247 data.digests_done++;
2248
2249 cpt_cracked++;
2250
2251 salt_buf->digests_done++;
2252
2253 if (salt_buf->digests_done == salt_buf->digests_cnt)
2254 {
2255 data.salts_shown[salt_pos] = 1;
2256
2257 data.salts_done++;
2258 }
2259 }
2260
2261 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2262
2263 hc_thread_mutex_unlock (mux_display);
2264
2265 check_hash (device_param, &cracked[i]);
2266 }
2267
2268 myfree (cracked);
2269
2270 if (cpt_cracked > 0)
2271 {
2272 hc_thread_mutex_lock (mux_display);
2273
2274 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2275 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2276
2277 data.cpt_pos++;
2278
2279 data.cpt_total += cpt_cracked;
2280
2281 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2282
2283 hc_thread_mutex_unlock (mux_display);
2284 }
2285
2286 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2287 {
2288 // we need to reset cracked state on the device
2289 // otherwise host thinks again and again the hash was cracked
2290 // and returns invalid password each time
2291
2292 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2293
2294 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);
2295 }
2296
2297 num_cracked = 0;
2298
2299 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2300 }
2301 }
2302
2303 static void save_hash ()
2304 {
2305 char *hashfile = data.hashfile;
2306
2307 char new_hashfile[256] = { 0 };
2308 char old_hashfile[256] = { 0 };
2309
2310 snprintf (new_hashfile, 255, "%s.new", hashfile);
2311 snprintf (old_hashfile, 255, "%s.old", hashfile);
2312
2313 unlink (new_hashfile);
2314
2315 char separator = data.separator;
2316
2317 FILE *fp = fopen (new_hashfile, "wb");
2318
2319 if (fp == NULL)
2320 {
2321 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2322
2323 exit (-1);
2324 }
2325
2326 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2327 {
2328 if (data.salts_shown[salt_pos] == 1) continue;
2329
2330 salt_t *salt_buf = &data.salts_buf[salt_pos];
2331
2332 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2333 {
2334 uint idx = salt_buf->digests_offset + digest_pos;
2335
2336 if (data.digests_shown[idx] == 1) continue;
2337
2338 if (data.hash_mode != 2500)
2339 {
2340 char out_buf[HCBUFSIZ] = { 0 };
2341
2342 if (data.username == 1)
2343 {
2344 user_t *user = data.hash_info[idx]->user;
2345
2346 uint i;
2347
2348 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2349
2350 fputc (separator, fp);
2351 }
2352
2353 ascii_digest (out_buf, salt_pos, digest_pos);
2354
2355 fputs (out_buf, fp);
2356
2357 log_out (fp, "");
2358 }
2359 else
2360 {
2361 hccap_t hccap;
2362
2363 to_hccap_t (&hccap, salt_pos, digest_pos);
2364
2365 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2366 }
2367 }
2368 }
2369
2370 fflush (fp);
2371
2372 fclose (fp);
2373
2374 unlink (old_hashfile);
2375
2376 if (rename (hashfile, old_hashfile) != 0)
2377 {
2378 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2379
2380 exit (-1);
2381 }
2382
2383 unlink (hashfile);
2384
2385 if (rename (new_hashfile, hashfile) != 0)
2386 {
2387 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2388
2389 exit (-1);
2390 }
2391
2392 unlink (old_hashfile);
2393 }
2394
2395 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2396 {
2397 // function called only in case kernel_power_all > words_left
2398
2399 float kernel_power_div = (float) (total_left) / kernel_power_all;
2400
2401 kernel_power_div += kernel_power_div / 100;
2402
2403 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2404
2405 while (kernel_power_new < total_left)
2406 {
2407 kernel_power_div += kernel_power_div / 100;
2408
2409 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2410 }
2411
2412 if (data.quiet == 0)
2413 {
2414 clear_prompt ();
2415
2416 //log_info ("");
2417
2418 log_info ("INFO: approaching final keyspace, workload adjusted");
2419 log_info ("");
2420
2421 fprintf (stdout, "%s", PROMPT);
2422
2423 fflush (stdout);
2424 }
2425
2426 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2427
2428 return kernel_power_div;
2429 }
2430
2431 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2432 {
2433 uint num_elements = num;
2434
2435 device_param->kernel_params_buf32[30] = data.combs_mode;
2436 device_param->kernel_params_buf32[31] = num;
2437
2438 uint kernel_threads = device_param->kernel_threads;
2439
2440 while (num_elements % kernel_threads) num_elements++;
2441
2442 cl_kernel kernel = NULL;
2443
2444 switch (kern_run)
2445 {
2446 case KERN_RUN_1: kernel = device_param->kernel1; break;
2447 case KERN_RUN_12: kernel = device_param->kernel12; break;
2448 case KERN_RUN_2: kernel = device_param->kernel2; break;
2449 case KERN_RUN_23: kernel = device_param->kernel23; break;
2450 case KERN_RUN_3: kernel = device_param->kernel3; break;
2451 }
2452
2453 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2454 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2455 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2456 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2457 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2458 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2459 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2460 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2461 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2462 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2463 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2464
2465 cl_event event;
2466
2467 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2468 {
2469 const size_t global_work_size[3] = { num_elements, 32, 1 };
2470 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2471
2472 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2473 }
2474 else
2475 {
2476 if (kern_run == KERN_RUN_2)
2477 {
2478 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2479 {
2480 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2481 }
2482 }
2483
2484 while (num_elements % kernel_threads) num_elements++;
2485
2486 const size_t global_work_size[3] = { num_elements, 1, 1 };
2487 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2488
2489 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2490 }
2491
2492 hc_clFlush (data.ocl, device_param->command_queue);
2493
2494 hc_clWaitForEvents (data.ocl, 1, &event);
2495
2496 if (event_update)
2497 {
2498 cl_ulong time_start;
2499 cl_ulong time_end;
2500
2501 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2502 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2503
2504 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2505
2506 uint exec_pos = device_param->exec_pos;
2507
2508 device_param->exec_ms[exec_pos] = exec_time;
2509
2510 exec_pos++;
2511
2512 if (exec_pos == EXEC_CACHE)
2513 {
2514 exec_pos = 0;
2515 }
2516
2517 device_param->exec_pos = exec_pos;
2518 }
2519
2520 hc_clReleaseEvent (data.ocl, event);
2521
2522 hc_clFinish (data.ocl, device_param->command_queue);
2523 }
2524
2525 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2526 {
2527 uint num_elements = num;
2528
2529 switch (kern_run)
2530 {
2531 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2532 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2533 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2534 }
2535
2536 // causes problems with special threads like in bcrypt
2537 // const uint kernel_threads = device_param->kernel_threads;
2538
2539 uint kernel_threads = device_param->kernel_threads;
2540
2541 while (num_elements % kernel_threads) num_elements++;
2542
2543 cl_kernel kernel = NULL;
2544
2545 switch (kern_run)
2546 {
2547 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2548 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2549 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2550 }
2551
2552 switch (kern_run)
2553 {
2554 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2555 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2556 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2557 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2558 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2559 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2560 break;
2561 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2562 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2563 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2564 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2565 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2566 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2567 break;
2568 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2569 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2570 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2571 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2572 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2573 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2574 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2575 break;
2576 }
2577
2578 const size_t global_work_size[3] = { num_elements, 1, 1 };
2579 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2580
2581 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2582
2583 hc_clFlush (data.ocl, device_param->command_queue);
2584
2585 hc_clFinish (data.ocl, device_param->command_queue);
2586 }
2587
2588 static void run_kernel_tm (hc_device_param_t *device_param)
2589 {
2590 const uint num_elements = 1024; // fixed
2591
2592 uint kernel_threads = 32;
2593
2594 cl_kernel kernel = device_param->kernel_tm;
2595
2596 const size_t global_work_size[3] = { num_elements, 1, 1 };
2597 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2598
2599 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2600
2601 hc_clFlush (data.ocl, device_param->command_queue);
2602
2603 hc_clFinish (data.ocl, device_param->command_queue);
2604 }
2605
2606 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2607 {
2608 uint num_elements = num;
2609
2610 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2611 device_param->kernel_params_amp_buf32[6] = num_elements;
2612
2613 // causes problems with special threads like in bcrypt
2614 // const uint kernel_threads = device_param->kernel_threads;
2615
2616 uint kernel_threads = device_param->kernel_threads;
2617
2618 while (num_elements % kernel_threads) num_elements++;
2619
2620 cl_kernel kernel = device_param->kernel_amp;
2621
2622 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2623 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2624
2625 const size_t global_work_size[3] = { num_elements, 1, 1 };
2626 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2627
2628 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2629
2630 hc_clFlush (data.ocl, device_param->command_queue);
2631
2632 hc_clFinish (data.ocl, device_param->command_queue);
2633 }
2634
2635 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2636 {
2637 const u32 num16d = num / 16;
2638 const u32 num16m = num % 16;
2639
2640 if (num16d)
2641 {
2642 device_param->kernel_params_memset_buf32[1] = value;
2643 device_param->kernel_params_memset_buf32[2] = num16d;
2644
2645 uint kernel_threads = device_param->kernel_threads;
2646
2647 uint num_elements = num16d;
2648
2649 while (num_elements % kernel_threads) num_elements++;
2650
2651 cl_kernel kernel = device_param->kernel_memset;
2652
2653 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2654 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2655 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2656
2657 const size_t global_work_size[3] = { num_elements, 1, 1 };
2658 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2659
2660 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2661
2662 hc_clFlush (data.ocl, device_param->command_queue);
2663
2664 hc_clFinish (data.ocl, device_param->command_queue);
2665 }
2666
2667 if (num16m)
2668 {
2669 u32 tmp[4];
2670
2671 tmp[0] = value;
2672 tmp[1] = value;
2673 tmp[2] = value;
2674 tmp[3] = value;
2675
2676 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2677 }
2678 }
2679
2680 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2681 {
2682 run_kernel_memset (device_param, buf, 0, size);
2683
2684 /*
2685 int rc = -1;
2686
2687 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2688 {
2689 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2690
2691 const cl_uchar zero = 0;
2692
2693 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2694 }
2695
2696 if (rc != 0)
2697 {
2698 // NOTE: clEnqueueFillBuffer () always fails with -59
2699 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2700 // How's that possible, OpenCL 1.2 support is advertised??
2701 // We need to workaround...
2702
2703 #define FILLSZ 0x100000
2704
2705 char *tmp = (char *) mymalloc (FILLSZ);
2706
2707 for (size_t i = 0; i < size; i += FILLSZ)
2708 {
2709 const size_t left = size - i;
2710
2711 const size_t fillsz = MIN (FILLSZ, left);
2712
2713 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2714 }
2715
2716 myfree (tmp);
2717 }
2718 */
2719 }
2720
2721 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)
2722 {
2723 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2724 {
2725 if (attack_mode == ATTACK_MODE_BF)
2726 {
2727 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2728 {
2729 const uint size_tm = 32 * sizeof (bs_word_t);
2730
2731 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2732
2733 run_kernel_tm (device_param);
2734
2735 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);
2736 }
2737 }
2738
2739 if (highest_pw_len < 16)
2740 {
2741 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2742 }
2743 else if (highest_pw_len < 32)
2744 {
2745 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2746 }
2747 else
2748 {
2749 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2750 }
2751 }
2752 else
2753 {
2754 run_kernel_amp (device_param, pws_cnt);
2755
2756 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2757
2758 if (opts_type & OPTS_TYPE_HOOK12)
2759 {
2760 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2761 }
2762
2763 uint iter = salt_buf->salt_iter;
2764
2765 uint loop_step = device_param->kernel_loops;
2766
2767 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2768 {
2769 uint loop_left = iter - loop_pos;
2770
2771 loop_left = MIN (loop_left, loop_step);
2772
2773 device_param->kernel_params_buf32[25] = loop_pos;
2774 device_param->kernel_params_buf32[26] = loop_left;
2775
2776 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2777
2778 if (data.devices_status == STATUS_CRACKED) break;
2779 if (data.devices_status == STATUS_ABORTED) break;
2780 if (data.devices_status == STATUS_QUIT) break;
2781
2782 /**
2783 * speed
2784 */
2785
2786 const float iter_part = (float) (loop_pos + loop_left) / iter;
2787
2788 const u64 perf_sum_all = pws_cnt * iter_part;
2789
2790 double speed_ms;
2791
2792 hc_timer_get (device_param->timer_speed, speed_ms);
2793
2794 const u32 speed_pos = device_param->speed_pos;
2795
2796 device_param->speed_cnt[speed_pos] = perf_sum_all;
2797
2798 device_param->speed_ms[speed_pos] = speed_ms;
2799
2800 if (data.benchmark == 1)
2801 {
2802 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2803 }
2804 }
2805
2806 if (opts_type & OPTS_TYPE_HOOK23)
2807 {
2808 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2809
2810 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);
2811
2812 // do something with data
2813
2814 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);
2815 }
2816
2817 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2818 }
2819 }
2820
2821 static int run_rule_engine (const int rule_len, const char *rule_buf)
2822 {
2823 if (rule_len == 0)
2824 {
2825 return 0;
2826 }
2827 else if (rule_len == 1)
2828 {
2829 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2830 }
2831
2832 return 1;
2833 }
2834
2835 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2836 {
2837 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2838 {
2839 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);
2840 }
2841 else if (data.attack_kern == ATTACK_KERN_COMBI)
2842 {
2843 if (data.attack_mode == ATTACK_MODE_COMBI)
2844 {
2845 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2846 {
2847 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2848 {
2849 for (u32 i = 0; i < pws_cnt; i++)
2850 {
2851 const u32 pw_len = device_param->pws_buf[i].pw_len;
2852
2853 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2854
2855 ptr[pw_len] = 0x01;
2856 }
2857 }
2858 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2859 {
2860 for (u32 i = 0; i < pws_cnt; i++)
2861 {
2862 const u32 pw_len = device_param->pws_buf[i].pw_len;
2863
2864 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2865
2866 ptr[pw_len] = 0x80;
2867 }
2868 }
2869 }
2870 }
2871 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2872 {
2873 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2874 {
2875 for (u32 i = 0; i < pws_cnt; i++)
2876 {
2877 const u32 pw_len = device_param->pws_buf[i].pw_len;
2878
2879 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2880
2881 ptr[pw_len] = 0x01;
2882 }
2883 }
2884 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2885 {
2886 for (u32 i = 0; i < pws_cnt; i++)
2887 {
2888 const u32 pw_len = device_param->pws_buf[i].pw_len;
2889
2890 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2891
2892 ptr[pw_len] = 0x80;
2893 }
2894 }
2895 }
2896
2897 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);
2898 }
2899 else if (data.attack_kern == ATTACK_KERN_BF)
2900 {
2901 const u64 off = device_param->words_off;
2902
2903 device_param->kernel_params_mp_l_buf64[3] = off;
2904
2905 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2906 }
2907 }
2908
2909 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2910 {
2911 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2912
2913 device_param->kernel_params_buf32[25] = 0;
2914 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2915 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2916
2917 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2918 {
2919 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2920 }
2921 else
2922 {
2923 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2924 }
2925
2926 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2927
2928 return exec_ms_prev;
2929 }
2930
2931 static void autotune (hc_device_param_t *device_param)
2932 {
2933 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2934
2935 const u32 kernel_accel_min = device_param->kernel_accel_min;
2936 const u32 kernel_accel_max = device_param->kernel_accel_max;
2937
2938 const u32 kernel_loops_min = device_param->kernel_loops_min;
2939 const u32 kernel_loops_max = device_param->kernel_loops_max;
2940
2941 u32 kernel_accel = kernel_accel_min;
2942 u32 kernel_loops = kernel_loops_min;
2943
2944 // in this case the user specified a fixed -u and -n on the commandline
2945 // no way to tune anything
2946 // but we need to run a few caching rounds
2947
2948 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2949 {
2950 try_run (device_param, kernel_accel, kernel_loops);
2951 try_run (device_param, kernel_accel, kernel_loops);
2952 try_run (device_param, kernel_accel, kernel_loops);
2953 try_run (device_param, kernel_accel, kernel_loops);
2954
2955 device_param->kernel_accel = kernel_accel;
2956 device_param->kernel_loops = kernel_loops;
2957
2958 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2959
2960 device_param->kernel_power = kernel_power;
2961
2962 return;
2963 }
2964
2965 // from here it's clear we are allowed to autotune
2966 // so let's init some fake words
2967
2968 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2969
2970 if (data.attack_kern == ATTACK_KERN_BF)
2971 {
2972 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2973 }
2974 else
2975 {
2976 for (u32 i = 0; i < kernel_power_max; i++)
2977 {
2978 device_param->pws_buf[i].i[0] = i;
2979 device_param->pws_buf[i].i[1] = 0x01234567;
2980 device_param->pws_buf[i].pw_len = 7 + (i & 7);
2981 }
2982
2983 if (data.kernel_rules_cnt > 1)
2984 {
2985 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, kernel_loops_max * sizeof (kernel_rule_t), 0, NULL, NULL);
2986 }
2987
2988 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);
2989 }
2990
2991 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2992 {
2993 run_kernel_amp (device_param, kernel_power_max);
2994 }
2995
2996 #define VERIFIER_CNT 1
2997
2998 // first find out highest kernel-loops that stays below target_ms
2999
3000 if (kernel_loops_min < kernel_loops_max)
3001 {
3002 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3003 {
3004 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3005
3006 for (int i = 0; i < VERIFIER_CNT; i++)
3007 {
3008 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3009
3010 exec_ms = MIN (exec_ms, exec_ms_v);
3011 }
3012
3013 if (exec_ms < target_ms) break;
3014 }
3015 }
3016
3017 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3018
3019 #define STEPS_CNT 10
3020
3021 if (kernel_accel_min < kernel_accel_max)
3022 {
3023 for (int i = 0; i < STEPS_CNT; i++)
3024 {
3025 const u32 kernel_accel_try = 1 << i;
3026
3027 if (kernel_accel_try < kernel_accel_min) continue;
3028 if (kernel_accel_try > kernel_accel_max) break;
3029
3030 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3031
3032 for (int i = 0; i < VERIFIER_CNT; i++)
3033 {
3034 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3035
3036 exec_ms = MIN (exec_ms, exec_ms_v);
3037 }
3038
3039 if (exec_ms > target_ms) break;
3040
3041 kernel_accel = kernel_accel_try;
3042 }
3043 }
3044
3045 // at this point we want to know the actual runtime for the following reason:
3046 // we need a reference for the balancing loop following up, and this
3047 // the balancing loop can have an effect that the creates a new opportunity, for example:
3048 // if the target is 95 ms and the current runtime is 48ms the above loop
3049 // stopped the execution because the previous exec_ms was > 95ms
3050 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3051 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3052
3053 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3054
3055 for (int i = 0; i < VERIFIER_CNT; i++)
3056 {
3057 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3058
3059 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3060 }
3061
3062 u32 diff = kernel_loops - kernel_accel;
3063
3064 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3065 {
3066 u32 kernel_accel_orig = kernel_accel;
3067 u32 kernel_loops_orig = kernel_loops;
3068
3069 for (u32 f = 1; f < 1024; f++)
3070 {
3071 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3072 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3073
3074 if (kernel_accel_try > kernel_accel_max) break;
3075 if (kernel_loops_try < kernel_loops_min) break;
3076
3077 u32 diff_new = kernel_loops_try - kernel_accel_try;
3078
3079 if (diff_new > diff) break;
3080
3081 diff_new = diff;
3082
3083 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3084
3085 for (int i = 0; i < VERIFIER_CNT; i++)
3086 {
3087 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3088
3089 exec_ms = MIN (exec_ms, exec_ms_v);
3090 }
3091
3092 if (exec_ms < exec_ms_pre_final)
3093 {
3094 exec_ms_pre_final = exec_ms;
3095
3096 kernel_accel = kernel_accel_try;
3097 kernel_loops = kernel_loops_try;
3098 }
3099 }
3100 }
3101
3102 const double exec_left = target_ms / exec_ms_pre_final;
3103
3104 const double accel_left = kernel_accel_max / kernel_accel;
3105
3106 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3107
3108 if (exec_accel_min >= 1.0)
3109 {
3110 // this is safe to not overflow kernel_accel_max because of accel_left
3111
3112 kernel_accel = (double) kernel_accel * exec_accel_min;
3113 }
3114
3115 // reset them fake words
3116
3117 /*
3118 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3119
3120 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);
3121 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);
3122 */
3123
3124 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3125
3126 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3127 {
3128 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3129 }
3130
3131 // reset timer
3132
3133 device_param->exec_pos = 0;
3134
3135 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3136
3137 // store
3138
3139 device_param->kernel_accel = kernel_accel;
3140 device_param->kernel_loops = kernel_loops;
3141
3142 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3143
3144 device_param->kernel_power = kernel_power;
3145
3146 #ifdef DEBUG
3147
3148 if (data.quiet == 0)
3149 {
3150 clear_prompt ();
3151
3152 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3153 "Device #%u: autotuned kernel-loops to %u\n",
3154 device_param->device_id + 1, kernel_accel,
3155 device_param->device_id + 1, kernel_loops);
3156
3157 fprintf (stdout, "%s", PROMPT);
3158
3159 fflush (stdout);
3160 }
3161
3162 #endif
3163 }
3164
3165 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3166 {
3167 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3168
3169 // init speed timer
3170
3171 uint speed_pos = device_param->speed_pos;
3172
3173 #ifdef _POSIX
3174 if (device_param->timer_speed.tv_sec == 0)
3175 {
3176 hc_timer_set (&device_param->timer_speed);
3177 }
3178 #endif
3179
3180 #ifdef _WIN
3181 if (device_param->timer_speed.QuadPart == 0)
3182 {
3183 hc_timer_set (&device_param->timer_speed);
3184 }
3185 #endif
3186
3187 // find higest password length, this is for optimization stuff
3188
3189 uint highest_pw_len = 0;
3190
3191 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3192 {
3193 }
3194 else if (data.attack_kern == ATTACK_KERN_COMBI)
3195 {
3196 }
3197 else if (data.attack_kern == ATTACK_KERN_BF)
3198 {
3199 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3200 + device_param->kernel_params_mp_l_buf32[5];
3201 }
3202
3203 // iteration type
3204
3205 uint innerloop_step = 0;
3206 uint innerloop_cnt = 0;
3207
3208 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3209 else innerloop_step = 1;
3210
3211 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3212 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3213 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3214
3215 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3216
3217 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3218 {
3219 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3220
3221 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3222
3223 if (data.devices_status == STATUS_CRACKED) break;
3224 if (data.devices_status == STATUS_ABORTED) break;
3225 if (data.devices_status == STATUS_QUIT) break;
3226 if (data.devices_status == STATUS_BYPASS) break;
3227
3228 salt_t *salt_buf = &data.salts_buf[salt_pos];
3229
3230 device_param->kernel_params_buf32[24] = salt_pos;
3231 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3232 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3233
3234 FILE *combs_fp = device_param->combs_fp;
3235
3236 if (data.attack_mode == ATTACK_MODE_COMBI)
3237 {
3238 rewind (combs_fp);
3239 }
3240
3241 // innerloops
3242
3243 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3244 {
3245 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3246
3247 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3248
3249 if (data.devices_status == STATUS_CRACKED) break;
3250 if (data.devices_status == STATUS_ABORTED) break;
3251 if (data.devices_status == STATUS_QUIT) break;
3252 if (data.devices_status == STATUS_BYPASS) break;
3253
3254 uint innerloop_left = innerloop_cnt - innerloop_pos;
3255
3256 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3257
3258 device_param->innerloop_pos = innerloop_pos;
3259 device_param->innerloop_left = innerloop_left;
3260
3261 device_param->kernel_params_buf32[27] = innerloop_left;
3262
3263 // i think we can get rid of this
3264 if (innerloop_left == 0)
3265 {
3266 puts ("bug, how should this happen????\n");
3267
3268 continue;
3269 }
3270
3271 if (data.salts_shown[salt_pos] == 1)
3272 {
3273 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3274
3275 continue;
3276 }
3277
3278 // initialize amplifiers
3279
3280 if (data.attack_mode == ATTACK_MODE_COMBI)
3281 {
3282 uint i = 0;
3283
3284 while (i < innerloop_left)
3285 {
3286 if (feof (combs_fp)) break;
3287
3288 int line_len = fgetl (combs_fp, line_buf);
3289
3290 if (line_len >= PW_MAX1) continue;
3291
3292 line_len = convert_from_hex (line_buf, line_len);
3293
3294 char *line_buf_new = line_buf;
3295
3296 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3297 {
3298 char rule_buf_out[BLOCK_SIZE] = { 0 };
3299
3300 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3301
3302 if (rule_len_out < 0)
3303 {
3304 data.words_progress_rejected[salt_pos] += pws_cnt;
3305
3306 continue;
3307 }
3308
3309 line_len = rule_len_out;
3310
3311 line_buf_new = rule_buf_out;
3312 }
3313
3314 line_len = MIN (line_len, PW_DICTMAX);
3315
3316 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3317
3318 memcpy (ptr, line_buf_new, line_len);
3319
3320 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3321
3322 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3323 {
3324 uppercase (ptr, line_len);
3325 }
3326
3327 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3328 {
3329 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3330 {
3331 ptr[line_len] = 0x80;
3332 }
3333
3334 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3335 {
3336 ptr[line_len] = 0x01;
3337 }
3338 }
3339
3340 device_param->combs_buf[i].pw_len = line_len;
3341
3342 i++;
3343 }
3344
3345 for (uint j = i; j < innerloop_left; j++)
3346 {
3347 device_param->combs_buf[j].i[0] = 0;
3348 device_param->combs_buf[j].i[1] = 0;
3349 device_param->combs_buf[j].i[2] = 0;
3350 device_param->combs_buf[j].i[3] = 0;
3351 device_param->combs_buf[j].i[4] = 0;
3352 device_param->combs_buf[j].i[5] = 0;
3353 device_param->combs_buf[j].i[6] = 0;
3354 device_param->combs_buf[j].i[7] = 0;
3355
3356 device_param->combs_buf[j].pw_len = 0;
3357 }
3358
3359 innerloop_left = i;
3360 }
3361 else if (data.attack_mode == ATTACK_MODE_BF)
3362 {
3363 u64 off = innerloop_pos;
3364
3365 device_param->kernel_params_mp_r_buf64[3] = off;
3366
3367 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3368 }
3369 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3370 {
3371 u64 off = innerloop_pos;
3372
3373 device_param->kernel_params_mp_buf64[3] = off;
3374
3375 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3376 }
3377 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3378 {
3379 u64 off = innerloop_pos;
3380
3381 device_param->kernel_params_mp_buf64[3] = off;
3382
3383 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3384 }
3385
3386 // copy amplifiers
3387
3388 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3389 {
3390 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);
3391 }
3392 else if (data.attack_mode == ATTACK_MODE_COMBI)
3393 {
3394 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);
3395 }
3396 else if (data.attack_mode == ATTACK_MODE_BF)
3397 {
3398 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);
3399 }
3400 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3401 {
3402 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);
3403 }
3404 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3405 {
3406 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);
3407 }
3408
3409 if (data.benchmark == 1)
3410 {
3411 hc_timer_set (&device_param->timer_speed);
3412 }
3413
3414 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3415
3416 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3417
3418 if (data.devices_status == STATUS_CRACKED) break;
3419 if (data.devices_status == STATUS_ABORTED) break;
3420 if (data.devices_status == STATUS_QUIT) break;
3421
3422 /**
3423 * result
3424 */
3425
3426 check_cracked (device_param, salt_pos);
3427
3428 /**
3429 * progress
3430 */
3431
3432 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3433
3434 hc_thread_mutex_lock (mux_counter);
3435
3436 data.words_progress_done[salt_pos] += perf_sum_all;
3437
3438 hc_thread_mutex_unlock (mux_counter);
3439
3440 /**
3441 * speed
3442 */
3443
3444 double speed_ms;
3445
3446 hc_timer_get (device_param->timer_speed, speed_ms);
3447
3448 hc_timer_set (&device_param->timer_speed);
3449
3450 // current speed
3451
3452 //hc_thread_mutex_lock (mux_display);
3453
3454 device_param->speed_cnt[speed_pos] = perf_sum_all;
3455
3456 device_param->speed_ms[speed_pos] = speed_ms;
3457
3458 //hc_thread_mutex_unlock (mux_display);
3459
3460 speed_pos++;
3461
3462 if (speed_pos == SPEED_CACHE)
3463 {
3464 speed_pos = 0;
3465 }
3466
3467 /**
3468 * benchmark
3469 */
3470
3471 if (data.benchmark == 1) break;
3472 }
3473 }
3474
3475 device_param->speed_pos = speed_pos;
3476
3477 myfree (line_buf);
3478 }
3479
3480 static void load_segment (wl_data_t *wl_data, FILE *fd)
3481 {
3482 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3483
3484 wl_data->pos = 0;
3485
3486 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3487
3488 wl_data->buf[wl_data->cnt] = 0;
3489
3490 if (wl_data->cnt == 0) return;
3491
3492 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3493
3494 while (!feof (fd))
3495 {
3496 if (wl_data->cnt == wl_data->avail)
3497 {
3498 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3499
3500 wl_data->avail += wl_data->incr;
3501 }
3502
3503 const int c = fgetc (fd);
3504
3505 if (c == EOF) break;
3506
3507 wl_data->buf[wl_data->cnt] = (char) c;
3508
3509 wl_data->cnt++;
3510
3511 if (c == '\n') break;
3512 }
3513
3514 // ensure stream ends with a newline
3515
3516 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3517 {
3518 wl_data->cnt++;
3519
3520 wl_data->buf[wl_data->cnt - 1] = '\n';
3521 }
3522
3523 return;
3524 }
3525
3526 static void get_next_word_lm (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 >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3533
3534 if (i == 7)
3535 {
3536 *off = i;
3537 *len = i;
3538
3539 return;
3540 }
3541
3542 if (*ptr != '\n') continue;
3543
3544 *off = i + 1;
3545
3546 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3547
3548 *len = i;
3549
3550 return;
3551 }
3552
3553 *off = sz;
3554 *len = sz;
3555 }
3556
3557 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3558 {
3559 char *ptr = buf;
3560
3561 for (u32 i = 0; i < sz; i++, ptr++)
3562 {
3563 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3564
3565 if (*ptr != '\n') continue;
3566
3567 *off = i + 1;
3568
3569 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3570
3571 *len = i;
3572
3573 return;
3574 }
3575
3576 *off = sz;
3577 *len = sz;
3578 }
3579
3580 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3581 {
3582 char *ptr = buf;
3583
3584 for (u32 i = 0; i < sz; i++, ptr++)
3585 {
3586 if (*ptr != '\n') continue;
3587
3588 *off = i + 1;
3589
3590 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3591
3592 *len = i;
3593
3594 return;
3595 }
3596
3597 *off = sz;
3598 *len = sz;
3599 }
3600
3601 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3602 {
3603 while (wl_data->pos < wl_data->cnt)
3604 {
3605 uint off;
3606 uint len;
3607
3608 char *ptr = wl_data->buf + wl_data->pos;
3609
3610 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3611
3612 wl_data->pos += off;
3613
3614 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3615 {
3616 char rule_buf_out[BLOCK_SIZE] = { 0 };
3617
3618 int rule_len_out = -1;
3619
3620 if (len < BLOCK_SIZE)
3621 {
3622 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3623 }
3624
3625 if (rule_len_out < 0)
3626 {
3627 continue;
3628 }
3629
3630 if (rule_len_out > PW_MAX)
3631 {
3632 continue;
3633 }
3634 }
3635 else
3636 {
3637 if (len > PW_MAX)
3638 {
3639 continue;
3640 }
3641 }
3642
3643 *out_buf = ptr;
3644 *out_len = len;
3645
3646 return;
3647 }
3648
3649 if (feof (fd))
3650 {
3651 fprintf (stderr, "BUG feof()!!\n");
3652
3653 return;
3654 }
3655
3656 load_segment (wl_data, fd);
3657
3658 get_next_word (wl_data, fd, out_buf, out_len);
3659 }
3660
3661 #ifdef _POSIX
3662 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3663 #endif
3664
3665 #ifdef _WIN
3666 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3667 #endif
3668 {
3669 hc_signal (NULL);
3670
3671 dictstat_t d;
3672
3673 d.cnt = 0;
3674
3675 #ifdef _POSIX
3676 fstat (fileno (fd), &d.stat);
3677 #endif
3678
3679 #ifdef _WIN
3680 _fstat64 (fileno (fd), &d.stat);
3681 #endif
3682
3683 d.stat.st_mode = 0;
3684 d.stat.st_nlink = 0;
3685 d.stat.st_uid = 0;
3686 d.stat.st_gid = 0;
3687 d.stat.st_rdev = 0;
3688 d.stat.st_atime = 0;
3689
3690 #ifdef _POSIX
3691 d.stat.st_blksize = 0;
3692 d.stat.st_blocks = 0;
3693 #endif
3694
3695 if (d.stat.st_size == 0) return 0;
3696
3697 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3698
3699 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3700 {
3701 if (d_cache)
3702 {
3703 u64 cnt = d_cache->cnt;
3704
3705 u64 keyspace = cnt;
3706
3707 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3708 {
3709 keyspace *= data.kernel_rules_cnt;
3710 }
3711 else if (data.attack_kern == ATTACK_KERN_COMBI)
3712 {
3713 keyspace *= data.combs_cnt;
3714 }
3715
3716 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);
3717 if (data.quiet == 0) log_info ("");
3718
3719 hc_signal (sigHandler_default);
3720
3721 return (keyspace);
3722 }
3723 }
3724
3725 time_t now = 0;
3726 time_t prev = 0;
3727
3728 u64 comp = 0;
3729 u64 cnt = 0;
3730 u64 cnt2 = 0;
3731
3732 while (!feof (fd))
3733 {
3734 load_segment (wl_data, fd);
3735
3736 comp += wl_data->cnt;
3737
3738 u32 i = 0;
3739
3740 while (i < wl_data->cnt)
3741 {
3742 u32 len;
3743 u32 off;
3744
3745 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3746
3747 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3748 {
3749 char rule_buf_out[BLOCK_SIZE] = { 0 };
3750
3751 int rule_len_out = -1;
3752
3753 if (len < BLOCK_SIZE)
3754 {
3755 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3756 }
3757
3758 if (rule_len_out < 0)
3759 {
3760 len = PW_MAX1;
3761 }
3762 else
3763 {
3764 len = rule_len_out;
3765 }
3766 }
3767
3768 if (len < PW_MAX1)
3769 {
3770 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3771 {
3772 cnt += data.kernel_rules_cnt;
3773 }
3774 else if (data.attack_kern == ATTACK_KERN_COMBI)
3775 {
3776 cnt += data.combs_cnt;
3777 }
3778
3779 d.cnt++;
3780 }
3781
3782 i += off;
3783
3784 cnt2++;
3785 }
3786
3787 time (&now);
3788
3789 if ((now - prev) == 0) continue;
3790
3791 float percent = (float) comp / (float) d.stat.st_size;
3792
3793 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);
3794
3795 time (&prev);
3796 }
3797
3798 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);
3799 if (data.quiet == 0) log_info ("");
3800
3801 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3802
3803 hc_signal (sigHandler_default);
3804
3805 return (cnt);
3806 }
3807
3808 static void *thread_monitor (void *p)
3809 {
3810 uint runtime_check = 0;
3811 uint remove_check = 0;
3812 uint status_check = 0;
3813 uint restore_check = 0;
3814
3815 uint restore_left = data.restore_timer;
3816 uint remove_left = data.remove_timer;
3817 uint status_left = data.status_timer;
3818
3819 #ifdef HAVE_HWMON
3820 uint hwmon_check = 0;
3821
3822 int slowdown_warnings = 0;
3823
3824 // these variables are mainly used for fan control
3825
3826 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3827
3828 // temperature controller "loopback" values
3829
3830 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3831 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3832
3833 int temp_threshold = 1; // degrees celcius
3834
3835 int fan_speed_min = 15; // in percentage
3836 int fan_speed_max = 100;
3837
3838 time_t last_temp_check_time;
3839 #endif // HAVE_HWMON
3840
3841 uint sleep_time = 1;
3842
3843 if (data.runtime)
3844 {
3845 runtime_check = 1;
3846 }
3847
3848 if (data.restore_timer)
3849 {
3850 restore_check = 1;
3851 }
3852
3853 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3854 {
3855 remove_check = 1;
3856 }
3857
3858 if (data.status == 1)
3859 {
3860 status_check = 1;
3861 }
3862
3863 #ifdef HAVE_HWMON
3864 if (data.gpu_temp_disable == 0)
3865 {
3866 time (&last_temp_check_time);
3867
3868 hwmon_check = 1;
3869 }
3870 #endif
3871
3872 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3873 {
3874 #ifdef HAVE_HWMON
3875 if (hwmon_check == 0)
3876 #endif
3877 return (p);
3878 }
3879
3880 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3881 {
3882 hc_sleep (sleep_time);
3883
3884 if (data.devices_status != STATUS_RUNNING) continue;
3885
3886 #ifdef HAVE_HWMON
3887
3888 if (1)
3889 {
3890 hc_thread_mutex_lock (mux_adl);
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 const int threshold = data.hm_device[device_id].gpu_temp_threshold_slowdown;
3903
3904 if (temperature >= threshold)
3905 {
3906 if (slowdown_warnings < 3)
3907 {
3908 if (data.quiet == 0) clear_prompt ();
3909
3910 log_info ("WARNING: Drivers temperature threshold (%dc) hit on GPU #%d, expect performance to drop...", threshold, device_id + 1);
3911
3912 if (slowdown_warnings == 2)
3913 {
3914 log_info ("");
3915 }
3916
3917 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3918 if (data.quiet == 0) fflush (stdout);
3919
3920 slowdown_warnings++;
3921 }
3922 }
3923 else
3924 {
3925 slowdown_warnings = 0;
3926 }
3927 }
3928
3929 hc_thread_mutex_unlock (mux_adl);
3930 }
3931
3932 if (hwmon_check == 1)
3933 {
3934 hc_thread_mutex_lock (mux_adl);
3935
3936 time_t temp_check_time;
3937
3938 time (&temp_check_time);
3939
3940 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3941
3942 if (Ta == 0) Ta = 1;
3943
3944 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3945 {
3946 hc_device_param_t *device_param = &data.devices_param[device_id];
3947
3948 if (device_param->skipped) continue;
3949
3950 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3951
3952 const int temperature = hm_get_temperature_with_device_id (device_id);
3953
3954 if (temperature > (int) data.gpu_temp_abort)
3955 {
3956 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3957
3958 if (data.devices_status != STATUS_QUIT) myabort ();
3959
3960 break;
3961 }
3962
3963 const int gpu_temp_retain = data.gpu_temp_retain;
3964
3965 if (gpu_temp_retain)
3966 {
3967 if (data.hm_device[device_id].fan_set_supported == 1)
3968 {
3969 int temp_cur = temperature;
3970
3971 int temp_diff_new = gpu_temp_retain - temp_cur;
3972
3973 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3974
3975 // calculate Ta value (time difference in seconds between the last check and this check)
3976
3977 last_temp_check_time = temp_check_time;
3978
3979 float Kp = 1.8;
3980 float Ki = 0.005;
3981 float Kd = 6;
3982
3983 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3984
3985 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);
3986
3987 if (abs (fan_diff_required) >= temp_threshold)
3988 {
3989 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3990
3991 int fan_speed_level = fan_speed_cur;
3992
3993 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3994
3995 int fan_speed_new = fan_speed_level - fan_diff_required;
3996
3997 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3998 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3999
4000 if (fan_speed_new != fan_speed_cur)
4001 {
4002 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4003 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4004
4005 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4006 {
4007 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4008 {
4009 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new, 1);
4010 }
4011 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4012 {
4013 #ifdef _WIN
4014 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4015 #endif
4016 }
4017
4018 fan_speed_chgd[device_id] = 1;
4019 }
4020
4021 temp_diff_old[device_id] = temp_diff_new;
4022 }
4023 }
4024 }
4025 }
4026 }
4027
4028 hc_thread_mutex_unlock (mux_adl);
4029 }
4030 #endif // HAVE_HWMON
4031
4032 if (restore_check == 1)
4033 {
4034 restore_left--;
4035
4036 if (restore_left == 0)
4037 {
4038 if (data.restore_disable == 0) cycle_restore ();
4039
4040 restore_left = data.restore_timer;
4041 }
4042 }
4043
4044 if ((runtime_check == 1) && (data.runtime_start > 0))
4045 {
4046 time_t runtime_cur;
4047
4048 time (&runtime_cur);
4049
4050 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4051
4052 if (runtime_left <= 0)
4053 {
4054 if (data.benchmark == 0)
4055 {
4056 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4057 }
4058
4059 if (data.devices_status != STATUS_QUIT) myabort ();
4060 }
4061 }
4062
4063 if (remove_check == 1)
4064 {
4065 remove_left--;
4066
4067 if (remove_left == 0)
4068 {
4069 if (data.digests_saved != data.digests_done)
4070 {
4071 data.digests_saved = data.digests_done;
4072
4073 save_hash ();
4074 }
4075
4076 remove_left = data.remove_timer;
4077 }
4078 }
4079
4080 if (status_check == 1)
4081 {
4082 status_left--;
4083
4084 if (status_left == 0)
4085 {
4086 //hc_thread_mutex_lock (mux_display);
4087
4088 if (data.quiet == 0) clear_prompt ();
4089
4090 if (data.quiet == 0) log_info ("");
4091
4092 status_display ();
4093
4094 if (data.quiet == 0) log_info ("");
4095
4096 //hc_thread_mutex_unlock (mux_display);
4097
4098 status_left = data.status_timer;
4099 }
4100 }
4101 }
4102
4103 #ifdef HAVE_HWMON
4104 myfree (fan_speed_chgd);
4105
4106 myfree (temp_diff_old);
4107 myfree (temp_diff_sum);
4108 #endif
4109
4110 p = NULL;
4111
4112 return (p);
4113 }
4114
4115 static void *thread_outfile_remove (void *p)
4116 {
4117 // some hash-dependent constants
4118 char *outfile_dir = data.outfile_check_directory;
4119 uint dgst_size = data.dgst_size;
4120 uint isSalted = data.isSalted;
4121 uint esalt_size = data.esalt_size;
4122 uint hash_mode = data.hash_mode;
4123
4124 uint outfile_check_timer = data.outfile_check_timer;
4125
4126 char separator = data.separator;
4127
4128 // some hash-dependent functions
4129 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4130 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4131
4132 // buffers
4133 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4134
4135 hash_buf.digest = mymalloc (dgst_size);
4136
4137 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4138
4139 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4140
4141 uint digest_buf[64] = { 0 };
4142
4143 outfile_data_t *out_info = NULL;
4144
4145 char **out_files = NULL;
4146
4147 time_t folder_mtime = 0;
4148
4149 int out_cnt = 0;
4150
4151 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4152
4153 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4154 {
4155 hc_sleep (1);
4156
4157 if (data.devices_status != STATUS_RUNNING) continue;
4158
4159 check_left--;
4160
4161 if (check_left == 0)
4162 {
4163 struct stat outfile_check_stat;
4164
4165 if (stat (outfile_dir, &outfile_check_stat) == 0)
4166 {
4167 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4168
4169 if (is_dir == 1)
4170 {
4171 if (outfile_check_stat.st_mtime > folder_mtime)
4172 {
4173 char **out_files_new = scan_directory (outfile_dir);
4174
4175 int out_cnt_new = count_dictionaries (out_files_new);
4176
4177 outfile_data_t *out_info_new = NULL;
4178
4179 if (out_cnt_new > 0)
4180 {
4181 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4182
4183 for (int i = 0; i < out_cnt_new; i++)
4184 {
4185 out_info_new[i].file_name = out_files_new[i];
4186
4187 // check if there are files that we have seen/checked before (and not changed)
4188
4189 for (int j = 0; j < out_cnt; j++)
4190 {
4191 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4192 {
4193 struct stat outfile_stat;
4194
4195 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4196 {
4197 if (outfile_stat.st_ctime == out_info[j].ctime)
4198 {
4199 out_info_new[i].ctime = out_info[j].ctime;
4200 out_info_new[i].seek = out_info[j].seek;
4201 }
4202 }
4203 }
4204 }
4205 }
4206 }
4207
4208 local_free (out_info);
4209 local_free (out_files);
4210
4211 out_files = out_files_new;
4212 out_cnt = out_cnt_new;
4213 out_info = out_info_new;
4214
4215 folder_mtime = outfile_check_stat.st_mtime;
4216 }
4217
4218 for (int j = 0; j < out_cnt; j++)
4219 {
4220 FILE *fp = fopen (out_info[j].file_name, "rb");
4221
4222 if (fp != NULL)
4223 {
4224 //hc_thread_mutex_lock (mux_display);
4225
4226 #ifdef _POSIX
4227 struct stat outfile_stat;
4228
4229 fstat (fileno (fp), &outfile_stat);
4230 #endif
4231
4232 #ifdef _WIN
4233 struct stat64 outfile_stat;
4234
4235 _fstat64 (fileno (fp), &outfile_stat);
4236 #endif
4237
4238 if (outfile_stat.st_ctime > out_info[j].ctime)
4239 {
4240 out_info[j].ctime = outfile_stat.st_ctime;
4241 out_info[j].seek = 0;
4242 }
4243
4244 fseek (fp, out_info[j].seek, SEEK_SET);
4245
4246 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4247
4248 while (!feof (fp))
4249 {
4250 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4251
4252 if (ptr == NULL) break;
4253
4254 int line_len = strlen (line_buf);
4255
4256 if (line_len <= 0) continue;
4257
4258 int iter = MAX_CUT_TRIES;
4259
4260 for (uint i = line_len - 1; i && iter; i--, line_len--)
4261 {
4262 if (line_buf[i] != separator) continue;
4263
4264 int parser_status = PARSER_OK;
4265
4266 if ((hash_mode != 2500) && (hash_mode != 6800))
4267 {
4268 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4269 }
4270
4271 uint found = 0;
4272
4273 if (parser_status == PARSER_OK)
4274 {
4275 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4276 {
4277 if (data.salts_shown[salt_pos] == 1) continue;
4278
4279 salt_t *salt_buf = &data.salts_buf[salt_pos];
4280
4281 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4282 {
4283 uint idx = salt_buf->digests_offset + digest_pos;
4284
4285 if (data.digests_shown[idx] == 1) continue;
4286
4287 uint cracked = 0;
4288
4289 if (hash_mode == 6800)
4290 {
4291 if (i == salt_buf->salt_len)
4292 {
4293 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4294 }
4295 }
4296 else if (hash_mode == 2500)
4297 {
4298 // BSSID : MAC1 : MAC2 (:plain)
4299 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4300 {
4301 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4302
4303 if (!cracked) continue;
4304
4305 // now compare MAC1 and MAC2 too, since we have this additional info
4306 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4307 char *mac2_pos = mac1_pos + 12 + 1;
4308
4309 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4310 wpa_t *wpa = &wpas[salt_pos];
4311
4312 // compare hex string(s) vs binary MAC address(es)
4313
4314 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4315 {
4316 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4317 {
4318 cracked = 0;
4319
4320 break;
4321 }
4322 }
4323
4324 // early skip ;)
4325 if (!cracked) continue;
4326
4327 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4328 {
4329 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4330 {
4331 cracked = 0;
4332
4333 break;
4334 }
4335 }
4336 }
4337 }
4338 else
4339 {
4340 char *digests_buf_ptr = (char *) data.digests_buf;
4341
4342 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4343
4344 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4345 }
4346
4347 if (cracked == 1)
4348 {
4349 found = 1;
4350
4351 data.digests_shown[idx] = 1;
4352
4353 data.digests_done++;
4354
4355 salt_buf->digests_done++;
4356
4357 if (salt_buf->digests_done == salt_buf->digests_cnt)
4358 {
4359 data.salts_shown[salt_pos] = 1;
4360
4361 data.salts_done++;
4362
4363 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4364 }
4365 }
4366 }
4367
4368 if (data.devices_status == STATUS_CRACKED) break;
4369 }
4370 }
4371
4372 if (found) break;
4373
4374 if (data.devices_status == STATUS_CRACKED) break;
4375
4376 iter--;
4377 }
4378
4379 if (data.devices_status == STATUS_CRACKED) break;
4380 }
4381
4382 myfree (line_buf);
4383
4384 out_info[j].seek = ftell (fp);
4385
4386 //hc_thread_mutex_unlock (mux_display);
4387
4388 fclose (fp);
4389 }
4390 }
4391 }
4392 }
4393
4394 check_left = outfile_check_timer;
4395 }
4396 }
4397
4398 if (esalt_size) local_free (hash_buf.esalt);
4399
4400 if (isSalted) local_free (hash_buf.salt);
4401
4402 local_free (hash_buf.digest);
4403
4404 local_free (out_info);
4405
4406 local_free (out_files);
4407
4408 p = NULL;
4409
4410 return (p);
4411 }
4412
4413 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4414 {
4415 if (device_param->pws_cnt < device_param->kernel_power)
4416 {
4417 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4418
4419 u8 *ptr = (u8 *) pw->i;
4420
4421 memcpy (ptr, pw_buf, pw_len);
4422
4423 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4424
4425 pw->pw_len = pw_len;
4426
4427 device_param->pws_cnt++;
4428 }
4429 else
4430 {
4431 fprintf (stderr, "BUG pw_add()!!\n");
4432
4433 return;
4434 }
4435 }
4436
4437 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4438 {
4439 hc_thread_mutex_lock (mux_dispatcher);
4440
4441 const u64 words_cur = data.words_cur;
4442 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4443
4444 device_param->words_off = words_cur;
4445
4446 const u64 words_left = words_base - words_cur;
4447
4448 if (allow_div)
4449 {
4450 if (data.kernel_power_all > words_left)
4451 {
4452 if (data.kernel_power_div == 0)
4453 {
4454 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4455 }
4456 }
4457
4458 if (data.kernel_power_div)
4459 {
4460 if (device_param->kernel_power == device_param->kernel_power_user)
4461 {
4462 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4463
4464 if (kernel_power_new < device_param->kernel_power)
4465 {
4466 device_param->kernel_power = kernel_power_new;
4467 }
4468 }
4469 }
4470 }
4471
4472 const uint kernel_power = device_param->kernel_power;
4473
4474 uint work = MIN (words_left, kernel_power);
4475
4476 work = MIN (work, max);
4477
4478 data.words_cur += work;
4479
4480 hc_thread_mutex_unlock (mux_dispatcher);
4481
4482 return work;
4483 }
4484
4485 static void *thread_calc_stdin (void *p)
4486 {
4487 hc_device_param_t *device_param = (hc_device_param_t *) p;
4488
4489 if (device_param->skipped) return NULL;
4490
4491 autotune (device_param);
4492
4493 char *buf = (char *) mymalloc (HCBUFSIZ);
4494
4495 const uint attack_kern = data.attack_kern;
4496
4497 const uint kernel_power = device_param->kernel_power;
4498
4499 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4500 {
4501 hc_thread_mutex_lock (mux_dispatcher);
4502
4503 if (feof (stdin) != 0)
4504 {
4505 hc_thread_mutex_unlock (mux_dispatcher);
4506
4507 break;
4508 }
4509
4510 uint words_cur = 0;
4511
4512 while (words_cur < kernel_power)
4513 {
4514 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4515
4516 if (line_buf == NULL) break;
4517
4518 uint line_len = in_superchop (line_buf);
4519
4520 line_len = convert_from_hex (line_buf, line_len);
4521
4522 // post-process rule engine
4523
4524 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4525 {
4526 char rule_buf_out[BLOCK_SIZE] = { 0 };
4527
4528 int rule_len_out = -1;
4529
4530 if (line_len < BLOCK_SIZE)
4531 {
4532 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4533 }
4534
4535 if (rule_len_out < 0) continue;
4536
4537 line_buf = rule_buf_out;
4538 line_len = rule_len_out;
4539 }
4540
4541 if (line_len > PW_MAX)
4542 {
4543 continue;
4544 }
4545
4546 if (attack_kern == ATTACK_KERN_STRAIGHT)
4547 {
4548 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4549 {
4550 hc_thread_mutex_lock (mux_counter);
4551
4552 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4553 {
4554 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4555 }
4556
4557 hc_thread_mutex_unlock (mux_counter);
4558
4559 continue;
4560 }
4561 }
4562 else if (attack_kern == ATTACK_KERN_COMBI)
4563 {
4564 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4565 // since we still need to combine the plains
4566
4567 if (line_len > data.pw_max)
4568 {
4569 hc_thread_mutex_lock (mux_counter);
4570
4571 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4572 {
4573 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4574 }
4575
4576 hc_thread_mutex_unlock (mux_counter);
4577
4578 continue;
4579 }
4580 }
4581
4582 pw_add (device_param, (u8 *) line_buf, line_len);
4583
4584 words_cur++;
4585
4586 if (data.devices_status == STATUS_CRACKED) break;
4587 if (data.devices_status == STATUS_ABORTED) break;
4588 if (data.devices_status == STATUS_QUIT) break;
4589 if (data.devices_status == STATUS_BYPASS) break;
4590 }
4591
4592 hc_thread_mutex_unlock (mux_dispatcher);
4593
4594 if (data.devices_status == STATUS_CRACKED) break;
4595 if (data.devices_status == STATUS_ABORTED) break;
4596 if (data.devices_status == STATUS_QUIT) break;
4597 if (data.devices_status == STATUS_BYPASS) break;
4598
4599 // flush
4600
4601 const uint pws_cnt = device_param->pws_cnt;
4602
4603 if (pws_cnt)
4604 {
4605 run_copy (device_param, pws_cnt);
4606
4607 run_cracker (device_param, pws_cnt);
4608
4609 device_param->pws_cnt = 0;
4610
4611 /*
4612 still required?
4613 if (attack_kern == ATTACK_KERN_STRAIGHT)
4614 {
4615 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4616 }
4617 else if (attack_kern == ATTACK_KERN_COMBI)
4618 {
4619 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4620 }
4621 */
4622 }
4623 }
4624
4625 device_param->kernel_accel = 0;
4626 device_param->kernel_loops = 0;
4627
4628 myfree (buf);
4629
4630 return NULL;
4631 }
4632
4633 static void *thread_calc (void *p)
4634 {
4635 hc_device_param_t *device_param = (hc_device_param_t *) p;
4636
4637 if (device_param->skipped) return NULL;
4638
4639 autotune (device_param);
4640
4641 const uint attack_mode = data.attack_mode;
4642 const uint attack_kern = data.attack_kern;
4643
4644 if (attack_mode == ATTACK_MODE_BF)
4645 {
4646 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4647 {
4648 const uint work = get_work (device_param, -1, true);
4649
4650 if (work == 0) break;
4651
4652 const u64 words_off = device_param->words_off;
4653 const u64 words_fin = words_off + work;
4654
4655 const uint pws_cnt = work;
4656
4657 device_param->pws_cnt = pws_cnt;
4658
4659 if (pws_cnt)
4660 {
4661 run_copy (device_param, pws_cnt);
4662
4663 run_cracker (device_param, pws_cnt);
4664
4665 device_param->pws_cnt = 0;
4666
4667 /*
4668 still required?
4669 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4670 */
4671 }
4672
4673 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4674
4675 if (data.devices_status == STATUS_CRACKED) break;
4676 if (data.devices_status == STATUS_ABORTED) break;
4677 if (data.devices_status == STATUS_QUIT) break;
4678 if (data.devices_status == STATUS_BYPASS) break;
4679
4680 if (data.benchmark == 1) break;
4681
4682 device_param->words_done = words_fin;
4683 }
4684 }
4685 else
4686 {
4687 const uint segment_size = data.segment_size;
4688
4689 char *dictfile = data.dictfile;
4690
4691 if (attack_mode == ATTACK_MODE_COMBI)
4692 {
4693 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4694 {
4695 dictfile = data.dictfile2;
4696 }
4697 }
4698
4699 FILE *fd = fopen (dictfile, "rb");
4700
4701 if (fd == NULL)
4702 {
4703 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4704
4705 return NULL;
4706 }
4707
4708 if (attack_mode == ATTACK_MODE_COMBI)
4709 {
4710 const uint combs_mode = data.combs_mode;
4711
4712 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4713 {
4714 const char *dictfilec = data.dictfile2;
4715
4716 FILE *combs_fp = fopen (dictfilec, "rb");
4717
4718 if (combs_fp == NULL)
4719 {
4720 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4721
4722 fclose (fd);
4723
4724 return NULL;
4725 }
4726
4727 device_param->combs_fp = combs_fp;
4728 }
4729 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4730 {
4731 const char *dictfilec = data.dictfile;
4732
4733 FILE *combs_fp = fopen (dictfilec, "rb");
4734
4735 if (combs_fp == NULL)
4736 {
4737 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4738
4739 fclose (fd);
4740
4741 return NULL;
4742 }
4743
4744 device_param->combs_fp = combs_fp;
4745 }
4746 }
4747
4748 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4749
4750 wl_data->buf = (char *) mymalloc (segment_size);
4751 wl_data->avail = segment_size;
4752 wl_data->incr = segment_size;
4753 wl_data->cnt = 0;
4754 wl_data->pos = 0;
4755
4756 u64 words_cur = 0;
4757
4758 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4759 {
4760 u64 words_off = 0;
4761 u64 words_fin = 0;
4762
4763 bool allow_div = true;
4764
4765 u64 max = -1;
4766
4767 while (max)
4768 {
4769 const uint work = get_work (device_param, max, allow_div);
4770
4771 allow_div = false;
4772
4773 if (work == 0) break;
4774
4775 words_off = device_param->words_off;
4776 words_fin = words_off + work;
4777
4778 char *line_buf;
4779 uint line_len;
4780
4781 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4782
4783 max = 0;
4784
4785 for ( ; words_cur < words_fin; words_cur++)
4786 {
4787 get_next_word (wl_data, fd, &line_buf, &line_len);
4788
4789 line_len = convert_from_hex (line_buf, line_len);
4790
4791 // post-process rule engine
4792
4793 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4794 {
4795 char rule_buf_out[BLOCK_SIZE] = { 0 };
4796
4797 int rule_len_out = -1;
4798
4799 if (line_len < BLOCK_SIZE)
4800 {
4801 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4802 }
4803
4804 if (rule_len_out < 0) continue;
4805
4806 line_buf = rule_buf_out;
4807 line_len = rule_len_out;
4808 }
4809
4810 if (attack_kern == ATTACK_KERN_STRAIGHT)
4811 {
4812 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4813 {
4814 max++;
4815
4816 hc_thread_mutex_lock (mux_counter);
4817
4818 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4819 {
4820 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4821 }
4822
4823 hc_thread_mutex_unlock (mux_counter);
4824
4825 continue;
4826 }
4827 }
4828 else if (attack_kern == ATTACK_KERN_COMBI)
4829 {
4830 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4831 // since we still need to combine the plains
4832
4833 if (line_len > data.pw_max)
4834 {
4835 max++;
4836
4837 hc_thread_mutex_lock (mux_counter);
4838
4839 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4840 {
4841 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4842 }
4843
4844 hc_thread_mutex_unlock (mux_counter);
4845
4846 continue;
4847 }
4848 }
4849
4850 pw_add (device_param, (u8 *) line_buf, line_len);
4851
4852 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4853
4854 if (data.devices_status == STATUS_CRACKED) break;
4855 if (data.devices_status == STATUS_ABORTED) break;
4856 if (data.devices_status == STATUS_QUIT) break;
4857 if (data.devices_status == STATUS_BYPASS) break;
4858 }
4859
4860 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4861
4862 if (data.devices_status == STATUS_CRACKED) break;
4863 if (data.devices_status == STATUS_ABORTED) break;
4864 if (data.devices_status == STATUS_QUIT) break;
4865 if (data.devices_status == STATUS_BYPASS) break;
4866 }
4867
4868 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4869
4870 if (data.devices_status == STATUS_CRACKED) break;
4871 if (data.devices_status == STATUS_ABORTED) break;
4872 if (data.devices_status == STATUS_QUIT) break;
4873 if (data.devices_status == STATUS_BYPASS) break;
4874
4875 //
4876 // flush
4877 //
4878
4879 const uint pws_cnt = device_param->pws_cnt;
4880
4881 if (pws_cnt)
4882 {
4883 run_copy (device_param, pws_cnt);
4884
4885 run_cracker (device_param, pws_cnt);
4886
4887 device_param->pws_cnt = 0;
4888
4889 /*
4890 still required?
4891 if (attack_kern == ATTACK_KERN_STRAIGHT)
4892 {
4893 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4894 }
4895 else if (attack_kern == ATTACK_KERN_COMBI)
4896 {
4897 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4898 }
4899 */
4900 }
4901
4902 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4903
4904 if (data.devices_status == STATUS_CRACKED) break;
4905 if (data.devices_status == STATUS_ABORTED) break;
4906 if (data.devices_status == STATUS_QUIT) break;
4907 if (data.devices_status == STATUS_BYPASS) break;
4908
4909 if (words_fin == 0) break;
4910
4911 device_param->words_done = words_fin;
4912 }
4913
4914 if (attack_mode == ATTACK_MODE_COMBI)
4915 {
4916 fclose (device_param->combs_fp);
4917 }
4918
4919 free (wl_data->buf);
4920 free (wl_data);
4921
4922 fclose (fd);
4923 }
4924
4925 device_param->kernel_accel = 0;
4926 device_param->kernel_loops = 0;
4927
4928 return NULL;
4929 }
4930
4931 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4932 {
4933 if (!device_param)
4934 {
4935 log_error ("ERROR: %s : Invalid argument", __func__);
4936
4937 exit (-1);
4938 }
4939
4940 salt_t *salt_buf = &data.salts_buf[salt_pos];
4941
4942 device_param->kernel_params_buf32[24] = salt_pos;
4943 device_param->kernel_params_buf32[27] = 1;
4944 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4945 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4946 device_param->kernel_params_buf32[30] = 0;
4947 device_param->kernel_params_buf32[31] = 1;
4948
4949 char *dictfile_old = data.dictfile;
4950
4951 const char *weak_hash_check = "weak-hash-check";
4952
4953 data.dictfile = (char *) weak_hash_check;
4954
4955 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4956
4957 data.kernel_rules_buf[0].cmds[0] = 0;
4958
4959 /**
4960 * run the kernel
4961 */
4962
4963 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4964 {
4965 run_kernel (KERN_RUN_1, device_param, 1, false);
4966 }
4967 else
4968 {
4969 run_kernel (KERN_RUN_1, device_param, 1, false);
4970
4971 uint loop_step = 16;
4972
4973 const uint iter = salt_buf->salt_iter;
4974
4975 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4976 {
4977 uint loop_left = iter - loop_pos;
4978
4979 loop_left = MIN (loop_left, loop_step);
4980
4981 device_param->kernel_params_buf32[25] = loop_pos;
4982 device_param->kernel_params_buf32[26] = loop_left;
4983
4984 run_kernel (KERN_RUN_2, device_param, 1, false);
4985 }
4986
4987 run_kernel (KERN_RUN_3, device_param, 1, false);
4988 }
4989
4990 /**
4991 * result
4992 */
4993
4994 check_cracked (device_param, salt_pos);
4995
4996 /**
4997 * cleanup
4998 */
4999
5000 device_param->kernel_params_buf32[24] = 0;
5001 device_param->kernel_params_buf32[25] = 0;
5002 device_param->kernel_params_buf32[26] = 0;
5003 device_param->kernel_params_buf32[27] = 0;
5004 device_param->kernel_params_buf32[28] = 0;
5005 device_param->kernel_params_buf32[29] = 0;
5006 device_param->kernel_params_buf32[30] = 0;
5007 device_param->kernel_params_buf32[31] = 0;
5008
5009 data.dictfile = dictfile_old;
5010
5011 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5012 }
5013
5014 // hlfmt hashcat
5015
5016 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5017 {
5018 if (data.username == 0)
5019 {
5020 *hashbuf_pos = line_buf;
5021 *hashbuf_len = line_len;
5022 }
5023 else
5024 {
5025 char *pos = line_buf;
5026 int len = line_len;
5027
5028 for (int i = 0; i < line_len; i++, pos++, len--)
5029 {
5030 if (line_buf[i] == data.separator)
5031 {
5032 pos++;
5033
5034 len--;
5035
5036 break;
5037 }
5038 }
5039
5040 *hashbuf_pos = pos;
5041 *hashbuf_len = len;
5042 }
5043 }
5044
5045 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5046 {
5047 char *pos = NULL;
5048 int len = 0;
5049
5050 int sep_cnt = 0;
5051
5052 for (int i = 0; i < line_len; i++)
5053 {
5054 if (line_buf[i] == data.separator)
5055 {
5056 sep_cnt++;
5057
5058 continue;
5059 }
5060
5061 if (sep_cnt == 0)
5062 {
5063 if (pos == NULL) pos = line_buf + i;
5064
5065 len++;
5066 }
5067 }
5068
5069 *userbuf_pos = pos;
5070 *userbuf_len = len;
5071 }
5072
5073 // hlfmt pwdump
5074
5075 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5076 {
5077 int sep_cnt = 0;
5078
5079 int sep2_len = 0;
5080 int sep3_len = 0;
5081
5082 for (int i = 0; i < line_len; i++)
5083 {
5084 if (line_buf[i] == ':')
5085 {
5086 sep_cnt++;
5087
5088 continue;
5089 }
5090
5091 if (sep_cnt == 2) sep2_len++;
5092 if (sep_cnt == 3) sep3_len++;
5093 }
5094
5095 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5096
5097 return 0;
5098 }
5099
5100 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5101 {
5102 char *pos = NULL;
5103 int len = 0;
5104
5105 int sep_cnt = 0;
5106
5107 for (int i = 0; i < line_len; i++)
5108 {
5109 if (line_buf[i] == ':')
5110 {
5111 sep_cnt++;
5112
5113 continue;
5114 }
5115
5116 if (data.hash_mode == 1000)
5117 {
5118 if (sep_cnt == 3)
5119 {
5120 if (pos == NULL) pos = line_buf + i;
5121
5122 len++;
5123 }
5124 }
5125 else if (data.hash_mode == 3000)
5126 {
5127 if (sep_cnt == 2)
5128 {
5129 if (pos == NULL) pos = line_buf + i;
5130
5131 len++;
5132 }
5133 }
5134 }
5135
5136 *hashbuf_pos = pos;
5137 *hashbuf_len = len;
5138 }
5139
5140 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5141 {
5142 char *pos = NULL;
5143 int len = 0;
5144
5145 int sep_cnt = 0;
5146
5147 for (int i = 0; i < line_len; i++)
5148 {
5149 if (line_buf[i] == ':')
5150 {
5151 sep_cnt++;
5152
5153 continue;
5154 }
5155
5156 if (sep_cnt == 0)
5157 {
5158 if (pos == NULL) pos = line_buf + i;
5159
5160 len++;
5161 }
5162 }
5163
5164 *userbuf_pos = pos;
5165 *userbuf_len = len;
5166 }
5167
5168 // hlfmt passwd
5169
5170 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5171 {
5172 int sep_cnt = 0;
5173
5174 char sep5_first = 0;
5175 char sep6_first = 0;
5176
5177 for (int i = 0; i < line_len; i++)
5178 {
5179 if (line_buf[i] == ':')
5180 {
5181 sep_cnt++;
5182
5183 continue;
5184 }
5185
5186 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5187 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5188 }
5189
5190 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5191
5192 return 0;
5193 }
5194
5195 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5196 {
5197 char *pos = NULL;
5198 int len = 0;
5199
5200 int sep_cnt = 0;
5201
5202 for (int i = 0; i < line_len; i++)
5203 {
5204 if (line_buf[i] == ':')
5205 {
5206 sep_cnt++;
5207
5208 continue;
5209 }
5210
5211 if (sep_cnt == 1)
5212 {
5213 if (pos == NULL) pos = line_buf + i;
5214
5215 len++;
5216 }
5217 }
5218
5219 *hashbuf_pos = pos;
5220 *hashbuf_len = len;
5221 }
5222
5223 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5224 {
5225 char *pos = NULL;
5226 int len = 0;
5227
5228 int sep_cnt = 0;
5229
5230 for (int i = 0; i < line_len; i++)
5231 {
5232 if (line_buf[i] == ':')
5233 {
5234 sep_cnt++;
5235
5236 continue;
5237 }
5238
5239 if (sep_cnt == 0)
5240 {
5241 if (pos == NULL) pos = line_buf + i;
5242
5243 len++;
5244 }
5245 }
5246
5247 *userbuf_pos = pos;
5248 *userbuf_len = len;
5249 }
5250
5251 // hlfmt shadow
5252
5253 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5254 {
5255 int sep_cnt = 0;
5256
5257 for (int i = 0; i < line_len; i++)
5258 {
5259 if (line_buf[i] == ':') sep_cnt++;
5260 }
5261
5262 if (sep_cnt == 8) return 1;
5263
5264 return 0;
5265 }
5266
5267 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5268 {
5269 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5270 }
5271
5272 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5273 {
5274 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5275 }
5276
5277 // hlfmt main
5278
5279 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5280 {
5281 switch (hashfile_format)
5282 {
5283 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5284 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5285 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5286 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5287 }
5288 }
5289
5290 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5291 {
5292 switch (hashfile_format)
5293 {
5294 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5295 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5296 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5297 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5298 }
5299 }
5300
5301 char *strhlfmt (const uint hashfile_format)
5302 {
5303 switch (hashfile_format)
5304 {
5305 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5306 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5307 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5308 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5309 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5310 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5311 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5312 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5313 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5314 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5315 }
5316
5317 return ((char *) "Unknown");
5318 }
5319
5320 static uint hlfmt_detect (FILE *fp, uint max_check)
5321 {
5322 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5323
5324 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5325 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5326
5327 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5328
5329 uint num_check = 0;
5330
5331 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5332
5333 while (!feof (fp))
5334 {
5335 int line_len = fgetl (fp, line_buf);
5336
5337 if (line_len == 0) continue;
5338
5339 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5340 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5341 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5342
5343 if (num_check == max_check) break;
5344
5345 num_check++;
5346 }
5347
5348 myfree (line_buf);
5349
5350 uint hashlist_format = HLFMT_HASHCAT;
5351
5352 for (int i = 1; i < HLFMTS_CNT; i++)
5353 {
5354 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5355
5356 hashlist_format = i;
5357 }
5358
5359 free (formats_cnt);
5360
5361 return hashlist_format;
5362 }
5363
5364 /**
5365 * some further helper function
5366 */
5367
5368 // wrapper around mymalloc for ADL
5369
5370 #if defined(HAVE_HWMON)
5371 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5372 {
5373 return mymalloc (iSize);
5374 }
5375 #endif
5376
5377 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)
5378 {
5379 u64 collisions = 0;
5380
5381 const uint dgst_pos0 = data.dgst_pos0;
5382 const uint dgst_pos1 = data.dgst_pos1;
5383 const uint dgst_pos2 = data.dgst_pos2;
5384 const uint dgst_pos3 = data.dgst_pos3;
5385
5386 memset (bitmap_a, 0, bitmap_size);
5387 memset (bitmap_b, 0, bitmap_size);
5388 memset (bitmap_c, 0, bitmap_size);
5389 memset (bitmap_d, 0, bitmap_size);
5390
5391 for (uint i = 0; i < digests_cnt; i++)
5392 {
5393 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5394
5395 uint *digest_ptr = (uint *) digests_buf_ptr;
5396
5397 digests_buf_ptr += dgst_size;
5398
5399 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5400 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5401 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5402 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5403
5404 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5405 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5406 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5407 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5408
5409 if (bitmap_a[idx0] & val0) collisions++;
5410 if (bitmap_b[idx1] & val1) collisions++;
5411 if (bitmap_c[idx2] & val2) collisions++;
5412 if (bitmap_d[idx3] & val3) collisions++;
5413
5414 bitmap_a[idx0] |= val0;
5415 bitmap_b[idx1] |= val1;
5416 bitmap_c[idx2] |= val2;
5417 bitmap_d[idx3] |= val3;
5418
5419 if (collisions >= collisions_max) return 0x7fffffff;
5420 }
5421
5422 return collisions;
5423 }
5424
5425 /**
5426 * main
5427 */
5428
5429 #ifdef _WIN
5430 void SetConsoleWindowSize (const int x)
5431 {
5432 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5433
5434 if (h == INVALID_HANDLE_VALUE) return;
5435
5436 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5437
5438 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5439
5440 SMALL_RECT *sr = &bufferInfo.srWindow;
5441
5442 sr->Right = MAX (sr->Right, x - 1);
5443
5444 COORD co;
5445
5446 co.X = sr->Right + 1;
5447 co.Y = sr->Bottom + 1;
5448
5449 if (!SetConsoleScreenBufferSize (h, co)) return;
5450
5451 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5452 }
5453 #endif
5454
5455 int main (int argc, char **argv)
5456 {
5457 #ifdef _WIN
5458 SetConsoleWindowSize (132);
5459 #endif
5460
5461 /**
5462 * To help users a bit
5463 */
5464
5465 char *compute = getenv ("COMPUTE");
5466
5467 if (compute)
5468 {
5469 static char display[100];
5470
5471 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5472
5473 putenv (display);
5474 }
5475 else
5476 {
5477 if (getenv ("DISPLAY") == NULL)
5478 putenv ((char *) "DISPLAY=:0");
5479 }
5480
5481 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5482 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5483
5484 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5485 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5486
5487 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5488 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5489
5490 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5491 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5492
5493 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5494 putenv ((char *) "POCL_KERNEL_CACHE=0");
5495
5496 umask (077);
5497
5498 /**
5499 * Real init
5500 */
5501
5502 memset (&data, 0, sizeof (hc_global_data_t));
5503
5504 time_t proc_start;
5505
5506 time (&proc_start);
5507
5508 data.proc_start = proc_start;
5509
5510 int myargc = argc;
5511 char **myargv = argv;
5512
5513 hc_thread_mutex_init (mux_dispatcher);
5514 hc_thread_mutex_init (mux_counter);
5515 hc_thread_mutex_init (mux_display);
5516 hc_thread_mutex_init (mux_adl);
5517
5518 /**
5519 * commandline parameters
5520 */
5521
5522 uint usage = USAGE;
5523 uint version = VERSION;
5524 uint quiet = QUIET;
5525 uint benchmark = BENCHMARK;
5526 uint show = SHOW;
5527 uint left = LEFT;
5528 uint username = USERNAME;
5529 uint remove = REMOVE;
5530 uint remove_timer = REMOVE_TIMER;
5531 u64 skip = SKIP;
5532 u64 limit = LIMIT;
5533 uint keyspace = KEYSPACE;
5534 uint potfile_disable = POTFILE_DISABLE;
5535 char *potfile_path = NULL;
5536 uint debug_mode = DEBUG_MODE;
5537 char *debug_file = NULL;
5538 char *induction_dir = NULL;
5539 char *outfile_check_dir = NULL;
5540 uint force = FORCE;
5541 uint runtime = RUNTIME;
5542 uint hash_mode = HASH_MODE;
5543 uint attack_mode = ATTACK_MODE;
5544 uint markov_disable = MARKOV_DISABLE;
5545 uint markov_classic = MARKOV_CLASSIC;
5546 uint markov_threshold = MARKOV_THRESHOLD;
5547 char *markov_hcstat = NULL;
5548 char *outfile = NULL;
5549 uint outfile_format = OUTFILE_FORMAT;
5550 uint outfile_autohex = OUTFILE_AUTOHEX;
5551 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5552 uint restore = RESTORE;
5553 uint restore_timer = RESTORE_TIMER;
5554 uint restore_disable = RESTORE_DISABLE;
5555 uint status = STATUS;
5556 uint status_timer = STATUS_TIMER;
5557 uint machine_readable = MACHINE_READABLE;
5558 uint loopback = LOOPBACK;
5559 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5560 char *session = NULL;
5561 uint hex_charset = HEX_CHARSET;
5562 uint hex_salt = HEX_SALT;
5563 uint hex_wordlist = HEX_WORDLIST;
5564 uint rp_gen = RP_GEN;
5565 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5566 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5567 uint rp_gen_seed = RP_GEN_SEED;
5568 char *rule_buf_l = (char *) RULE_BUF_L;
5569 char *rule_buf_r = (char *) RULE_BUF_R;
5570 uint increment = INCREMENT;
5571 uint increment_min = INCREMENT_MIN;
5572 uint increment_max = INCREMENT_MAX;
5573 char *cpu_affinity = NULL;
5574 OCL_PTR *ocl = NULL;
5575 char *opencl_devices = NULL;
5576 char *opencl_platforms = NULL;
5577 char *opencl_device_types = NULL;
5578 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5579 char *truecrypt_keyfiles = NULL;
5580 char *veracrypt_keyfiles = NULL;
5581 uint veracrypt_pim = 0;
5582 uint workload_profile = WORKLOAD_PROFILE;
5583 uint kernel_accel = KERNEL_ACCEL;
5584 uint kernel_loops = KERNEL_LOOPS;
5585 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5586 #ifdef HAVE_HWMON
5587 uint gpu_temp_abort = GPU_TEMP_ABORT;
5588 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5589 uint powertune_enable = POWERTUNE_ENABLE;
5590 #endif
5591 uint logfile_disable = LOGFILE_DISABLE;
5592 uint segment_size = SEGMENT_SIZE;
5593 uint scrypt_tmto = SCRYPT_TMTO;
5594 char separator = SEPARATOR;
5595 uint bitmap_min = BITMAP_MIN;
5596 uint bitmap_max = BITMAP_MAX;
5597 char *custom_charset_1 = NULL;
5598 char *custom_charset_2 = NULL;
5599 char *custom_charset_3 = NULL;
5600 char *custom_charset_4 = NULL;
5601
5602 #define IDX_HELP 'h'
5603 #define IDX_VERSION 'V'
5604 #define IDX_VERSION_LOWER 'v'
5605 #define IDX_QUIET 0xff02
5606 #define IDX_SHOW 0xff03
5607 #define IDX_LEFT 0xff04
5608 #define IDX_REMOVE 0xff05
5609 #define IDX_REMOVE_TIMER 0xff37
5610 #define IDX_SKIP 's'
5611 #define IDX_LIMIT 'l'
5612 #define IDX_KEYSPACE 0xff35
5613 #define IDX_POTFILE_DISABLE 0xff06
5614 #define IDX_POTFILE_PATH 0xffe0
5615 #define IDX_DEBUG_MODE 0xff43
5616 #define IDX_DEBUG_FILE 0xff44
5617 #define IDX_INDUCTION_DIR 0xff46
5618 #define IDX_OUTFILE_CHECK_DIR 0xff47
5619 #define IDX_USERNAME 0xff07
5620 #define IDX_FORCE 0xff08
5621 #define IDX_RUNTIME 0xff09
5622 #define IDX_BENCHMARK 'b'
5623 #define IDX_HASH_MODE 'm'
5624 #define IDX_ATTACK_MODE 'a'
5625 #define IDX_RP_FILE 'r'
5626 #define IDX_RP_GEN 'g'
5627 #define IDX_RP_GEN_FUNC_MIN 0xff10
5628 #define IDX_RP_GEN_FUNC_MAX 0xff11
5629 #define IDX_RP_GEN_SEED 0xff34
5630 #define IDX_RULE_BUF_L 'j'
5631 #define IDX_RULE_BUF_R 'k'
5632 #define IDX_INCREMENT 'i'
5633 #define IDX_INCREMENT_MIN 0xff12
5634 #define IDX_INCREMENT_MAX 0xff13
5635 #define IDX_OUTFILE 'o'
5636 #define IDX_OUTFILE_FORMAT 0xff14
5637 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5638 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5639 #define IDX_RESTORE 0xff15
5640 #define IDX_RESTORE_DISABLE 0xff27
5641 #define IDX_STATUS 0xff17
5642 #define IDX_STATUS_TIMER 0xff18
5643 #define IDX_MACHINE_READABLE 0xff50
5644 #define IDX_LOOPBACK 0xff38
5645 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5646 #define IDX_SESSION 0xff19
5647 #define IDX_HEX_CHARSET 0xff20
5648 #define IDX_HEX_SALT 0xff21
5649 #define IDX_HEX_WORDLIST 0xff40
5650 #define IDX_MARKOV_DISABLE 0xff22
5651 #define IDX_MARKOV_CLASSIC 0xff23
5652 #define IDX_MARKOV_THRESHOLD 't'
5653 #define IDX_MARKOV_HCSTAT 0xff24
5654 #define IDX_CPU_AFFINITY 0xff25
5655 #define IDX_OPENCL_DEVICES 'd'
5656 #define IDX_OPENCL_PLATFORMS 0xff72
5657 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5658 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5659 #define IDX_WORKLOAD_PROFILE 'w'
5660 #define IDX_KERNEL_ACCEL 'n'
5661 #define IDX_KERNEL_LOOPS 'u'
5662 #define IDX_GPU_TEMP_DISABLE 0xff29
5663 #define IDX_GPU_TEMP_ABORT 0xff30
5664 #define IDX_GPU_TEMP_RETAIN 0xff31
5665 #define IDX_POWERTUNE_ENABLE 0xff41
5666 #define IDX_LOGFILE_DISABLE 0xff51
5667 #define IDX_TRUECRYPT_KEYFILES 0xff52
5668 #define IDX_VERACRYPT_KEYFILES 0xff53
5669 #define IDX_VERACRYPT_PIM 0xff54
5670 #define IDX_SCRYPT_TMTO 0xff61
5671 #define IDX_SEGMENT_SIZE 'c'
5672 #define IDX_SEPARATOR 'p'
5673 #define IDX_BITMAP_MIN 0xff70
5674 #define IDX_BITMAP_MAX 0xff71
5675 #define IDX_CUSTOM_CHARSET_1 '1'
5676 #define IDX_CUSTOM_CHARSET_2 '2'
5677 #define IDX_CUSTOM_CHARSET_3 '3'
5678 #define IDX_CUSTOM_CHARSET_4 '4'
5679
5680 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5681
5682 struct option long_options[] =
5683 {
5684 {"help", no_argument, 0, IDX_HELP},
5685 {"version", no_argument, 0, IDX_VERSION},
5686 {"quiet", no_argument, 0, IDX_QUIET},
5687 {"show", no_argument, 0, IDX_SHOW},
5688 {"left", no_argument, 0, IDX_LEFT},
5689 {"username", no_argument, 0, IDX_USERNAME},
5690 {"remove", no_argument, 0, IDX_REMOVE},
5691 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5692 {"skip", required_argument, 0, IDX_SKIP},
5693 {"limit", required_argument, 0, IDX_LIMIT},
5694 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5695 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5696 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5697 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5698 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5699 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5700 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5701 {"force", no_argument, 0, IDX_FORCE},
5702 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5703 {"restore", no_argument, 0, IDX_RESTORE},
5704 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5705 {"status", no_argument, 0, IDX_STATUS},
5706 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5707 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5708 {"loopback", no_argument, 0, IDX_LOOPBACK},
5709 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5710 {"session", required_argument, 0, IDX_SESSION},
5711 {"runtime", required_argument, 0, IDX_RUNTIME},
5712 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5713 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5714 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5715 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5716 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5717 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5718 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5719 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5720 {"rules-file", required_argument, 0, IDX_RP_FILE},
5721 {"outfile", required_argument, 0, IDX_OUTFILE},
5722 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5723 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5724 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5725 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5726 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5727 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5728 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5729 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5730 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5731 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5732 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5733 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5734 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5735 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5736 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5737 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5738 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5739 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5740 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5741 #ifdef HAVE_HWMON
5742 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5743 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5744 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5745 #endif // HAVE_HWMON
5746 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5747 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5748 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5749 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5750 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5751 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5752 {"seperator", required_argument, 0, IDX_SEPARATOR},
5753 {"separator", required_argument, 0, IDX_SEPARATOR},
5754 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5755 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5756 {"increment", no_argument, 0, IDX_INCREMENT},
5757 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5758 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5759 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5760 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5761 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5762 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5763 {0, 0, 0, 0}
5764 };
5765
5766 uint rp_files_cnt = 0;
5767
5768 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5769
5770 int option_index = 0;
5771 int c = -1;
5772
5773 optind = 1;
5774 optopt = 0;
5775
5776 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5777 {
5778 switch (c)
5779 {
5780 case IDX_HELP: usage = 1; break;
5781 case IDX_VERSION:
5782 case IDX_VERSION_LOWER: version = 1; break;
5783 case IDX_RESTORE: restore = 1; break;
5784 case IDX_SESSION: session = optarg; break;
5785 case IDX_SHOW: show = 1; break;
5786 case IDX_LEFT: left = 1; break;
5787 case '?': return (-1);
5788 }
5789 }
5790
5791 if (optopt != 0)
5792 {
5793 log_error ("ERROR: Invalid argument specified");
5794
5795 return (-1);
5796 }
5797
5798 /**
5799 * exit functions
5800 */
5801
5802 if (version)
5803 {
5804 log_info ("%s", VERSION_TAG);
5805
5806 return (0);
5807 }
5808
5809 if (usage)
5810 {
5811 usage_big_print (PROGNAME);
5812
5813 return (0);
5814 }
5815
5816 /**
5817 * session needs to be set, always!
5818 */
5819
5820 if (session == NULL) session = (char *) PROGNAME;
5821
5822 /**
5823 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5824 */
5825
5826 char *exec_path = get_exec_path ();
5827
5828 #ifdef LINUX
5829
5830 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5831 char *resolved_exec_path = realpath (exec_path, NULL);
5832
5833 char *install_dir = get_install_dir (resolved_exec_path);
5834 char *profile_dir = NULL;
5835 char *session_dir = NULL;
5836 char *shared_dir = NULL;
5837
5838 if (strcmp (install_dir, resolved_install_folder) == 0)
5839 {
5840 struct passwd *pw = getpwuid (getuid ());
5841
5842 const char *homedir = pw->pw_dir;
5843
5844 profile_dir = get_profile_dir (homedir);
5845 session_dir = get_session_dir (profile_dir);
5846 shared_dir = strdup (SHARED_FOLDER);
5847
5848 mkdir (profile_dir, 0700);
5849 mkdir (session_dir, 0700);
5850 }
5851 else
5852 {
5853 profile_dir = install_dir;
5854 session_dir = install_dir;
5855 shared_dir = install_dir;
5856 }
5857
5858 myfree (resolved_install_folder);
5859 myfree (resolved_exec_path);
5860
5861 #else
5862
5863 char *install_dir = get_install_dir (exec_path);
5864 char *profile_dir = install_dir;
5865 char *session_dir = install_dir;
5866 char *shared_dir = install_dir;
5867
5868 #endif
5869
5870 data.install_dir = install_dir;
5871 data.profile_dir = profile_dir;
5872 data.session_dir = session_dir;
5873 data.shared_dir = shared_dir;
5874
5875 myfree (exec_path);
5876
5877 /**
5878 * kernel cache, we need to make sure folder exist
5879 */
5880
5881 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5882
5883 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5884
5885 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5886
5887 mkdir (kernels_folder, 0700);
5888
5889 myfree (kernels_folder);
5890
5891 /**
5892 * session
5893 */
5894
5895 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5896
5897 data.session = session;
5898
5899 char *eff_restore_file = (char *) mymalloc (session_size);
5900 char *new_restore_file = (char *) mymalloc (session_size);
5901
5902 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5903 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5904
5905 data.eff_restore_file = eff_restore_file;
5906 data.new_restore_file = new_restore_file;
5907
5908 if (((show == 1) || (left == 1)) && (restore == 1))
5909 {
5910 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5911 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5912
5913 return (-1);
5914 }
5915
5916 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5917 if ((show == 1) || (left == 1))
5918 {
5919 restore_disable = 1;
5920
5921 restore = 0;
5922 }
5923
5924 data.restore_disable = restore_disable;
5925
5926 restore_data_t *rd = init_restore (argc, argv);
5927
5928 data.rd = rd;
5929
5930 /**
5931 * restore file
5932 */
5933
5934 if (restore == 1)
5935 {
5936 read_restore (eff_restore_file, rd);
5937
5938 if (rd->version_bin < RESTORE_MIN)
5939 {
5940 log_error ("ERROR: Incompatible restore-file version");
5941
5942 return (-1);
5943 }
5944
5945 myargc = rd->argc;
5946 myargv = rd->argv;
5947
5948 #ifdef _POSIX
5949 rd->pid = getpid ();
5950 #elif _WIN
5951 rd->pid = GetCurrentProcessId ();
5952 #endif
5953 }
5954
5955 uint hash_mode_chgd = 0;
5956 uint runtime_chgd = 0;
5957 uint kernel_loops_chgd = 0;
5958 uint kernel_accel_chgd = 0;
5959 uint attack_mode_chgd = 0;
5960 uint outfile_format_chgd = 0;
5961 uint rp_gen_seed_chgd = 0;
5962 uint remove_timer_chgd = 0;
5963 uint increment_min_chgd = 0;
5964 uint increment_max_chgd = 0;
5965 uint workload_profile_chgd = 0;
5966 uint opencl_vector_width_chgd = 0;
5967
5968 optind = 1;
5969 optopt = 0;
5970 option_index = 0;
5971
5972 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5973 {
5974 switch (c)
5975 {
5976 //case IDX_HELP: usage = 1; break;
5977 //case IDX_VERSION: version = 1; break;
5978 //case IDX_RESTORE: restore = 1; break;
5979 case IDX_QUIET: quiet = 1; break;
5980 //case IDX_SHOW: show = 1; break;
5981 case IDX_SHOW: break;
5982 //case IDX_LEFT: left = 1; break;
5983 case IDX_LEFT: break;
5984 case IDX_USERNAME: username = 1; break;
5985 case IDX_REMOVE: remove = 1; break;
5986 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5987 remove_timer_chgd = 1; break;
5988 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5989 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5990 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5991 case IDX_DEBUG_FILE: debug_file = optarg; break;
5992 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5993 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5994 case IDX_FORCE: force = 1; break;
5995 case IDX_SKIP: skip = atoll (optarg); break;
5996 case IDX_LIMIT: limit = atoll (optarg); break;
5997 case IDX_KEYSPACE: keyspace = 1; break;
5998 case IDX_BENCHMARK: benchmark = 1; break;
5999 case IDX_RESTORE: break;
6000 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6001 case IDX_STATUS: status = 1; break;
6002 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6003 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6004 case IDX_LOOPBACK: loopback = 1; break;
6005 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6006 //case IDX_SESSION: session = optarg; break;
6007 case IDX_SESSION: break;
6008 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6009 hash_mode_chgd = 1; break;
6010 case IDX_RUNTIME: runtime = atoi (optarg);
6011 runtime_chgd = 1; break;
6012 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6013 attack_mode_chgd = 1; break;
6014 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6015 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6016 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6017 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6018 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6019 rp_gen_seed_chgd = 1; break;
6020 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6021 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6022 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6023 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6024 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6025 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6026 case IDX_OUTFILE: outfile = optarg; break;
6027 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6028 outfile_format_chgd = 1; break;
6029 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6030 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6031 case IDX_HEX_CHARSET: hex_charset = 1; break;
6032 case IDX_HEX_SALT: hex_salt = 1; break;
6033 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6034 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6035 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6036 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6037 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6038 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6039 opencl_vector_width_chgd = 1; break;
6040 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6041 workload_profile_chgd = 1; break;
6042 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6043 kernel_accel_chgd = 1; break;
6044 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6045 kernel_loops_chgd = 1; break;
6046 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6047 #ifdef HAVE_HWMON
6048 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6049 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6050 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6051 #endif // HAVE_HWMON
6052 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6053 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6054 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6055 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6056 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6057 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6058 case IDX_SEPARATOR: separator = optarg[0]; break;
6059 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6060 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6061 case IDX_INCREMENT: increment = 1; break;
6062 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6063 increment_min_chgd = 1; break;
6064 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6065 increment_max_chgd = 1; break;
6066 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6067 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6068 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6069 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6070
6071 default:
6072 log_error ("ERROR: Invalid argument specified");
6073 return (-1);
6074 }
6075 }
6076
6077 if (optopt != 0)
6078 {
6079 log_error ("ERROR: Invalid argument specified");
6080
6081 return (-1);
6082 }
6083
6084 /**
6085 * Inform user things getting started,
6086 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6087 * - we do not need to check algorithm_pos
6088 */
6089
6090 if (quiet == 0)
6091 {
6092 if (benchmark == 1)
6093 {
6094 if (machine_readable == 0)
6095 {
6096 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6097 log_info ("");
6098 }
6099 else
6100 {
6101 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6102 }
6103 }
6104 else if (restore == 1)
6105 {
6106 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6107 log_info ("");
6108 }
6109 else
6110 {
6111 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6112 log_info ("");
6113 }
6114 }
6115
6116 /**
6117 * sanity check
6118 */
6119
6120 if (attack_mode > 7)
6121 {
6122 log_error ("ERROR: Invalid attack-mode specified");
6123
6124 return (-1);
6125 }
6126
6127 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6128 {
6129 log_error ("ERROR: Invalid runtime specified");
6130
6131 return (-1);
6132 }
6133
6134 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6135 {
6136 log_error ("ERROR: Invalid hash-type specified");
6137
6138 return (-1);
6139 }
6140
6141 // renamed hash modes
6142
6143 if (hash_mode_chgd)
6144 {
6145 int n = -1;
6146
6147 switch (hash_mode)
6148 {
6149 case 123: n = 124;
6150 break;
6151 }
6152
6153 if (n >= 0)
6154 {
6155 log_error ("Old -m specified, use -m %d instead", n);
6156
6157 return (-1);
6158 }
6159 }
6160
6161 if (username == 1)
6162 {
6163 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6164 {
6165 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6166
6167 return (-1);
6168 }
6169 }
6170
6171 if (outfile_format > 16)
6172 {
6173 log_error ("ERROR: Invalid outfile-format specified");
6174
6175 return (-1);
6176 }
6177
6178 if (left == 1)
6179 {
6180 if (outfile_format_chgd == 1)
6181 {
6182 if (outfile_format > 1)
6183 {
6184 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6185
6186 return (-1);
6187 }
6188 }
6189 else
6190 {
6191 outfile_format = OUTFILE_FMT_HASH;
6192 }
6193 }
6194
6195 if (show == 1)
6196 {
6197 if (outfile_format_chgd == 1)
6198 {
6199 if ((outfile_format > 7) && (outfile_format < 16))
6200 {
6201 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6202
6203 return (-1);
6204 }
6205 }
6206 }
6207
6208 if (increment_min < INCREMENT_MIN)
6209 {
6210 log_error ("ERROR: Invalid increment-min specified");
6211
6212 return (-1);
6213 }
6214
6215 if (increment_max > INCREMENT_MAX)
6216 {
6217 log_error ("ERROR: Invalid increment-max specified");
6218
6219 return (-1);
6220 }
6221
6222 if (increment_min > increment_max)
6223 {
6224 log_error ("ERROR: Invalid increment-min specified");
6225
6226 return (-1);
6227 }
6228
6229 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6230 {
6231 log_error ("ERROR: increment is not allowed in attack-mode 0");
6232
6233 return (-1);
6234 }
6235
6236 if ((increment == 0) && (increment_min_chgd == 1))
6237 {
6238 log_error ("ERROR: increment-min is only supported together with increment switch");
6239
6240 return (-1);
6241 }
6242
6243 if ((increment == 0) && (increment_max_chgd == 1))
6244 {
6245 log_error ("ERROR: increment-max is only supported together with increment switch");
6246
6247 return (-1);
6248 }
6249
6250 if (rp_files_cnt && rp_gen)
6251 {
6252 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6253
6254 return (-1);
6255 }
6256
6257 if (rp_files_cnt || rp_gen)
6258 {
6259 if (attack_mode != ATTACK_MODE_STRAIGHT)
6260 {
6261 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6262
6263 return (-1);
6264 }
6265 }
6266
6267 if (rp_gen_func_min > rp_gen_func_max)
6268 {
6269 log_error ("ERROR: Invalid rp-gen-func-min specified");
6270
6271 return (-1);
6272 }
6273
6274 if (kernel_accel_chgd == 1)
6275 {
6276 if (force == 0)
6277 {
6278 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6279 log_info ("Please consider using the option -w instead");
6280 log_info ("You can use --force to override this but do not post error reports if you do so");
6281 log_info ("");
6282
6283 return (-1);
6284 }
6285
6286 if (kernel_accel < 1)
6287 {
6288 log_error ("ERROR: Invalid kernel-accel specified");
6289
6290 return (-1);
6291 }
6292
6293 if (kernel_accel > 1024)
6294 {
6295 log_error ("ERROR: Invalid kernel-accel specified");
6296
6297 return (-1);
6298 }
6299 }
6300
6301 if (kernel_loops_chgd == 1)
6302 {
6303 if (force == 0)
6304 {
6305 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6306 log_info ("Please consider using the option -w instead");
6307 log_info ("You can use --force to override this but do not post error reports if you do so");
6308 log_info ("");
6309
6310 return (-1);
6311 }
6312
6313 if (kernel_loops < 1)
6314 {
6315 log_error ("ERROR: Invalid kernel-loops specified");
6316
6317 return (-1);
6318 }
6319
6320 if (kernel_loops > 1024)
6321 {
6322 log_error ("ERROR: Invalid kernel-loops specified");
6323
6324 return (-1);
6325 }
6326 }
6327
6328 if ((workload_profile < 1) || (workload_profile > 4))
6329 {
6330 log_error ("ERROR: workload-profile %i not available", workload_profile);
6331
6332 return (-1);
6333 }
6334
6335 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6336 {
6337 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6338
6339 return (-1);
6340 }
6341
6342 if (show == 1 || left == 1)
6343 {
6344 attack_mode = ATTACK_MODE_NONE;
6345
6346 if (remove == 1)
6347 {
6348 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6349
6350 return (-1);
6351 }
6352
6353 if (potfile_disable == 1)
6354 {
6355 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6356
6357 return (-1);
6358 }
6359 }
6360
6361 uint attack_kern = ATTACK_KERN_NONE;
6362
6363 switch (attack_mode)
6364 {
6365 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6366 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6367 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6368 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6369 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6370 }
6371
6372 if (benchmark == 0)
6373 {
6374 if (keyspace == 1)
6375 {
6376 int num_additional_params = 1;
6377
6378 if (attack_kern == ATTACK_KERN_COMBI)
6379 {
6380 num_additional_params = 2;
6381 }
6382
6383 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6384
6385 if (keyspace_wordlist_specified == 0) optind--;
6386 }
6387
6388 if (attack_kern == ATTACK_KERN_NONE)
6389 {
6390 if ((optind + 1) != myargc)
6391 {
6392 usage_mini_print (myargv[0]);
6393
6394 return (-1);
6395 }
6396 }
6397 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6398 {
6399 if ((optind + 1) > myargc)
6400 {
6401 usage_mini_print (myargv[0]);
6402
6403 return (-1);
6404 }
6405 }
6406 else if (attack_kern == ATTACK_KERN_COMBI)
6407 {
6408 if ((optind + 3) != myargc)
6409 {
6410 usage_mini_print (myargv[0]);
6411
6412 return (-1);
6413 }
6414 }
6415 else if (attack_kern == ATTACK_KERN_BF)
6416 {
6417 if ((optind + 1) > myargc)
6418 {
6419 usage_mini_print (myargv[0]);
6420
6421 return (-1);
6422 }
6423 }
6424 else
6425 {
6426 usage_mini_print (myargv[0]);
6427
6428 return (-1);
6429 }
6430 }
6431 else
6432 {
6433 if (myargv[optind] != 0)
6434 {
6435 log_error ("ERROR: Invalid argument for benchmark mode specified");
6436
6437 return (-1);
6438 }
6439
6440 if (attack_mode_chgd == 1)
6441 {
6442 if (attack_mode != ATTACK_MODE_BF)
6443 {
6444 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6445
6446 return (-1);
6447 }
6448 }
6449 }
6450
6451 if (skip != 0 && limit != 0)
6452 {
6453 limit += skip;
6454 }
6455
6456 if (keyspace == 1)
6457 {
6458 if (show == 1)
6459 {
6460 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6461
6462 return (-1);
6463 }
6464 else if (left == 1)
6465 {
6466 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6467
6468 return (-1);
6469 }
6470
6471 potfile_disable = 1;
6472
6473 restore_disable = 1;
6474
6475 restore = 0;
6476
6477 weak_hash_threshold = 0;
6478
6479 quiet = 1;
6480 }
6481
6482 if (remove_timer_chgd == 1)
6483 {
6484 if (remove == 0)
6485 {
6486 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6487
6488 return (-1);
6489 }
6490
6491 if (remove_timer < 1)
6492 {
6493 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6494
6495 return (-1);
6496 }
6497 }
6498
6499 if (loopback == 1)
6500 {
6501 if (attack_mode == ATTACK_MODE_STRAIGHT)
6502 {
6503 if ((rp_files_cnt == 0) && (rp_gen == 0))
6504 {
6505 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6506
6507 return (-1);
6508 }
6509 }
6510 else
6511 {
6512 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6513
6514 return (-1);
6515 }
6516 }
6517
6518 if (debug_mode > 0)
6519 {
6520 if (attack_mode != ATTACK_MODE_STRAIGHT)
6521 {
6522 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6523
6524 return (-1);
6525 }
6526
6527 if ((rp_files_cnt == 0) && (rp_gen == 0))
6528 {
6529 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6530
6531 return (-1);
6532 }
6533 }
6534
6535 if (debug_mode > 4)
6536 {
6537 log_error ("ERROR: Invalid debug-mode specified");
6538
6539 return (-1);
6540 }
6541
6542 if (debug_file != NULL)
6543 {
6544 if (debug_mode < 1)
6545 {
6546 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6547
6548 return (-1);
6549 }
6550 }
6551
6552 if (induction_dir != NULL)
6553 {
6554 if (attack_mode == ATTACK_MODE_BF)
6555 {
6556 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6557
6558 return (-1);
6559 }
6560 }
6561
6562 if (attack_mode != ATTACK_MODE_STRAIGHT)
6563 {
6564 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6565 {
6566 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6567
6568 return (-1);
6569 }
6570
6571 weak_hash_threshold = 0;
6572 }
6573
6574 /**
6575 * induction directory
6576 */
6577
6578 char *induction_directory = NULL;
6579
6580 if (attack_mode != ATTACK_MODE_BF)
6581 {
6582 if (induction_dir == NULL)
6583 {
6584 induction_directory = (char *) mymalloc (session_size);
6585
6586 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6587
6588 // create induction folder if it does not already exist
6589
6590 if (keyspace == 0)
6591 {
6592 if (rmdir (induction_directory) == -1)
6593 {
6594 if (errno == ENOENT)
6595 {
6596 // good, we can ignore
6597 }
6598 else if (errno == ENOTEMPTY)
6599 {
6600 char *induction_directory_mv = (char *) mymalloc (session_size);
6601
6602 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6603
6604 if (rename (induction_directory, induction_directory_mv) != 0)
6605 {
6606 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6607
6608 return (-1);
6609 }
6610 }
6611 else
6612 {
6613 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6614
6615 return (-1);
6616 }
6617 }
6618
6619 if (mkdir (induction_directory, 0700) == -1)
6620 {
6621 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6622
6623 return (-1);
6624 }
6625 }
6626 }
6627 else
6628 {
6629 induction_directory = induction_dir;
6630 }
6631 }
6632
6633 data.induction_directory = induction_directory;
6634
6635 /**
6636 * loopback
6637 */
6638
6639 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6640
6641 char *loopback_file = (char *) mymalloc (loopback_size);
6642
6643 /**
6644 * tuning db
6645 */
6646
6647 char tuning_db_file[256] = { 0 };
6648
6649 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6650
6651 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6652
6653 /**
6654 * outfile-check directory
6655 */
6656
6657 char *outfile_check_directory = NULL;
6658
6659 if (outfile_check_dir == NULL)
6660 {
6661 outfile_check_directory = (char *) mymalloc (session_size);
6662
6663 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6664 }
6665 else
6666 {
6667 outfile_check_directory = outfile_check_dir;
6668 }
6669
6670 data.outfile_check_directory = outfile_check_directory;
6671
6672 if (keyspace == 0)
6673 {
6674 struct stat outfile_check_stat;
6675
6676 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6677 {
6678 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6679
6680 if (is_dir == 0)
6681 {
6682 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6683
6684 return (-1);
6685 }
6686 }
6687 else if (outfile_check_dir == NULL)
6688 {
6689 if (mkdir (outfile_check_directory, 0700) == -1)
6690 {
6691 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6692
6693 return (-1);
6694 }
6695 }
6696 }
6697
6698 /**
6699 * special other stuff
6700 */
6701
6702 if (hash_mode == 9710)
6703 {
6704 outfile_format = 5;
6705 outfile_format_chgd = 1;
6706 }
6707
6708 if (hash_mode == 9810)
6709 {
6710 outfile_format = 5;
6711 outfile_format_chgd = 1;
6712 }
6713
6714 if (hash_mode == 10410)
6715 {
6716 outfile_format = 5;
6717 outfile_format_chgd = 1;
6718 }
6719
6720 /**
6721 * store stuff
6722 */
6723
6724 data.hash_mode = hash_mode;
6725 data.restore = restore;
6726 data.restore_timer = restore_timer;
6727 data.restore_disable = restore_disable;
6728 data.status = status;
6729 data.status_timer = status_timer;
6730 data.machine_readable = machine_readable;
6731 data.loopback = loopback;
6732 data.runtime = runtime;
6733 data.remove = remove;
6734 data.remove_timer = remove_timer;
6735 data.debug_mode = debug_mode;
6736 data.debug_file = debug_file;
6737 data.username = username;
6738 data.quiet = quiet;
6739 data.outfile = outfile;
6740 data.outfile_format = outfile_format;
6741 data.outfile_autohex = outfile_autohex;
6742 data.hex_charset = hex_charset;
6743 data.hex_salt = hex_salt;
6744 data.hex_wordlist = hex_wordlist;
6745 data.separator = separator;
6746 data.rp_files = rp_files;
6747 data.rp_files_cnt = rp_files_cnt;
6748 data.rp_gen = rp_gen;
6749 data.rp_gen_seed = rp_gen_seed;
6750 data.force = force;
6751 data.benchmark = benchmark;
6752 data.skip = skip;
6753 data.limit = limit;
6754 #ifdef HAVE_HWMON
6755 data.powertune_enable = powertune_enable;
6756 #endif
6757 data.logfile_disable = logfile_disable;
6758 data.truecrypt_keyfiles = truecrypt_keyfiles;
6759 data.veracrypt_keyfiles = veracrypt_keyfiles;
6760 data.veracrypt_pim = veracrypt_pim;
6761 data.scrypt_tmto = scrypt_tmto;
6762 data.workload_profile = workload_profile;
6763
6764 /**
6765 * cpu affinity
6766 */
6767
6768 if (cpu_affinity)
6769 {
6770 set_cpu_affinity (cpu_affinity);
6771 }
6772
6773 if (rp_gen_seed_chgd == 0)
6774 {
6775 srand (proc_start);
6776 }
6777 else
6778 {
6779 srand (rp_gen_seed);
6780 }
6781
6782 /**
6783 * logfile init
6784 */
6785
6786 if (logfile_disable == 0)
6787 {
6788 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6789
6790 char *logfile = (char *) mymalloc (logfile_size);
6791
6792 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6793
6794 data.logfile = logfile;
6795
6796 char *topid = logfile_generate_topid ();
6797
6798 data.topid = topid;
6799 }
6800
6801 // logfile_append() checks for logfile_disable internally to make it easier from here
6802
6803 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6804 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6805 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6806 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6807 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6808 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6809 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6810 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6811 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6812 #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));
6813
6814 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6815 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6816 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6817 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6818 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6819 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6820 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6821 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6822
6823 logfile_top_msg ("START");
6824
6825 logfile_top_uint (attack_mode);
6826 logfile_top_uint (attack_kern);
6827 logfile_top_uint (benchmark);
6828 logfile_top_uint (bitmap_min);
6829 logfile_top_uint (bitmap_max);
6830 logfile_top_uint (debug_mode);
6831 logfile_top_uint (force);
6832 logfile_top_uint (kernel_accel);
6833 logfile_top_uint (kernel_loops);
6834 logfile_top_uint (gpu_temp_disable);
6835 #ifdef HAVE_HWMON
6836 logfile_top_uint (gpu_temp_abort);
6837 logfile_top_uint (gpu_temp_retain);
6838 #endif
6839 logfile_top_uint (hash_mode);
6840 logfile_top_uint (hex_charset);
6841 logfile_top_uint (hex_salt);
6842 logfile_top_uint (hex_wordlist);
6843 logfile_top_uint (increment);
6844 logfile_top_uint (increment_max);
6845 logfile_top_uint (increment_min);
6846 logfile_top_uint (keyspace);
6847 logfile_top_uint (left);
6848 logfile_top_uint (logfile_disable);
6849 logfile_top_uint (loopback);
6850 logfile_top_uint (markov_classic);
6851 logfile_top_uint (markov_disable);
6852 logfile_top_uint (markov_threshold);
6853 logfile_top_uint (outfile_autohex);
6854 logfile_top_uint (outfile_check_timer);
6855 logfile_top_uint (outfile_format);
6856 logfile_top_uint (potfile_disable);
6857 logfile_top_string (potfile_path);
6858 #if defined(HAVE_HWMON)
6859 logfile_top_uint (powertune_enable);
6860 #endif
6861 logfile_top_uint (scrypt_tmto);
6862 logfile_top_uint (quiet);
6863 logfile_top_uint (remove);
6864 logfile_top_uint (remove_timer);
6865 logfile_top_uint (restore);
6866 logfile_top_uint (restore_disable);
6867 logfile_top_uint (restore_timer);
6868 logfile_top_uint (rp_gen);
6869 logfile_top_uint (rp_gen_func_max);
6870 logfile_top_uint (rp_gen_func_min);
6871 logfile_top_uint (rp_gen_seed);
6872 logfile_top_uint (runtime);
6873 logfile_top_uint (segment_size);
6874 logfile_top_uint (show);
6875 logfile_top_uint (status);
6876 logfile_top_uint (machine_readable);
6877 logfile_top_uint (status_timer);
6878 logfile_top_uint (usage);
6879 logfile_top_uint (username);
6880 logfile_top_uint (version);
6881 logfile_top_uint (weak_hash_threshold);
6882 logfile_top_uint (workload_profile);
6883 logfile_top_uint64 (limit);
6884 logfile_top_uint64 (skip);
6885 logfile_top_char (separator);
6886 logfile_top_string (cpu_affinity);
6887 logfile_top_string (custom_charset_1);
6888 logfile_top_string (custom_charset_2);
6889 logfile_top_string (custom_charset_3);
6890 logfile_top_string (custom_charset_4);
6891 logfile_top_string (debug_file);
6892 logfile_top_string (opencl_devices);
6893 logfile_top_string (opencl_platforms);
6894 logfile_top_string (opencl_device_types);
6895 logfile_top_uint (opencl_vector_width);
6896 logfile_top_string (induction_dir);
6897 logfile_top_string (markov_hcstat);
6898 logfile_top_string (outfile);
6899 logfile_top_string (outfile_check_dir);
6900 logfile_top_string (rule_buf_l);
6901 logfile_top_string (rule_buf_r);
6902 logfile_top_string (session);
6903 logfile_top_string (truecrypt_keyfiles);
6904 logfile_top_string (veracrypt_keyfiles);
6905 logfile_top_uint (veracrypt_pim);
6906
6907 /**
6908 * Init OpenCL library loader
6909 */
6910
6911 if (keyspace == 0)
6912 {
6913 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6914
6915 ocl_init (ocl);
6916
6917 data.ocl = ocl;
6918 }
6919
6920 /**
6921 * OpenCL platform selection
6922 */
6923
6924 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6925
6926 /**
6927 * OpenCL device selection
6928 */
6929
6930 u32 devices_filter = setup_devices_filter (opencl_devices);
6931
6932 /**
6933 * OpenCL device type selection
6934 */
6935
6936 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6937
6938 /**
6939 * benchmark
6940 */
6941
6942 if (benchmark == 1)
6943 {
6944 /**
6945 * disable useless stuff for benchmark
6946 */
6947
6948 status_timer = 0;
6949 restore_timer = 0;
6950 restore_disable = 1;
6951 potfile_disable = 1;
6952 weak_hash_threshold = 0;
6953 gpu_temp_disable = 1;
6954
6955 #ifdef HAVE_HWMON
6956 powertune_enable = 1;
6957 #endif
6958
6959 data.status_timer = status_timer;
6960 data.restore_timer = restore_timer;
6961 data.restore_disable = restore_disable;
6962
6963 /**
6964 * force attack mode to be bruteforce
6965 */
6966
6967 attack_mode = ATTACK_MODE_BF;
6968 attack_kern = ATTACK_KERN_BF;
6969
6970 if (workload_profile_chgd == 0)
6971 {
6972 workload_profile = 3;
6973
6974 data.workload_profile = workload_profile;
6975 }
6976 }
6977
6978 /**
6979 * config
6980 */
6981
6982 uint hash_type = 0;
6983 uint salt_type = 0;
6984 uint attack_exec = 0;
6985 uint opts_type = 0;
6986 uint kern_type = 0;
6987 uint dgst_size = 0;
6988 uint esalt_size = 0;
6989 uint opti_type = 0;
6990 uint dgst_pos0 = -1;
6991 uint dgst_pos1 = -1;
6992 uint dgst_pos2 = -1;
6993 uint dgst_pos3 = -1;
6994
6995 int (*parse_func) (char *, uint, hash_t *);
6996 int (*sort_by_digest) (const void *, const void *);
6997
6998 uint algorithm_pos = 0;
6999 uint algorithm_max = 1;
7000
7001 uint *algorithms = default_benchmark_algorithms;
7002
7003 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7004
7005 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7006 {
7007 /*
7008 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7009 * the following algos are skipped entirely
7010 */
7011
7012 if (algorithm_pos > 0)
7013 {
7014 local_free (rd);
7015
7016 rd = init_restore (argc, argv);
7017
7018 data.rd = rd;
7019 }
7020
7021 /**
7022 * update hash_mode in case of multihash benchmark
7023 */
7024
7025 if (benchmark == 1)
7026 {
7027 if (hash_mode_chgd == 0)
7028 {
7029 hash_mode = algorithms[algorithm_pos];
7030
7031 data.hash_mode = hash_mode;
7032 }
7033
7034 quiet = 1;
7035
7036 data.quiet = quiet;
7037 }
7038
7039 switch (hash_mode)
7040 {
7041 case 0: hash_type = HASH_TYPE_MD5;
7042 salt_type = SALT_TYPE_NONE;
7043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7044 opts_type = OPTS_TYPE_PT_GENERATE_LE
7045 | OPTS_TYPE_PT_ADD80
7046 | OPTS_TYPE_PT_ADDBITS14;
7047 kern_type = KERN_TYPE_MD5;
7048 dgst_size = DGST_SIZE_4_4;
7049 parse_func = md5_parse_hash;
7050 sort_by_digest = sort_by_digest_4_4;
7051 opti_type = OPTI_TYPE_ZERO_BYTE
7052 | OPTI_TYPE_PRECOMPUTE_INIT
7053 | OPTI_TYPE_PRECOMPUTE_MERKLE
7054 | OPTI_TYPE_MEET_IN_MIDDLE
7055 | OPTI_TYPE_EARLY_SKIP
7056 | OPTI_TYPE_NOT_ITERATED
7057 | OPTI_TYPE_NOT_SALTED
7058 | OPTI_TYPE_RAW_HASH;
7059 dgst_pos0 = 0;
7060 dgst_pos1 = 3;
7061 dgst_pos2 = 2;
7062 dgst_pos3 = 1;
7063 break;
7064
7065 case 10: hash_type = HASH_TYPE_MD5;
7066 salt_type = SALT_TYPE_INTERN;
7067 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7068 opts_type = OPTS_TYPE_PT_GENERATE_LE
7069 | OPTS_TYPE_ST_ADD80
7070 | OPTS_TYPE_ST_ADDBITS14;
7071 kern_type = KERN_TYPE_MD5_PWSLT;
7072 dgst_size = DGST_SIZE_4_4;
7073 parse_func = md5s_parse_hash;
7074 sort_by_digest = sort_by_digest_4_4;
7075 opti_type = OPTI_TYPE_ZERO_BYTE
7076 | OPTI_TYPE_PRECOMPUTE_INIT
7077 | OPTI_TYPE_PRECOMPUTE_MERKLE
7078 | OPTI_TYPE_MEET_IN_MIDDLE
7079 | OPTI_TYPE_EARLY_SKIP
7080 | OPTI_TYPE_NOT_ITERATED
7081 | OPTI_TYPE_APPENDED_SALT
7082 | OPTI_TYPE_RAW_HASH;
7083 dgst_pos0 = 0;
7084 dgst_pos1 = 3;
7085 dgst_pos2 = 2;
7086 dgst_pos3 = 1;
7087 break;
7088
7089 case 11: hash_type = HASH_TYPE_MD5;
7090 salt_type = SALT_TYPE_INTERN;
7091 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7092 opts_type = OPTS_TYPE_PT_GENERATE_LE
7093 | OPTS_TYPE_ST_ADD80
7094 | OPTS_TYPE_ST_ADDBITS14;
7095 kern_type = KERN_TYPE_MD5_PWSLT;
7096 dgst_size = DGST_SIZE_4_4;
7097 parse_func = joomla_parse_hash;
7098 sort_by_digest = sort_by_digest_4_4;
7099 opti_type = OPTI_TYPE_ZERO_BYTE
7100 | OPTI_TYPE_PRECOMPUTE_INIT
7101 | OPTI_TYPE_PRECOMPUTE_MERKLE
7102 | OPTI_TYPE_MEET_IN_MIDDLE
7103 | OPTI_TYPE_EARLY_SKIP
7104 | OPTI_TYPE_NOT_ITERATED
7105 | OPTI_TYPE_APPENDED_SALT
7106 | OPTI_TYPE_RAW_HASH;
7107 dgst_pos0 = 0;
7108 dgst_pos1 = 3;
7109 dgst_pos2 = 2;
7110 dgst_pos3 = 1;
7111 break;
7112
7113 case 12: hash_type = HASH_TYPE_MD5;
7114 salt_type = SALT_TYPE_INTERN;
7115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7116 opts_type = OPTS_TYPE_PT_GENERATE_LE
7117 | OPTS_TYPE_ST_ADD80
7118 | OPTS_TYPE_ST_ADDBITS14;
7119 kern_type = KERN_TYPE_MD5_PWSLT;
7120 dgst_size = DGST_SIZE_4_4;
7121 parse_func = postgresql_parse_hash;
7122 sort_by_digest = sort_by_digest_4_4;
7123 opti_type = OPTI_TYPE_ZERO_BYTE
7124 | OPTI_TYPE_PRECOMPUTE_INIT
7125 | OPTI_TYPE_PRECOMPUTE_MERKLE
7126 | OPTI_TYPE_MEET_IN_MIDDLE
7127 | OPTI_TYPE_EARLY_SKIP
7128 | OPTI_TYPE_NOT_ITERATED
7129 | OPTI_TYPE_APPENDED_SALT
7130 | OPTI_TYPE_RAW_HASH;
7131 dgst_pos0 = 0;
7132 dgst_pos1 = 3;
7133 dgst_pos2 = 2;
7134 dgst_pos3 = 1;
7135 break;
7136
7137 case 20: hash_type = HASH_TYPE_MD5;
7138 salt_type = SALT_TYPE_INTERN;
7139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7140 opts_type = OPTS_TYPE_PT_GENERATE_LE
7141 | OPTS_TYPE_PT_ADD80
7142 | OPTS_TYPE_PT_ADDBITS14;
7143 kern_type = KERN_TYPE_MD5_SLTPW;
7144 dgst_size = DGST_SIZE_4_4;
7145 parse_func = md5s_parse_hash;
7146 sort_by_digest = sort_by_digest_4_4;
7147 opti_type = OPTI_TYPE_ZERO_BYTE
7148 | OPTI_TYPE_PRECOMPUTE_INIT
7149 | OPTI_TYPE_PRECOMPUTE_MERKLE
7150 | OPTI_TYPE_EARLY_SKIP
7151 | OPTI_TYPE_NOT_ITERATED
7152 | OPTI_TYPE_PREPENDED_SALT
7153 | OPTI_TYPE_RAW_HASH;
7154 dgst_pos0 = 0;
7155 dgst_pos1 = 3;
7156 dgst_pos2 = 2;
7157 dgst_pos3 = 1;
7158 break;
7159
7160 case 21: hash_type = HASH_TYPE_MD5;
7161 salt_type = SALT_TYPE_INTERN;
7162 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7163 opts_type = OPTS_TYPE_PT_GENERATE_LE
7164 | OPTS_TYPE_PT_ADD80
7165 | OPTS_TYPE_PT_ADDBITS14;
7166 kern_type = KERN_TYPE_MD5_SLTPW;
7167 dgst_size = DGST_SIZE_4_4;
7168 parse_func = osc_parse_hash;
7169 sort_by_digest = sort_by_digest_4_4;
7170 opti_type = OPTI_TYPE_ZERO_BYTE
7171 | OPTI_TYPE_PRECOMPUTE_INIT
7172 | OPTI_TYPE_PRECOMPUTE_MERKLE
7173 | OPTI_TYPE_EARLY_SKIP
7174 | OPTI_TYPE_NOT_ITERATED
7175 | OPTI_TYPE_PREPENDED_SALT
7176 | OPTI_TYPE_RAW_HASH;
7177 dgst_pos0 = 0;
7178 dgst_pos1 = 3;
7179 dgst_pos2 = 2;
7180 dgst_pos3 = 1;
7181 break;
7182
7183 case 22: hash_type = HASH_TYPE_MD5;
7184 salt_type = SALT_TYPE_EMBEDDED;
7185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7186 opts_type = OPTS_TYPE_PT_GENERATE_LE
7187 | OPTS_TYPE_PT_ADD80
7188 | OPTS_TYPE_PT_ADDBITS14;
7189 kern_type = KERN_TYPE_MD5_SLTPW;
7190 dgst_size = DGST_SIZE_4_4;
7191 parse_func = netscreen_parse_hash;
7192 sort_by_digest = sort_by_digest_4_4;
7193 opti_type = OPTI_TYPE_ZERO_BYTE
7194 | OPTI_TYPE_PRECOMPUTE_INIT
7195 | OPTI_TYPE_PRECOMPUTE_MERKLE
7196 | OPTI_TYPE_EARLY_SKIP
7197 | OPTI_TYPE_NOT_ITERATED
7198 | OPTI_TYPE_PREPENDED_SALT
7199 | OPTI_TYPE_RAW_HASH;
7200 dgst_pos0 = 0;
7201 dgst_pos1 = 3;
7202 dgst_pos2 = 2;
7203 dgst_pos3 = 1;
7204 break;
7205
7206 case 23: hash_type = HASH_TYPE_MD5;
7207 salt_type = SALT_TYPE_EMBEDDED;
7208 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7209 opts_type = OPTS_TYPE_PT_GENERATE_LE
7210 | OPTS_TYPE_PT_ADD80
7211 | OPTS_TYPE_PT_ADDBITS14;
7212 kern_type = KERN_TYPE_MD5_SLTPW;
7213 dgst_size = DGST_SIZE_4_4;
7214 parse_func = skype_parse_hash;
7215 sort_by_digest = sort_by_digest_4_4;
7216 opti_type = OPTI_TYPE_ZERO_BYTE
7217 | OPTI_TYPE_PRECOMPUTE_INIT
7218 | OPTI_TYPE_PRECOMPUTE_MERKLE
7219 | OPTI_TYPE_EARLY_SKIP
7220 | OPTI_TYPE_NOT_ITERATED
7221 | OPTI_TYPE_PREPENDED_SALT
7222 | OPTI_TYPE_RAW_HASH;
7223 dgst_pos0 = 0;
7224 dgst_pos1 = 3;
7225 dgst_pos2 = 2;
7226 dgst_pos3 = 1;
7227 break;
7228
7229 case 30: hash_type = HASH_TYPE_MD5;
7230 salt_type = SALT_TYPE_INTERN;
7231 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7232 opts_type = OPTS_TYPE_PT_GENERATE_LE
7233 | OPTS_TYPE_PT_UNICODE
7234 | OPTS_TYPE_ST_ADD80
7235 | OPTS_TYPE_ST_ADDBITS14;
7236 kern_type = KERN_TYPE_MD5_PWUSLT;
7237 dgst_size = DGST_SIZE_4_4;
7238 parse_func = md5s_parse_hash;
7239 sort_by_digest = sort_by_digest_4_4;
7240 opti_type = OPTI_TYPE_ZERO_BYTE
7241 | OPTI_TYPE_PRECOMPUTE_INIT
7242 | OPTI_TYPE_PRECOMPUTE_MERKLE
7243 | OPTI_TYPE_MEET_IN_MIDDLE
7244 | OPTI_TYPE_EARLY_SKIP
7245 | OPTI_TYPE_NOT_ITERATED
7246 | OPTI_TYPE_APPENDED_SALT
7247 | OPTI_TYPE_RAW_HASH;
7248 dgst_pos0 = 0;
7249 dgst_pos1 = 3;
7250 dgst_pos2 = 2;
7251 dgst_pos3 = 1;
7252 break;
7253
7254 case 40: hash_type = HASH_TYPE_MD5;
7255 salt_type = SALT_TYPE_INTERN;
7256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7257 opts_type = OPTS_TYPE_PT_GENERATE_LE
7258 | OPTS_TYPE_PT_ADD80
7259 | OPTS_TYPE_PT_ADDBITS14
7260 | OPTS_TYPE_PT_UNICODE;
7261 kern_type = KERN_TYPE_MD5_SLTPWU;
7262 dgst_size = DGST_SIZE_4_4;
7263 parse_func = md5s_parse_hash;
7264 sort_by_digest = sort_by_digest_4_4;
7265 opti_type = OPTI_TYPE_ZERO_BYTE
7266 | OPTI_TYPE_PRECOMPUTE_INIT
7267 | OPTI_TYPE_PRECOMPUTE_MERKLE
7268 | OPTI_TYPE_EARLY_SKIP
7269 | OPTI_TYPE_NOT_ITERATED
7270 | OPTI_TYPE_PREPENDED_SALT
7271 | OPTI_TYPE_RAW_HASH;
7272 dgst_pos0 = 0;
7273 dgst_pos1 = 3;
7274 dgst_pos2 = 2;
7275 dgst_pos3 = 1;
7276 break;
7277
7278 case 50: hash_type = HASH_TYPE_MD5;
7279 salt_type = SALT_TYPE_INTERN;
7280 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7281 opts_type = OPTS_TYPE_PT_GENERATE_LE
7282 | OPTS_TYPE_ST_ADD80
7283 | OPTS_TYPE_ST_ADDBITS14;
7284 kern_type = KERN_TYPE_HMACMD5_PW;
7285 dgst_size = DGST_SIZE_4_4;
7286 parse_func = hmacmd5_parse_hash;
7287 sort_by_digest = sort_by_digest_4_4;
7288 opti_type = OPTI_TYPE_ZERO_BYTE
7289 | OPTI_TYPE_NOT_ITERATED;
7290 dgst_pos0 = 0;
7291 dgst_pos1 = 3;
7292 dgst_pos2 = 2;
7293 dgst_pos3 = 1;
7294 break;
7295
7296 case 60: hash_type = HASH_TYPE_MD5;
7297 salt_type = SALT_TYPE_INTERN;
7298 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7299 opts_type = OPTS_TYPE_PT_GENERATE_LE
7300 | OPTS_TYPE_PT_ADD80
7301 | OPTS_TYPE_PT_ADDBITS14;
7302 kern_type = KERN_TYPE_HMACMD5_SLT;
7303 dgst_size = DGST_SIZE_4_4;
7304 parse_func = hmacmd5_parse_hash;
7305 sort_by_digest = sort_by_digest_4_4;
7306 opti_type = OPTI_TYPE_ZERO_BYTE
7307 | OPTI_TYPE_NOT_ITERATED;
7308 dgst_pos0 = 0;
7309 dgst_pos1 = 3;
7310 dgst_pos2 = 2;
7311 dgst_pos3 = 1;
7312 break;
7313
7314 case 100: hash_type = HASH_TYPE_SHA1;
7315 salt_type = SALT_TYPE_NONE;
7316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7317 opts_type = OPTS_TYPE_PT_GENERATE_BE
7318 | OPTS_TYPE_PT_ADD80
7319 | OPTS_TYPE_PT_ADDBITS15;
7320 kern_type = KERN_TYPE_SHA1;
7321 dgst_size = DGST_SIZE_4_5;
7322 parse_func = sha1_parse_hash;
7323 sort_by_digest = sort_by_digest_4_5;
7324 opti_type = OPTI_TYPE_ZERO_BYTE
7325 | OPTI_TYPE_PRECOMPUTE_INIT
7326 | OPTI_TYPE_PRECOMPUTE_MERKLE
7327 | OPTI_TYPE_EARLY_SKIP
7328 | OPTI_TYPE_NOT_ITERATED
7329 | OPTI_TYPE_NOT_SALTED
7330 | OPTI_TYPE_RAW_HASH;
7331 dgst_pos0 = 3;
7332 dgst_pos1 = 4;
7333 dgst_pos2 = 2;
7334 dgst_pos3 = 1;
7335 break;
7336
7337 case 101: hash_type = HASH_TYPE_SHA1;
7338 salt_type = SALT_TYPE_NONE;
7339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7340 opts_type = OPTS_TYPE_PT_GENERATE_BE
7341 | OPTS_TYPE_PT_ADD80
7342 | OPTS_TYPE_PT_ADDBITS15;
7343 kern_type = KERN_TYPE_SHA1;
7344 dgst_size = DGST_SIZE_4_5;
7345 parse_func = sha1b64_parse_hash;
7346 sort_by_digest = sort_by_digest_4_5;
7347 opti_type = OPTI_TYPE_ZERO_BYTE
7348 | OPTI_TYPE_PRECOMPUTE_INIT
7349 | OPTI_TYPE_PRECOMPUTE_MERKLE
7350 | OPTI_TYPE_EARLY_SKIP
7351 | OPTI_TYPE_NOT_ITERATED
7352 | OPTI_TYPE_NOT_SALTED
7353 | OPTI_TYPE_RAW_HASH;
7354 dgst_pos0 = 3;
7355 dgst_pos1 = 4;
7356 dgst_pos2 = 2;
7357 dgst_pos3 = 1;
7358 break;
7359
7360 case 110: hash_type = HASH_TYPE_SHA1;
7361 salt_type = SALT_TYPE_INTERN;
7362 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7363 opts_type = OPTS_TYPE_PT_GENERATE_BE
7364 | OPTS_TYPE_ST_ADD80
7365 | OPTS_TYPE_ST_ADDBITS15;
7366 kern_type = KERN_TYPE_SHA1_PWSLT;
7367 dgst_size = DGST_SIZE_4_5;
7368 parse_func = sha1s_parse_hash;
7369 sort_by_digest = sort_by_digest_4_5;
7370 opti_type = OPTI_TYPE_ZERO_BYTE
7371 | OPTI_TYPE_PRECOMPUTE_INIT
7372 | OPTI_TYPE_PRECOMPUTE_MERKLE
7373 | OPTI_TYPE_EARLY_SKIP
7374 | OPTI_TYPE_NOT_ITERATED
7375 | OPTI_TYPE_APPENDED_SALT
7376 | OPTI_TYPE_RAW_HASH;
7377 dgst_pos0 = 3;
7378 dgst_pos1 = 4;
7379 dgst_pos2 = 2;
7380 dgst_pos3 = 1;
7381 break;
7382
7383 case 111: hash_type = HASH_TYPE_SHA1;
7384 salt_type = SALT_TYPE_EMBEDDED;
7385 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7386 opts_type = OPTS_TYPE_PT_GENERATE_BE
7387 | OPTS_TYPE_ST_ADD80
7388 | OPTS_TYPE_ST_ADDBITS15;
7389 kern_type = KERN_TYPE_SHA1_PWSLT;
7390 dgst_size = DGST_SIZE_4_5;
7391 parse_func = sha1b64s_parse_hash;
7392 sort_by_digest = sort_by_digest_4_5;
7393 opti_type = OPTI_TYPE_ZERO_BYTE
7394 | OPTI_TYPE_PRECOMPUTE_INIT
7395 | OPTI_TYPE_PRECOMPUTE_MERKLE
7396 | OPTI_TYPE_EARLY_SKIP
7397 | OPTI_TYPE_NOT_ITERATED
7398 | OPTI_TYPE_APPENDED_SALT
7399 | OPTI_TYPE_RAW_HASH;
7400 dgst_pos0 = 3;
7401 dgst_pos1 = 4;
7402 dgst_pos2 = 2;
7403 dgst_pos3 = 1;
7404 break;
7405
7406 case 112: hash_type = HASH_TYPE_SHA1;
7407 salt_type = SALT_TYPE_INTERN;
7408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7409 opts_type = OPTS_TYPE_PT_GENERATE_BE
7410 | OPTS_TYPE_ST_ADD80
7411 | OPTS_TYPE_ST_ADDBITS15
7412 | OPTS_TYPE_ST_HEX;
7413 kern_type = KERN_TYPE_SHA1_PWSLT;
7414 dgst_size = DGST_SIZE_4_5;
7415 parse_func = oracles_parse_hash;
7416 sort_by_digest = sort_by_digest_4_5;
7417 opti_type = OPTI_TYPE_ZERO_BYTE
7418 | OPTI_TYPE_PRECOMPUTE_INIT
7419 | OPTI_TYPE_PRECOMPUTE_MERKLE
7420 | OPTI_TYPE_EARLY_SKIP
7421 | OPTI_TYPE_NOT_ITERATED
7422 | OPTI_TYPE_APPENDED_SALT
7423 | OPTI_TYPE_RAW_HASH;
7424 dgst_pos0 = 3;
7425 dgst_pos1 = 4;
7426 dgst_pos2 = 2;
7427 dgst_pos3 = 1;
7428 break;
7429
7430 case 120: hash_type = HASH_TYPE_SHA1;
7431 salt_type = SALT_TYPE_INTERN;
7432 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7433 opts_type = OPTS_TYPE_PT_GENERATE_BE
7434 | OPTS_TYPE_PT_ADD80
7435 | OPTS_TYPE_PT_ADDBITS15;
7436 kern_type = KERN_TYPE_SHA1_SLTPW;
7437 dgst_size = DGST_SIZE_4_5;
7438 parse_func = sha1s_parse_hash;
7439 sort_by_digest = sort_by_digest_4_5;
7440 opti_type = OPTI_TYPE_ZERO_BYTE
7441 | OPTI_TYPE_PRECOMPUTE_INIT
7442 | OPTI_TYPE_PRECOMPUTE_MERKLE
7443 | OPTI_TYPE_EARLY_SKIP
7444 | OPTI_TYPE_NOT_ITERATED
7445 | OPTI_TYPE_PREPENDED_SALT
7446 | OPTI_TYPE_RAW_HASH;
7447 dgst_pos0 = 3;
7448 dgst_pos1 = 4;
7449 dgst_pos2 = 2;
7450 dgst_pos3 = 1;
7451 break;
7452
7453 case 121: hash_type = HASH_TYPE_SHA1;
7454 salt_type = SALT_TYPE_INTERN;
7455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7456 opts_type = OPTS_TYPE_PT_GENERATE_BE
7457 | OPTS_TYPE_PT_ADD80
7458 | OPTS_TYPE_PT_ADDBITS15
7459 | OPTS_TYPE_ST_LOWER;
7460 kern_type = KERN_TYPE_SHA1_SLTPW;
7461 dgst_size = DGST_SIZE_4_5;
7462 parse_func = smf_parse_hash;
7463 sort_by_digest = sort_by_digest_4_5;
7464 opti_type = OPTI_TYPE_ZERO_BYTE
7465 | OPTI_TYPE_PRECOMPUTE_INIT
7466 | OPTI_TYPE_PRECOMPUTE_MERKLE
7467 | OPTI_TYPE_EARLY_SKIP
7468 | OPTI_TYPE_NOT_ITERATED
7469 | OPTI_TYPE_PREPENDED_SALT
7470 | OPTI_TYPE_RAW_HASH;
7471 dgst_pos0 = 3;
7472 dgst_pos1 = 4;
7473 dgst_pos2 = 2;
7474 dgst_pos3 = 1;
7475 break;
7476
7477 case 122: hash_type = HASH_TYPE_SHA1;
7478 salt_type = SALT_TYPE_EMBEDDED;
7479 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7480 opts_type = OPTS_TYPE_PT_GENERATE_BE
7481 | OPTS_TYPE_PT_ADD80
7482 | OPTS_TYPE_PT_ADDBITS15
7483 | OPTS_TYPE_ST_HEX;
7484 kern_type = KERN_TYPE_SHA1_SLTPW;
7485 dgst_size = DGST_SIZE_4_5;
7486 parse_func = osx1_parse_hash;
7487 sort_by_digest = sort_by_digest_4_5;
7488 opti_type = OPTI_TYPE_ZERO_BYTE
7489 | OPTI_TYPE_PRECOMPUTE_INIT
7490 | OPTI_TYPE_PRECOMPUTE_MERKLE
7491 | OPTI_TYPE_EARLY_SKIP
7492 | OPTI_TYPE_NOT_ITERATED
7493 | OPTI_TYPE_PREPENDED_SALT
7494 | OPTI_TYPE_RAW_HASH;
7495 dgst_pos0 = 3;
7496 dgst_pos1 = 4;
7497 dgst_pos2 = 2;
7498 dgst_pos3 = 1;
7499 break;
7500
7501 case 124: hash_type = HASH_TYPE_SHA1;
7502 salt_type = SALT_TYPE_EMBEDDED;
7503 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7504 opts_type = OPTS_TYPE_PT_GENERATE_BE
7505 | OPTS_TYPE_PT_ADD80
7506 | OPTS_TYPE_PT_ADDBITS15;
7507 kern_type = KERN_TYPE_SHA1_SLTPW;
7508 dgst_size = DGST_SIZE_4_5;
7509 parse_func = djangosha1_parse_hash;
7510 sort_by_digest = sort_by_digest_4_5;
7511 opti_type = OPTI_TYPE_ZERO_BYTE
7512 | OPTI_TYPE_PRECOMPUTE_INIT
7513 | OPTI_TYPE_PRECOMPUTE_MERKLE
7514 | OPTI_TYPE_EARLY_SKIP
7515 | OPTI_TYPE_NOT_ITERATED
7516 | OPTI_TYPE_PREPENDED_SALT
7517 | OPTI_TYPE_RAW_HASH;
7518 dgst_pos0 = 3;
7519 dgst_pos1 = 4;
7520 dgst_pos2 = 2;
7521 dgst_pos3 = 1;
7522 break;
7523
7524 case 125: hash_type = HASH_TYPE_SHA1;
7525 salt_type = SALT_TYPE_EMBEDDED;
7526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7527 opts_type = OPTS_TYPE_PT_GENERATE_BE
7528 | OPTS_TYPE_PT_ADD80
7529 | OPTS_TYPE_PT_ADDBITS15
7530 | OPTS_TYPE_ST_HEX;
7531 kern_type = KERN_TYPE_SHA1_SLTPW;
7532 dgst_size = DGST_SIZE_4_5;
7533 parse_func = arubaos_parse_hash;
7534 sort_by_digest = sort_by_digest_4_5;
7535 opti_type = OPTI_TYPE_ZERO_BYTE
7536 | OPTI_TYPE_PRECOMPUTE_INIT
7537 | OPTI_TYPE_PRECOMPUTE_MERKLE
7538 | OPTI_TYPE_EARLY_SKIP
7539 | OPTI_TYPE_NOT_ITERATED
7540 | OPTI_TYPE_PREPENDED_SALT
7541 | OPTI_TYPE_RAW_HASH;
7542 dgst_pos0 = 3;
7543 dgst_pos1 = 4;
7544 dgst_pos2 = 2;
7545 dgst_pos3 = 1;
7546 break;
7547
7548 case 130: hash_type = HASH_TYPE_SHA1;
7549 salt_type = SALT_TYPE_INTERN;
7550 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7551 opts_type = OPTS_TYPE_PT_GENERATE_BE
7552 | OPTS_TYPE_PT_UNICODE
7553 | OPTS_TYPE_ST_ADD80
7554 | OPTS_TYPE_ST_ADDBITS15;
7555 kern_type = KERN_TYPE_SHA1_PWUSLT;
7556 dgst_size = DGST_SIZE_4_5;
7557 parse_func = sha1s_parse_hash;
7558 sort_by_digest = sort_by_digest_4_5;
7559 opti_type = OPTI_TYPE_ZERO_BYTE
7560 | OPTI_TYPE_PRECOMPUTE_INIT
7561 | OPTI_TYPE_PRECOMPUTE_MERKLE
7562 | OPTI_TYPE_EARLY_SKIP
7563 | OPTI_TYPE_NOT_ITERATED
7564 | OPTI_TYPE_APPENDED_SALT
7565 | OPTI_TYPE_RAW_HASH;
7566 dgst_pos0 = 3;
7567 dgst_pos1 = 4;
7568 dgst_pos2 = 2;
7569 dgst_pos3 = 1;
7570 break;
7571
7572 case 131: hash_type = HASH_TYPE_SHA1;
7573 salt_type = SALT_TYPE_EMBEDDED;
7574 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7575 opts_type = OPTS_TYPE_PT_GENERATE_BE
7576 | OPTS_TYPE_PT_UNICODE
7577 | OPTS_TYPE_PT_UPPER
7578 | OPTS_TYPE_ST_ADD80
7579 | OPTS_TYPE_ST_ADDBITS15
7580 | OPTS_TYPE_ST_HEX;
7581 kern_type = KERN_TYPE_SHA1_PWUSLT;
7582 dgst_size = DGST_SIZE_4_5;
7583 parse_func = mssql2000_parse_hash;
7584 sort_by_digest = sort_by_digest_4_5;
7585 opti_type = OPTI_TYPE_ZERO_BYTE
7586 | OPTI_TYPE_PRECOMPUTE_INIT
7587 | OPTI_TYPE_PRECOMPUTE_MERKLE
7588 | OPTI_TYPE_EARLY_SKIP
7589 | OPTI_TYPE_NOT_ITERATED
7590 | OPTI_TYPE_APPENDED_SALT
7591 | OPTI_TYPE_RAW_HASH;
7592 dgst_pos0 = 3;
7593 dgst_pos1 = 4;
7594 dgst_pos2 = 2;
7595 dgst_pos3 = 1;
7596 break;
7597
7598 case 132: hash_type = HASH_TYPE_SHA1;
7599 salt_type = SALT_TYPE_EMBEDDED;
7600 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7601 opts_type = OPTS_TYPE_PT_GENERATE_BE
7602 | OPTS_TYPE_PT_UNICODE
7603 | OPTS_TYPE_ST_ADD80
7604 | OPTS_TYPE_ST_ADDBITS15
7605 | OPTS_TYPE_ST_HEX;
7606 kern_type = KERN_TYPE_SHA1_PWUSLT;
7607 dgst_size = DGST_SIZE_4_5;
7608 parse_func = mssql2005_parse_hash;
7609 sort_by_digest = sort_by_digest_4_5;
7610 opti_type = OPTI_TYPE_ZERO_BYTE
7611 | OPTI_TYPE_PRECOMPUTE_INIT
7612 | OPTI_TYPE_PRECOMPUTE_MERKLE
7613 | OPTI_TYPE_EARLY_SKIP
7614 | OPTI_TYPE_NOT_ITERATED
7615 | OPTI_TYPE_APPENDED_SALT
7616 | OPTI_TYPE_RAW_HASH;
7617 dgst_pos0 = 3;
7618 dgst_pos1 = 4;
7619 dgst_pos2 = 2;
7620 dgst_pos3 = 1;
7621 break;
7622
7623 case 133: hash_type = HASH_TYPE_SHA1;
7624 salt_type = SALT_TYPE_EMBEDDED;
7625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7626 opts_type = OPTS_TYPE_PT_GENERATE_BE
7627 | OPTS_TYPE_PT_UNICODE
7628 | OPTS_TYPE_ST_ADD80
7629 | OPTS_TYPE_ST_ADDBITS15;
7630 kern_type = KERN_TYPE_SHA1_PWUSLT;
7631 dgst_size = DGST_SIZE_4_5;
7632 parse_func = peoplesoft_parse_hash;
7633 sort_by_digest = sort_by_digest_4_5;
7634 opti_type = OPTI_TYPE_ZERO_BYTE
7635 | OPTI_TYPE_PRECOMPUTE_INIT
7636 | OPTI_TYPE_PRECOMPUTE_MERKLE
7637 | OPTI_TYPE_EARLY_SKIP
7638 | OPTI_TYPE_NOT_ITERATED
7639 | OPTI_TYPE_APPENDED_SALT
7640 | OPTI_TYPE_RAW_HASH;
7641 dgst_pos0 = 3;
7642 dgst_pos1 = 4;
7643 dgst_pos2 = 2;
7644 dgst_pos3 = 1;
7645 break;
7646
7647 case 140: hash_type = HASH_TYPE_SHA1;
7648 salt_type = SALT_TYPE_INTERN;
7649 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7650 opts_type = OPTS_TYPE_PT_GENERATE_BE
7651 | OPTS_TYPE_PT_ADD80
7652 | OPTS_TYPE_PT_ADDBITS15
7653 | OPTS_TYPE_PT_UNICODE;
7654 kern_type = KERN_TYPE_SHA1_SLTPWU;
7655 dgst_size = DGST_SIZE_4_5;
7656 parse_func = sha1s_parse_hash;
7657 sort_by_digest = sort_by_digest_4_5;
7658 opti_type = OPTI_TYPE_ZERO_BYTE
7659 | OPTI_TYPE_PRECOMPUTE_INIT
7660 | OPTI_TYPE_PRECOMPUTE_MERKLE
7661 | OPTI_TYPE_EARLY_SKIP
7662 | OPTI_TYPE_NOT_ITERATED
7663 | OPTI_TYPE_PREPENDED_SALT
7664 | OPTI_TYPE_RAW_HASH;
7665 dgst_pos0 = 3;
7666 dgst_pos1 = 4;
7667 dgst_pos2 = 2;
7668 dgst_pos3 = 1;
7669 break;
7670
7671 case 141: hash_type = HASH_TYPE_SHA1;
7672 salt_type = SALT_TYPE_EMBEDDED;
7673 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7674 opts_type = OPTS_TYPE_PT_GENERATE_BE
7675 | OPTS_TYPE_PT_ADD80
7676 | OPTS_TYPE_PT_ADDBITS15
7677 | OPTS_TYPE_PT_UNICODE
7678 | OPTS_TYPE_ST_BASE64;
7679 kern_type = KERN_TYPE_SHA1_SLTPWU;
7680 dgst_size = DGST_SIZE_4_5;
7681 parse_func = episerver_parse_hash;
7682 sort_by_digest = sort_by_digest_4_5;
7683 opti_type = OPTI_TYPE_ZERO_BYTE
7684 | OPTI_TYPE_PRECOMPUTE_INIT
7685 | OPTI_TYPE_PRECOMPUTE_MERKLE
7686 | OPTI_TYPE_EARLY_SKIP
7687 | OPTI_TYPE_NOT_ITERATED
7688 | OPTI_TYPE_PREPENDED_SALT
7689 | OPTI_TYPE_RAW_HASH;
7690 dgst_pos0 = 3;
7691 dgst_pos1 = 4;
7692 dgst_pos2 = 2;
7693 dgst_pos3 = 1;
7694 break;
7695
7696 case 150: hash_type = HASH_TYPE_SHA1;
7697 salt_type = SALT_TYPE_INTERN;
7698 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7699 opts_type = OPTS_TYPE_PT_GENERATE_BE
7700 | OPTS_TYPE_ST_ADD80
7701 | OPTS_TYPE_ST_ADDBITS15;
7702 kern_type = KERN_TYPE_HMACSHA1_PW;
7703 dgst_size = DGST_SIZE_4_5;
7704 parse_func = hmacsha1_parse_hash;
7705 sort_by_digest = sort_by_digest_4_5;
7706 opti_type = OPTI_TYPE_ZERO_BYTE
7707 | OPTI_TYPE_NOT_ITERATED;
7708 dgst_pos0 = 3;
7709 dgst_pos1 = 4;
7710 dgst_pos2 = 2;
7711 dgst_pos3 = 1;
7712 break;
7713
7714 case 160: hash_type = HASH_TYPE_SHA1;
7715 salt_type = SALT_TYPE_INTERN;
7716 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7717 opts_type = OPTS_TYPE_PT_GENERATE_BE
7718 | OPTS_TYPE_PT_ADD80
7719 | OPTS_TYPE_PT_ADDBITS15;
7720 kern_type = KERN_TYPE_HMACSHA1_SLT;
7721 dgst_size = DGST_SIZE_4_5;
7722 parse_func = hmacsha1_parse_hash;
7723 sort_by_digest = sort_by_digest_4_5;
7724 opti_type = OPTI_TYPE_ZERO_BYTE
7725 | OPTI_TYPE_NOT_ITERATED;
7726 dgst_pos0 = 3;
7727 dgst_pos1 = 4;
7728 dgst_pos2 = 2;
7729 dgst_pos3 = 1;
7730 break;
7731
7732 case 190: 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_SHA1_LINKEDIN;
7739 dgst_size = DGST_SIZE_4_5;
7740 parse_func = sha1linkedin_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_EARLY_SKIP
7745 | OPTI_TYPE_NOT_ITERATED
7746 | OPTI_TYPE_NOT_SALTED;
7747 dgst_pos0 = 0;
7748 dgst_pos1 = 4;
7749 dgst_pos2 = 3;
7750 dgst_pos3 = 2;
7751 break;
7752
7753 case 200: hash_type = HASH_TYPE_MYSQL;
7754 salt_type = SALT_TYPE_NONE;
7755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7756 opts_type = 0;
7757 kern_type = KERN_TYPE_MYSQL;
7758 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7759 parse_func = mysql323_parse_hash;
7760 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7761 opti_type = OPTI_TYPE_ZERO_BYTE;
7762 dgst_pos0 = 0;
7763 dgst_pos1 = 1;
7764 dgst_pos2 = 2;
7765 dgst_pos3 = 3;
7766 break;
7767
7768 case 300: hash_type = HASH_TYPE_SHA1;
7769 salt_type = SALT_TYPE_NONE;
7770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7771 opts_type = OPTS_TYPE_PT_GENERATE_BE
7772 | OPTS_TYPE_PT_ADD80
7773 | OPTS_TYPE_PT_ADDBITS15;
7774 kern_type = KERN_TYPE_MYSQL41;
7775 dgst_size = DGST_SIZE_4_5;
7776 parse_func = sha1_parse_hash;
7777 sort_by_digest = sort_by_digest_4_5;
7778 opti_type = OPTI_TYPE_ZERO_BYTE
7779 | OPTI_TYPE_PRECOMPUTE_INIT
7780 | OPTI_TYPE_PRECOMPUTE_MERKLE
7781 | OPTI_TYPE_EARLY_SKIP
7782 | OPTI_TYPE_NOT_ITERATED
7783 | OPTI_TYPE_NOT_SALTED;
7784 dgst_pos0 = 3;
7785 dgst_pos1 = 4;
7786 dgst_pos2 = 2;
7787 dgst_pos3 = 1;
7788 break;
7789
7790 case 400: hash_type = HASH_TYPE_MD5;
7791 salt_type = SALT_TYPE_EMBEDDED;
7792 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7793 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7794 kern_type = KERN_TYPE_PHPASS;
7795 dgst_size = DGST_SIZE_4_4;
7796 parse_func = phpass_parse_hash;
7797 sort_by_digest = sort_by_digest_4_4;
7798 opti_type = OPTI_TYPE_ZERO_BYTE
7799 | OPTI_TYPE_SLOW_HASH_SIMD;
7800 dgst_pos0 = 0;
7801 dgst_pos1 = 1;
7802 dgst_pos2 = 2;
7803 dgst_pos3 = 3;
7804 break;
7805
7806 case 500: hash_type = HASH_TYPE_MD5;
7807 salt_type = SALT_TYPE_EMBEDDED;
7808 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7809 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7810 kern_type = KERN_TYPE_MD5CRYPT;
7811 dgst_size = DGST_SIZE_4_4;
7812 parse_func = md5crypt_parse_hash;
7813 sort_by_digest = sort_by_digest_4_4;
7814 opti_type = OPTI_TYPE_ZERO_BYTE;
7815 dgst_pos0 = 0;
7816 dgst_pos1 = 1;
7817 dgst_pos2 = 2;
7818 dgst_pos3 = 3;
7819 break;
7820
7821 case 501: hash_type = HASH_TYPE_MD5;
7822 salt_type = SALT_TYPE_EMBEDDED;
7823 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7824 opts_type = OPTS_TYPE_PT_GENERATE_LE
7825 | OPTS_TYPE_HASH_COPY;
7826 kern_type = KERN_TYPE_MD5CRYPT;
7827 dgst_size = DGST_SIZE_4_4;
7828 parse_func = juniper_parse_hash;
7829 sort_by_digest = sort_by_digest_4_4;
7830 opti_type = OPTI_TYPE_ZERO_BYTE;
7831 dgst_pos0 = 0;
7832 dgst_pos1 = 1;
7833 dgst_pos2 = 2;
7834 dgst_pos3 = 3;
7835 break;
7836
7837 case 900: hash_type = HASH_TYPE_MD4;
7838 salt_type = SALT_TYPE_NONE;
7839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7840 opts_type = OPTS_TYPE_PT_GENERATE_LE
7841 | OPTS_TYPE_PT_ADD80
7842 | OPTS_TYPE_PT_ADDBITS14;
7843 kern_type = KERN_TYPE_MD4;
7844 dgst_size = DGST_SIZE_4_4;
7845 parse_func = md4_parse_hash;
7846 sort_by_digest = sort_by_digest_4_4;
7847 opti_type = OPTI_TYPE_ZERO_BYTE
7848 | OPTI_TYPE_PRECOMPUTE_INIT
7849 | OPTI_TYPE_PRECOMPUTE_MERKLE
7850 | OPTI_TYPE_MEET_IN_MIDDLE
7851 | OPTI_TYPE_EARLY_SKIP
7852 | OPTI_TYPE_NOT_ITERATED
7853 | OPTI_TYPE_NOT_SALTED
7854 | OPTI_TYPE_RAW_HASH;
7855 dgst_pos0 = 0;
7856 dgst_pos1 = 3;
7857 dgst_pos2 = 2;
7858 dgst_pos3 = 1;
7859 break;
7860
7861 case 1000: hash_type = HASH_TYPE_MD4;
7862 salt_type = SALT_TYPE_NONE;
7863 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7864 opts_type = OPTS_TYPE_PT_GENERATE_LE
7865 | OPTS_TYPE_PT_ADD80
7866 | OPTS_TYPE_PT_ADDBITS14
7867 | OPTS_TYPE_PT_UNICODE;
7868 kern_type = KERN_TYPE_MD4_PWU;
7869 dgst_size = DGST_SIZE_4_4;
7870 parse_func = md4_parse_hash;
7871 sort_by_digest = sort_by_digest_4_4;
7872 opti_type = OPTI_TYPE_ZERO_BYTE
7873 | OPTI_TYPE_PRECOMPUTE_INIT
7874 | OPTI_TYPE_PRECOMPUTE_MERKLE
7875 | OPTI_TYPE_MEET_IN_MIDDLE
7876 | OPTI_TYPE_EARLY_SKIP
7877 | OPTI_TYPE_NOT_ITERATED
7878 | OPTI_TYPE_NOT_SALTED
7879 | OPTI_TYPE_RAW_HASH;
7880 dgst_pos0 = 0;
7881 dgst_pos1 = 3;
7882 dgst_pos2 = 2;
7883 dgst_pos3 = 1;
7884 break;
7885
7886 case 1100: hash_type = HASH_TYPE_MD4;
7887 salt_type = SALT_TYPE_INTERN;
7888 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7889 opts_type = OPTS_TYPE_PT_GENERATE_LE
7890 | OPTS_TYPE_PT_ADD80
7891 | OPTS_TYPE_PT_ADDBITS14
7892 | OPTS_TYPE_PT_UNICODE
7893 | OPTS_TYPE_ST_ADD80
7894 | OPTS_TYPE_ST_UNICODE
7895 | OPTS_TYPE_ST_LOWER;
7896 kern_type = KERN_TYPE_MD44_PWUSLT;
7897 dgst_size = DGST_SIZE_4_4;
7898 parse_func = dcc_parse_hash;
7899 sort_by_digest = sort_by_digest_4_4;
7900 opti_type = OPTI_TYPE_ZERO_BYTE
7901 | OPTI_TYPE_PRECOMPUTE_INIT
7902 | OPTI_TYPE_PRECOMPUTE_MERKLE
7903 | OPTI_TYPE_EARLY_SKIP
7904 | OPTI_TYPE_NOT_ITERATED;
7905 dgst_pos0 = 0;
7906 dgst_pos1 = 3;
7907 dgst_pos2 = 2;
7908 dgst_pos3 = 1;
7909 break;
7910
7911 case 1400: hash_type = HASH_TYPE_SHA256;
7912 salt_type = SALT_TYPE_NONE;
7913 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7914 opts_type = OPTS_TYPE_PT_GENERATE_BE
7915 | OPTS_TYPE_PT_ADD80
7916 | OPTS_TYPE_PT_ADDBITS15;
7917 kern_type = KERN_TYPE_SHA256;
7918 dgst_size = DGST_SIZE_4_8;
7919 parse_func = sha256_parse_hash;
7920 sort_by_digest = sort_by_digest_4_8;
7921 opti_type = OPTI_TYPE_ZERO_BYTE
7922 | OPTI_TYPE_PRECOMPUTE_INIT
7923 | OPTI_TYPE_PRECOMPUTE_MERKLE
7924 | OPTI_TYPE_EARLY_SKIP
7925 | OPTI_TYPE_NOT_ITERATED
7926 | OPTI_TYPE_NOT_SALTED
7927 | OPTI_TYPE_RAW_HASH;
7928 dgst_pos0 = 3;
7929 dgst_pos1 = 7;
7930 dgst_pos2 = 2;
7931 dgst_pos3 = 6;
7932 break;
7933
7934 case 1410: hash_type = HASH_TYPE_SHA256;
7935 salt_type = SALT_TYPE_INTERN;
7936 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7937 opts_type = OPTS_TYPE_PT_GENERATE_BE
7938 | OPTS_TYPE_ST_ADD80
7939 | OPTS_TYPE_ST_ADDBITS15;
7940 kern_type = KERN_TYPE_SHA256_PWSLT;
7941 dgst_size = DGST_SIZE_4_8;
7942 parse_func = sha256s_parse_hash;
7943 sort_by_digest = sort_by_digest_4_8;
7944 opti_type = OPTI_TYPE_ZERO_BYTE
7945 | OPTI_TYPE_PRECOMPUTE_INIT
7946 | OPTI_TYPE_PRECOMPUTE_MERKLE
7947 | OPTI_TYPE_EARLY_SKIP
7948 | OPTI_TYPE_NOT_ITERATED
7949 | OPTI_TYPE_APPENDED_SALT
7950 | OPTI_TYPE_RAW_HASH;
7951 dgst_pos0 = 3;
7952 dgst_pos1 = 7;
7953 dgst_pos2 = 2;
7954 dgst_pos3 = 6;
7955 break;
7956
7957 case 1420: hash_type = HASH_TYPE_SHA256;
7958 salt_type = SALT_TYPE_INTERN;
7959 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7960 opts_type = OPTS_TYPE_PT_GENERATE_BE
7961 | OPTS_TYPE_PT_ADD80
7962 | OPTS_TYPE_PT_ADDBITS15;
7963 kern_type = KERN_TYPE_SHA256_SLTPW;
7964 dgst_size = DGST_SIZE_4_8;
7965 parse_func = sha256s_parse_hash;
7966 sort_by_digest = sort_by_digest_4_8;
7967 opti_type = OPTI_TYPE_ZERO_BYTE
7968 | OPTI_TYPE_PRECOMPUTE_INIT
7969 | OPTI_TYPE_PRECOMPUTE_MERKLE
7970 | OPTI_TYPE_EARLY_SKIP
7971 | OPTI_TYPE_NOT_ITERATED
7972 | OPTI_TYPE_PREPENDED_SALT
7973 | OPTI_TYPE_RAW_HASH;
7974 dgst_pos0 = 3;
7975 dgst_pos1 = 7;
7976 dgst_pos2 = 2;
7977 dgst_pos3 = 6;
7978 break;
7979
7980 case 1421: hash_type = HASH_TYPE_SHA256;
7981 salt_type = SALT_TYPE_EMBEDDED;
7982 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7983 opts_type = OPTS_TYPE_PT_GENERATE_BE
7984 | OPTS_TYPE_PT_ADD80
7985 | OPTS_TYPE_PT_ADDBITS15;
7986 kern_type = KERN_TYPE_SHA256_SLTPW;
7987 dgst_size = DGST_SIZE_4_8;
7988 parse_func = hmailserver_parse_hash;
7989 sort_by_digest = sort_by_digest_4_8;
7990 opti_type = OPTI_TYPE_ZERO_BYTE
7991 | OPTI_TYPE_PRECOMPUTE_INIT
7992 | OPTI_TYPE_PRECOMPUTE_MERKLE
7993 | OPTI_TYPE_EARLY_SKIP
7994 | OPTI_TYPE_NOT_ITERATED
7995 | OPTI_TYPE_PREPENDED_SALT
7996 | OPTI_TYPE_RAW_HASH;
7997 dgst_pos0 = 3;
7998 dgst_pos1 = 7;
7999 dgst_pos2 = 2;
8000 dgst_pos3 = 6;
8001 break;
8002
8003 case 1430: hash_type = HASH_TYPE_SHA256;
8004 salt_type = SALT_TYPE_INTERN;
8005 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8006 opts_type = OPTS_TYPE_PT_GENERATE_BE
8007 | OPTS_TYPE_PT_UNICODE
8008 | OPTS_TYPE_ST_ADD80
8009 | OPTS_TYPE_ST_ADDBITS15;
8010 kern_type = KERN_TYPE_SHA256_PWUSLT;
8011 dgst_size = DGST_SIZE_4_8;
8012 parse_func = sha256s_parse_hash;
8013 sort_by_digest = sort_by_digest_4_8;
8014 opti_type = OPTI_TYPE_ZERO_BYTE
8015 | OPTI_TYPE_PRECOMPUTE_INIT
8016 | OPTI_TYPE_PRECOMPUTE_MERKLE
8017 | OPTI_TYPE_EARLY_SKIP
8018 | OPTI_TYPE_NOT_ITERATED
8019 | OPTI_TYPE_APPENDED_SALT
8020 | OPTI_TYPE_RAW_HASH;
8021 dgst_pos0 = 3;
8022 dgst_pos1 = 7;
8023 dgst_pos2 = 2;
8024 dgst_pos3 = 6;
8025 break;
8026
8027 case 1440: hash_type = HASH_TYPE_SHA256;
8028 salt_type = SALT_TYPE_INTERN;
8029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8030 opts_type = OPTS_TYPE_PT_GENERATE_BE
8031 | OPTS_TYPE_PT_ADD80
8032 | OPTS_TYPE_PT_ADDBITS15
8033 | OPTS_TYPE_PT_UNICODE;
8034 kern_type = KERN_TYPE_SHA256_SLTPWU;
8035 dgst_size = DGST_SIZE_4_8;
8036 parse_func = sha256s_parse_hash;
8037 sort_by_digest = sort_by_digest_4_8;
8038 opti_type = OPTI_TYPE_ZERO_BYTE
8039 | OPTI_TYPE_PRECOMPUTE_INIT
8040 | OPTI_TYPE_PRECOMPUTE_MERKLE
8041 | OPTI_TYPE_EARLY_SKIP
8042 | OPTI_TYPE_NOT_ITERATED
8043 | OPTI_TYPE_PREPENDED_SALT
8044 | OPTI_TYPE_RAW_HASH;
8045 dgst_pos0 = 3;
8046 dgst_pos1 = 7;
8047 dgst_pos2 = 2;
8048 dgst_pos3 = 6;
8049 break;
8050
8051 case 1441: hash_type = HASH_TYPE_SHA256;
8052 salt_type = SALT_TYPE_EMBEDDED;
8053 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8054 opts_type = OPTS_TYPE_PT_GENERATE_BE
8055 | OPTS_TYPE_PT_ADD80
8056 | OPTS_TYPE_PT_ADDBITS15
8057 | OPTS_TYPE_PT_UNICODE
8058 | OPTS_TYPE_ST_BASE64;
8059 kern_type = KERN_TYPE_SHA256_SLTPWU;
8060 dgst_size = DGST_SIZE_4_8;
8061 parse_func = episerver4_parse_hash;
8062 sort_by_digest = sort_by_digest_4_8;
8063 opti_type = OPTI_TYPE_ZERO_BYTE
8064 | OPTI_TYPE_PRECOMPUTE_INIT
8065 | OPTI_TYPE_PRECOMPUTE_MERKLE
8066 | OPTI_TYPE_EARLY_SKIP
8067 | OPTI_TYPE_NOT_ITERATED
8068 | OPTI_TYPE_PREPENDED_SALT
8069 | OPTI_TYPE_RAW_HASH;
8070 dgst_pos0 = 3;
8071 dgst_pos1 = 7;
8072 dgst_pos2 = 2;
8073 dgst_pos3 = 6;
8074 break;
8075
8076 case 1450: hash_type = HASH_TYPE_SHA256;
8077 salt_type = SALT_TYPE_INTERN;
8078 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8079 opts_type = OPTS_TYPE_PT_GENERATE_BE
8080 | OPTS_TYPE_ST_ADD80;
8081 kern_type = KERN_TYPE_HMACSHA256_PW;
8082 dgst_size = DGST_SIZE_4_8;
8083 parse_func = hmacsha256_parse_hash;
8084 sort_by_digest = sort_by_digest_4_8;
8085 opti_type = OPTI_TYPE_ZERO_BYTE
8086 | OPTI_TYPE_NOT_ITERATED;
8087 dgst_pos0 = 3;
8088 dgst_pos1 = 7;
8089 dgst_pos2 = 2;
8090 dgst_pos3 = 6;
8091 break;
8092
8093 case 1460: hash_type = HASH_TYPE_SHA256;
8094 salt_type = SALT_TYPE_INTERN;
8095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8096 opts_type = OPTS_TYPE_PT_GENERATE_BE
8097 | OPTS_TYPE_PT_ADD80
8098 | OPTS_TYPE_PT_ADDBITS15;
8099 kern_type = KERN_TYPE_HMACSHA256_SLT;
8100 dgst_size = DGST_SIZE_4_8;
8101 parse_func = hmacsha256_parse_hash;
8102 sort_by_digest = sort_by_digest_4_8;
8103 opti_type = OPTI_TYPE_ZERO_BYTE
8104 | OPTI_TYPE_NOT_ITERATED;
8105 dgst_pos0 = 3;
8106 dgst_pos1 = 7;
8107 dgst_pos2 = 2;
8108 dgst_pos3 = 6;
8109 break;
8110
8111 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8112 salt_type = SALT_TYPE_EMBEDDED;
8113 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8114 opts_type = OPTS_TYPE_PT_GENERATE_LE
8115 | OPTS_TYPE_PT_BITSLICE;
8116 kern_type = KERN_TYPE_DESCRYPT;
8117 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8118 parse_func = descrypt_parse_hash;
8119 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8120 opti_type = OPTI_TYPE_ZERO_BYTE
8121 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8122 dgst_pos0 = 0;
8123 dgst_pos1 = 1;
8124 dgst_pos2 = 2;
8125 dgst_pos3 = 3;
8126 break;
8127
8128 case 1600: hash_type = HASH_TYPE_MD5;
8129 salt_type = SALT_TYPE_EMBEDDED;
8130 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8131 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8132 kern_type = KERN_TYPE_APR1CRYPT;
8133 dgst_size = DGST_SIZE_4_4;
8134 parse_func = md5apr1_parse_hash;
8135 sort_by_digest = sort_by_digest_4_4;
8136 opti_type = OPTI_TYPE_ZERO_BYTE;
8137 dgst_pos0 = 0;
8138 dgst_pos1 = 1;
8139 dgst_pos2 = 2;
8140 dgst_pos3 = 3;
8141 break;
8142
8143 case 1700: hash_type = HASH_TYPE_SHA512;
8144 salt_type = SALT_TYPE_NONE;
8145 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8146 opts_type = OPTS_TYPE_PT_GENERATE_BE
8147 | OPTS_TYPE_PT_ADD80
8148 | OPTS_TYPE_PT_ADDBITS15;
8149 kern_type = KERN_TYPE_SHA512;
8150 dgst_size = DGST_SIZE_8_8;
8151 parse_func = sha512_parse_hash;
8152 sort_by_digest = sort_by_digest_8_8;
8153 opti_type = OPTI_TYPE_ZERO_BYTE
8154 | OPTI_TYPE_PRECOMPUTE_INIT
8155 | OPTI_TYPE_PRECOMPUTE_MERKLE
8156 | OPTI_TYPE_EARLY_SKIP
8157 | OPTI_TYPE_NOT_ITERATED
8158 | OPTI_TYPE_NOT_SALTED
8159 | OPTI_TYPE_USES_BITS_64
8160 | OPTI_TYPE_RAW_HASH;
8161 dgst_pos0 = 14;
8162 dgst_pos1 = 15;
8163 dgst_pos2 = 6;
8164 dgst_pos3 = 7;
8165 break;
8166
8167 case 1710: hash_type = HASH_TYPE_SHA512;
8168 salt_type = SALT_TYPE_INTERN;
8169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8170 opts_type = OPTS_TYPE_PT_GENERATE_BE
8171 | OPTS_TYPE_ST_ADD80
8172 | OPTS_TYPE_ST_ADDBITS15;
8173 kern_type = KERN_TYPE_SHA512_PWSLT;
8174 dgst_size = DGST_SIZE_8_8;
8175 parse_func = sha512s_parse_hash;
8176 sort_by_digest = sort_by_digest_8_8;
8177 opti_type = OPTI_TYPE_ZERO_BYTE
8178 | OPTI_TYPE_PRECOMPUTE_INIT
8179 | OPTI_TYPE_PRECOMPUTE_MERKLE
8180 | OPTI_TYPE_EARLY_SKIP
8181 | OPTI_TYPE_NOT_ITERATED
8182 | OPTI_TYPE_APPENDED_SALT
8183 | OPTI_TYPE_USES_BITS_64
8184 | OPTI_TYPE_RAW_HASH;
8185 dgst_pos0 = 14;
8186 dgst_pos1 = 15;
8187 dgst_pos2 = 6;
8188 dgst_pos3 = 7;
8189 break;
8190
8191 case 1711: hash_type = HASH_TYPE_SHA512;
8192 salt_type = SALT_TYPE_EMBEDDED;
8193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8194 opts_type = OPTS_TYPE_PT_GENERATE_BE
8195 | OPTS_TYPE_ST_ADD80
8196 | OPTS_TYPE_ST_ADDBITS15;
8197 kern_type = KERN_TYPE_SHA512_PWSLT;
8198 dgst_size = DGST_SIZE_8_8;
8199 parse_func = sha512b64s_parse_hash;
8200 sort_by_digest = sort_by_digest_8_8;
8201 opti_type = OPTI_TYPE_ZERO_BYTE
8202 | OPTI_TYPE_PRECOMPUTE_INIT
8203 | OPTI_TYPE_PRECOMPUTE_MERKLE
8204 | OPTI_TYPE_EARLY_SKIP
8205 | OPTI_TYPE_NOT_ITERATED
8206 | OPTI_TYPE_APPENDED_SALT
8207 | OPTI_TYPE_USES_BITS_64
8208 | OPTI_TYPE_RAW_HASH;
8209 dgst_pos0 = 14;
8210 dgst_pos1 = 15;
8211 dgst_pos2 = 6;
8212 dgst_pos3 = 7;
8213 break;
8214
8215 case 1720: hash_type = HASH_TYPE_SHA512;
8216 salt_type = SALT_TYPE_INTERN;
8217 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8218 opts_type = OPTS_TYPE_PT_GENERATE_BE
8219 | OPTS_TYPE_PT_ADD80
8220 | OPTS_TYPE_PT_ADDBITS15;
8221 kern_type = KERN_TYPE_SHA512_SLTPW;
8222 dgst_size = DGST_SIZE_8_8;
8223 parse_func = sha512s_parse_hash;
8224 sort_by_digest = sort_by_digest_8_8;
8225 opti_type = OPTI_TYPE_ZERO_BYTE
8226 | OPTI_TYPE_PRECOMPUTE_INIT
8227 | OPTI_TYPE_PRECOMPUTE_MERKLE
8228 | OPTI_TYPE_EARLY_SKIP
8229 | OPTI_TYPE_NOT_ITERATED
8230 | OPTI_TYPE_PREPENDED_SALT
8231 | OPTI_TYPE_USES_BITS_64
8232 | OPTI_TYPE_RAW_HASH;
8233 dgst_pos0 = 14;
8234 dgst_pos1 = 15;
8235 dgst_pos2 = 6;
8236 dgst_pos3 = 7;
8237 break;
8238
8239 case 1722: hash_type = HASH_TYPE_SHA512;
8240 salt_type = SALT_TYPE_EMBEDDED;
8241 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8242 opts_type = OPTS_TYPE_PT_GENERATE_BE
8243 | OPTS_TYPE_PT_ADD80
8244 | OPTS_TYPE_PT_ADDBITS15
8245 | OPTS_TYPE_ST_HEX;
8246 kern_type = KERN_TYPE_SHA512_SLTPW;
8247 dgst_size = DGST_SIZE_8_8;
8248 parse_func = osx512_parse_hash;
8249 sort_by_digest = sort_by_digest_8_8;
8250 opti_type = OPTI_TYPE_ZERO_BYTE
8251 | OPTI_TYPE_PRECOMPUTE_INIT
8252 | OPTI_TYPE_PRECOMPUTE_MERKLE
8253 | OPTI_TYPE_EARLY_SKIP
8254 | OPTI_TYPE_NOT_ITERATED
8255 | OPTI_TYPE_PREPENDED_SALT
8256 | OPTI_TYPE_USES_BITS_64
8257 | OPTI_TYPE_RAW_HASH;
8258 dgst_pos0 = 14;
8259 dgst_pos1 = 15;
8260 dgst_pos2 = 6;
8261 dgst_pos3 = 7;
8262 break;
8263
8264 case 1730: hash_type = HASH_TYPE_SHA512;
8265 salt_type = SALT_TYPE_INTERN;
8266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8267 opts_type = OPTS_TYPE_PT_GENERATE_BE
8268 | OPTS_TYPE_PT_UNICODE
8269 | OPTS_TYPE_ST_ADD80
8270 | OPTS_TYPE_ST_ADDBITS15;
8271 kern_type = KERN_TYPE_SHA512_PWSLTU;
8272 dgst_size = DGST_SIZE_8_8;
8273 parse_func = sha512s_parse_hash;
8274 sort_by_digest = sort_by_digest_8_8;
8275 opti_type = OPTI_TYPE_ZERO_BYTE
8276 | OPTI_TYPE_PRECOMPUTE_INIT
8277 | OPTI_TYPE_PRECOMPUTE_MERKLE
8278 | OPTI_TYPE_EARLY_SKIP
8279 | OPTI_TYPE_NOT_ITERATED
8280 | OPTI_TYPE_APPENDED_SALT
8281 | OPTI_TYPE_USES_BITS_64
8282 | OPTI_TYPE_RAW_HASH;
8283 dgst_pos0 = 14;
8284 dgst_pos1 = 15;
8285 dgst_pos2 = 6;
8286 dgst_pos3 = 7;
8287 break;
8288
8289 case 1731: hash_type = HASH_TYPE_SHA512;
8290 salt_type = SALT_TYPE_EMBEDDED;
8291 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8292 opts_type = OPTS_TYPE_PT_GENERATE_BE
8293 | OPTS_TYPE_PT_UNICODE
8294 | OPTS_TYPE_ST_ADD80
8295 | OPTS_TYPE_ST_ADDBITS15
8296 | OPTS_TYPE_ST_HEX;
8297 kern_type = KERN_TYPE_SHA512_PWSLTU;
8298 dgst_size = DGST_SIZE_8_8;
8299 parse_func = mssql2012_parse_hash;
8300 sort_by_digest = sort_by_digest_8_8;
8301 opti_type = OPTI_TYPE_ZERO_BYTE
8302 | OPTI_TYPE_PRECOMPUTE_INIT
8303 | OPTI_TYPE_PRECOMPUTE_MERKLE
8304 | OPTI_TYPE_EARLY_SKIP
8305 | OPTI_TYPE_NOT_ITERATED
8306 | OPTI_TYPE_APPENDED_SALT
8307 | OPTI_TYPE_USES_BITS_64
8308 | OPTI_TYPE_RAW_HASH;
8309 dgst_pos0 = 14;
8310 dgst_pos1 = 15;
8311 dgst_pos2 = 6;
8312 dgst_pos3 = 7;
8313 break;
8314
8315 case 1740: hash_type = HASH_TYPE_SHA512;
8316 salt_type = SALT_TYPE_INTERN;
8317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8318 opts_type = OPTS_TYPE_PT_GENERATE_BE
8319 | OPTS_TYPE_PT_ADD80
8320 | OPTS_TYPE_PT_ADDBITS15
8321 | OPTS_TYPE_PT_UNICODE;
8322 kern_type = KERN_TYPE_SHA512_SLTPWU;
8323 dgst_size = DGST_SIZE_8_8;
8324 parse_func = sha512s_parse_hash;
8325 sort_by_digest = sort_by_digest_8_8;
8326 opti_type = OPTI_TYPE_ZERO_BYTE
8327 | OPTI_TYPE_PRECOMPUTE_INIT
8328 | OPTI_TYPE_PRECOMPUTE_MERKLE
8329 | OPTI_TYPE_EARLY_SKIP
8330 | OPTI_TYPE_NOT_ITERATED
8331 | OPTI_TYPE_PREPENDED_SALT
8332 | OPTI_TYPE_USES_BITS_64
8333 | OPTI_TYPE_RAW_HASH;
8334 dgst_pos0 = 14;
8335 dgst_pos1 = 15;
8336 dgst_pos2 = 6;
8337 dgst_pos3 = 7;
8338 break;
8339
8340 case 1750: hash_type = HASH_TYPE_SHA512;
8341 salt_type = SALT_TYPE_INTERN;
8342 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8343 opts_type = OPTS_TYPE_PT_GENERATE_BE
8344 | OPTS_TYPE_ST_ADD80;
8345 kern_type = KERN_TYPE_HMACSHA512_PW;
8346 dgst_size = DGST_SIZE_8_8;
8347 parse_func = hmacsha512_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 | OPTI_TYPE_NOT_ITERATED;
8352 dgst_pos0 = 14;
8353 dgst_pos1 = 15;
8354 dgst_pos2 = 6;
8355 dgst_pos3 = 7;
8356 break;
8357
8358 case 1760: hash_type = HASH_TYPE_SHA512;
8359 salt_type = SALT_TYPE_INTERN;
8360 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8361 opts_type = OPTS_TYPE_PT_GENERATE_BE
8362 | OPTS_TYPE_PT_ADD80
8363 | OPTS_TYPE_PT_ADDBITS15;
8364 kern_type = KERN_TYPE_HMACSHA512_SLT;
8365 dgst_size = DGST_SIZE_8_8;
8366 parse_func = hmacsha512_parse_hash;
8367 sort_by_digest = sort_by_digest_8_8;
8368 opti_type = OPTI_TYPE_ZERO_BYTE
8369 | OPTI_TYPE_USES_BITS_64
8370 | OPTI_TYPE_NOT_ITERATED;
8371 dgst_pos0 = 14;
8372 dgst_pos1 = 15;
8373 dgst_pos2 = 6;
8374 dgst_pos3 = 7;
8375 break;
8376
8377 case 1800: hash_type = HASH_TYPE_SHA512;
8378 salt_type = SALT_TYPE_EMBEDDED;
8379 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8380 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8381 kern_type = KERN_TYPE_SHA512CRYPT;
8382 dgst_size = DGST_SIZE_8_8;
8383 parse_func = sha512crypt_parse_hash;
8384 sort_by_digest = sort_by_digest_8_8;
8385 opti_type = OPTI_TYPE_ZERO_BYTE
8386 | OPTI_TYPE_USES_BITS_64;
8387 dgst_pos0 = 0;
8388 dgst_pos1 = 1;
8389 dgst_pos2 = 2;
8390 dgst_pos3 = 3;
8391 break;
8392
8393 case 2100: hash_type = HASH_TYPE_DCC2;
8394 salt_type = SALT_TYPE_EMBEDDED;
8395 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8396 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8397 | OPTS_TYPE_ST_LOWER
8398 | OPTS_TYPE_ST_UNICODE;
8399 kern_type = KERN_TYPE_DCC2;
8400 dgst_size = DGST_SIZE_4_4;
8401 parse_func = dcc2_parse_hash;
8402 sort_by_digest = sort_by_digest_4_4;
8403 opti_type = OPTI_TYPE_ZERO_BYTE
8404 | OPTI_TYPE_SLOW_HASH_SIMD;
8405 dgst_pos0 = 0;
8406 dgst_pos1 = 1;
8407 dgst_pos2 = 2;
8408 dgst_pos3 = 3;
8409 break;
8410
8411 case 2400: hash_type = HASH_TYPE_MD5;
8412 salt_type = SALT_TYPE_NONE;
8413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8414 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8415 kern_type = KERN_TYPE_MD5PIX;
8416 dgst_size = DGST_SIZE_4_4;
8417 parse_func = md5pix_parse_hash;
8418 sort_by_digest = sort_by_digest_4_4;
8419 opti_type = OPTI_TYPE_ZERO_BYTE
8420 | OPTI_TYPE_PRECOMPUTE_INIT
8421 | OPTI_TYPE_PRECOMPUTE_MERKLE
8422 | OPTI_TYPE_EARLY_SKIP
8423 | OPTI_TYPE_NOT_ITERATED
8424 | OPTI_TYPE_NOT_SALTED;
8425 dgst_pos0 = 0;
8426 dgst_pos1 = 3;
8427 dgst_pos2 = 2;
8428 dgst_pos3 = 1;
8429 break;
8430
8431 case 2410: hash_type = HASH_TYPE_MD5;
8432 salt_type = SALT_TYPE_INTERN;
8433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8434 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8435 kern_type = KERN_TYPE_MD5ASA;
8436 dgst_size = DGST_SIZE_4_4;
8437 parse_func = md5asa_parse_hash;
8438 sort_by_digest = sort_by_digest_4_4;
8439 opti_type = OPTI_TYPE_ZERO_BYTE
8440 | OPTI_TYPE_PRECOMPUTE_INIT
8441 | OPTI_TYPE_PRECOMPUTE_MERKLE
8442 | OPTI_TYPE_EARLY_SKIP
8443 | OPTI_TYPE_NOT_ITERATED;
8444 dgst_pos0 = 0;
8445 dgst_pos1 = 3;
8446 dgst_pos2 = 2;
8447 dgst_pos3 = 1;
8448 break;
8449
8450 case 2500: hash_type = HASH_TYPE_WPA;
8451 salt_type = SALT_TYPE_EMBEDDED;
8452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8453 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8454 kern_type = KERN_TYPE_WPA;
8455 dgst_size = DGST_SIZE_4_4;
8456 parse_func = wpa_parse_hash;
8457 sort_by_digest = sort_by_digest_4_4;
8458 opti_type = OPTI_TYPE_ZERO_BYTE
8459 | OPTI_TYPE_SLOW_HASH_SIMD;
8460 dgst_pos0 = 0;
8461 dgst_pos1 = 1;
8462 dgst_pos2 = 2;
8463 dgst_pos3 = 3;
8464 break;
8465
8466 case 2600: hash_type = HASH_TYPE_MD5;
8467 salt_type = SALT_TYPE_VIRTUAL;
8468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8469 opts_type = OPTS_TYPE_PT_GENERATE_LE
8470 | OPTS_TYPE_PT_ADD80
8471 | OPTS_TYPE_PT_ADDBITS14
8472 | OPTS_TYPE_ST_ADD80;
8473 kern_type = KERN_TYPE_MD55_PWSLT1;
8474 dgst_size = DGST_SIZE_4_4;
8475 parse_func = md5md5_parse_hash;
8476 sort_by_digest = sort_by_digest_4_4;
8477 opti_type = OPTI_TYPE_ZERO_BYTE
8478 | OPTI_TYPE_PRECOMPUTE_INIT
8479 | OPTI_TYPE_PRECOMPUTE_MERKLE
8480 | OPTI_TYPE_EARLY_SKIP;
8481 dgst_pos0 = 0;
8482 dgst_pos1 = 3;
8483 dgst_pos2 = 2;
8484 dgst_pos3 = 1;
8485 break;
8486
8487 case 2611: hash_type = HASH_TYPE_MD5;
8488 salt_type = SALT_TYPE_INTERN;
8489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8490 opts_type = OPTS_TYPE_PT_GENERATE_LE
8491 | OPTS_TYPE_PT_ADD80
8492 | OPTS_TYPE_PT_ADDBITS14
8493 | OPTS_TYPE_ST_ADD80;
8494 kern_type = KERN_TYPE_MD55_PWSLT1;
8495 dgst_size = DGST_SIZE_4_4;
8496 parse_func = vb3_parse_hash;
8497 sort_by_digest = sort_by_digest_4_4;
8498 opti_type = OPTI_TYPE_ZERO_BYTE
8499 | OPTI_TYPE_PRECOMPUTE_INIT
8500 | OPTI_TYPE_PRECOMPUTE_MERKLE
8501 | OPTI_TYPE_EARLY_SKIP;
8502 dgst_pos0 = 0;
8503 dgst_pos1 = 3;
8504 dgst_pos2 = 2;
8505 dgst_pos3 = 1;
8506 break;
8507
8508 case 2612: hash_type = HASH_TYPE_MD5;
8509 salt_type = SALT_TYPE_EMBEDDED;
8510 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8511 opts_type = OPTS_TYPE_PT_GENERATE_LE
8512 | OPTS_TYPE_PT_ADD80
8513 | OPTS_TYPE_PT_ADDBITS14
8514 | OPTS_TYPE_ST_ADD80
8515 | OPTS_TYPE_ST_HEX;
8516 kern_type = KERN_TYPE_MD55_PWSLT1;
8517 dgst_size = DGST_SIZE_4_4;
8518 parse_func = phps_parse_hash;
8519 sort_by_digest = sort_by_digest_4_4;
8520 opti_type = OPTI_TYPE_ZERO_BYTE
8521 | OPTI_TYPE_PRECOMPUTE_INIT
8522 | OPTI_TYPE_PRECOMPUTE_MERKLE
8523 | OPTI_TYPE_EARLY_SKIP;
8524 dgst_pos0 = 0;
8525 dgst_pos1 = 3;
8526 dgst_pos2 = 2;
8527 dgst_pos3 = 1;
8528 break;
8529
8530 case 2711: hash_type = HASH_TYPE_MD5;
8531 salt_type = SALT_TYPE_INTERN;
8532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8533 opts_type = OPTS_TYPE_PT_GENERATE_LE
8534 | OPTS_TYPE_PT_ADD80
8535 | OPTS_TYPE_PT_ADDBITS14
8536 | OPTS_TYPE_ST_ADD80;
8537 kern_type = KERN_TYPE_MD55_PWSLT2;
8538 dgst_size = DGST_SIZE_4_4;
8539 parse_func = vb30_parse_hash;
8540 sort_by_digest = sort_by_digest_4_4;
8541 opti_type = OPTI_TYPE_ZERO_BYTE
8542 | OPTI_TYPE_PRECOMPUTE_INIT
8543 | OPTI_TYPE_EARLY_SKIP;
8544 dgst_pos0 = 0;
8545 dgst_pos1 = 3;
8546 dgst_pos2 = 2;
8547 dgst_pos3 = 1;
8548 break;
8549
8550 case 2811: hash_type = HASH_TYPE_MD5;
8551 salt_type = SALT_TYPE_INTERN;
8552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8553 opts_type = OPTS_TYPE_PT_GENERATE_LE
8554 | OPTS_TYPE_PT_ADD80
8555 | OPTS_TYPE_PT_ADDBITS14;
8556 kern_type = KERN_TYPE_MD55_SLTPW;
8557 dgst_size = DGST_SIZE_4_4;
8558 parse_func = ipb2_parse_hash;
8559 sort_by_digest = sort_by_digest_4_4;
8560 opti_type = OPTI_TYPE_ZERO_BYTE
8561 | OPTI_TYPE_PRECOMPUTE_INIT
8562 | OPTI_TYPE_EARLY_SKIP;
8563 dgst_pos0 = 0;
8564 dgst_pos1 = 3;
8565 dgst_pos2 = 2;
8566 dgst_pos3 = 1;
8567 break;
8568
8569 case 3000: hash_type = HASH_TYPE_LM;
8570 salt_type = SALT_TYPE_NONE;
8571 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8572 opts_type = OPTS_TYPE_PT_GENERATE_LE
8573 | OPTS_TYPE_PT_UPPER
8574 | OPTS_TYPE_PT_BITSLICE;
8575 kern_type = KERN_TYPE_LM;
8576 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8577 parse_func = lm_parse_hash;
8578 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8579 opti_type = OPTI_TYPE_ZERO_BYTE
8580 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8581 dgst_pos0 = 0;
8582 dgst_pos1 = 1;
8583 dgst_pos2 = 2;
8584 dgst_pos3 = 3;
8585 break;
8586
8587 case 3100: hash_type = HASH_TYPE_ORACLEH;
8588 salt_type = SALT_TYPE_INTERN;
8589 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8590 opts_type = OPTS_TYPE_PT_GENERATE_LE
8591 | OPTS_TYPE_PT_UPPER
8592 | OPTS_TYPE_ST_UPPER;
8593 kern_type = KERN_TYPE_ORACLEH;
8594 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8595 parse_func = oracleh_parse_hash;
8596 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8597 opti_type = OPTI_TYPE_ZERO_BYTE;
8598 dgst_pos0 = 0;
8599 dgst_pos1 = 1;
8600 dgst_pos2 = 2;
8601 dgst_pos3 = 3;
8602 break;
8603
8604 case 3200: hash_type = HASH_TYPE_BCRYPT;
8605 salt_type = SALT_TYPE_EMBEDDED;
8606 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8607 opts_type = OPTS_TYPE_PT_GENERATE_LE
8608 | OPTS_TYPE_ST_GENERATE_LE;
8609 kern_type = KERN_TYPE_BCRYPT;
8610 dgst_size = DGST_SIZE_4_6;
8611 parse_func = bcrypt_parse_hash;
8612 sort_by_digest = sort_by_digest_4_6;
8613 opti_type = OPTI_TYPE_ZERO_BYTE;
8614 dgst_pos0 = 0;
8615 dgst_pos1 = 1;
8616 dgst_pos2 = 2;
8617 dgst_pos3 = 3;
8618 break;
8619
8620 case 3710: hash_type = HASH_TYPE_MD5;
8621 salt_type = SALT_TYPE_INTERN;
8622 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8623 opts_type = OPTS_TYPE_PT_GENERATE_LE
8624 | OPTS_TYPE_PT_ADD80
8625 | OPTS_TYPE_PT_ADDBITS14;
8626 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8627 dgst_size = DGST_SIZE_4_4;
8628 parse_func = md5s_parse_hash;
8629 sort_by_digest = sort_by_digest_4_4;
8630 opti_type = OPTI_TYPE_ZERO_BYTE
8631 | OPTI_TYPE_PRECOMPUTE_INIT
8632 | OPTI_TYPE_PRECOMPUTE_MERKLE
8633 | OPTI_TYPE_EARLY_SKIP;
8634 dgst_pos0 = 0;
8635 dgst_pos1 = 3;
8636 dgst_pos2 = 2;
8637 dgst_pos3 = 1;
8638 break;
8639
8640 case 3711: hash_type = HASH_TYPE_MD5;
8641 salt_type = SALT_TYPE_EMBEDDED;
8642 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8643 opts_type = OPTS_TYPE_PT_GENERATE_LE
8644 | OPTS_TYPE_PT_ADD80
8645 | OPTS_TYPE_PT_ADDBITS14;
8646 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8647 dgst_size = DGST_SIZE_4_4;
8648 parse_func = mediawiki_b_parse_hash;
8649 sort_by_digest = sort_by_digest_4_4;
8650 opti_type = OPTI_TYPE_ZERO_BYTE
8651 | OPTI_TYPE_PRECOMPUTE_INIT
8652 | OPTI_TYPE_PRECOMPUTE_MERKLE
8653 | OPTI_TYPE_EARLY_SKIP;
8654 dgst_pos0 = 0;
8655 dgst_pos1 = 3;
8656 dgst_pos2 = 2;
8657 dgst_pos3 = 1;
8658 break;
8659
8660 case 3800: hash_type = HASH_TYPE_MD5;
8661 salt_type = SALT_TYPE_INTERN;
8662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8663 opts_type = OPTS_TYPE_PT_GENERATE_LE
8664 | OPTS_TYPE_ST_ADDBITS14;
8665 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8666 dgst_size = DGST_SIZE_4_4;
8667 parse_func = md5s_parse_hash;
8668 sort_by_digest = sort_by_digest_4_4;
8669 opti_type = OPTI_TYPE_ZERO_BYTE
8670 | OPTI_TYPE_PRECOMPUTE_INIT
8671 | OPTI_TYPE_PRECOMPUTE_MERKLE
8672 | OPTI_TYPE_EARLY_SKIP
8673 | OPTI_TYPE_NOT_ITERATED
8674 | OPTI_TYPE_RAW_HASH;
8675 dgst_pos0 = 0;
8676 dgst_pos1 = 3;
8677 dgst_pos2 = 2;
8678 dgst_pos3 = 1;
8679 break;
8680
8681 case 4300: hash_type = HASH_TYPE_MD5;
8682 salt_type = SALT_TYPE_VIRTUAL;
8683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8684 opts_type = OPTS_TYPE_PT_GENERATE_LE
8685 | OPTS_TYPE_PT_ADD80
8686 | OPTS_TYPE_PT_ADDBITS14
8687 | OPTS_TYPE_ST_ADD80;
8688 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8689 dgst_size = DGST_SIZE_4_4;
8690 parse_func = md5md5_parse_hash;
8691 sort_by_digest = sort_by_digest_4_4;
8692 opti_type = OPTI_TYPE_ZERO_BYTE
8693 | OPTI_TYPE_PRECOMPUTE_INIT
8694 | OPTI_TYPE_PRECOMPUTE_MERKLE
8695 | OPTI_TYPE_EARLY_SKIP;
8696 dgst_pos0 = 0;
8697 dgst_pos1 = 3;
8698 dgst_pos2 = 2;
8699 dgst_pos3 = 1;
8700 break;
8701
8702
8703 case 4400: hash_type = HASH_TYPE_MD5;
8704 salt_type = SALT_TYPE_NONE;
8705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8706 opts_type = OPTS_TYPE_PT_GENERATE_BE
8707 | OPTS_TYPE_PT_ADD80
8708 | OPTS_TYPE_PT_ADDBITS15;
8709 kern_type = KERN_TYPE_MD5_SHA1;
8710 dgst_size = DGST_SIZE_4_4;
8711 parse_func = md5_parse_hash;
8712 sort_by_digest = sort_by_digest_4_4;
8713 opti_type = OPTI_TYPE_ZERO_BYTE
8714 | OPTI_TYPE_PRECOMPUTE_INIT
8715 | OPTI_TYPE_PRECOMPUTE_MERKLE
8716 | OPTI_TYPE_EARLY_SKIP
8717 | OPTI_TYPE_NOT_ITERATED
8718 | OPTI_TYPE_NOT_SALTED
8719 | OPTI_TYPE_RAW_HASH;
8720 dgst_pos0 = 0;
8721 dgst_pos1 = 3;
8722 dgst_pos2 = 2;
8723 dgst_pos3 = 1;
8724 break;
8725
8726 case 4500: hash_type = HASH_TYPE_SHA1;
8727 salt_type = SALT_TYPE_NONE;
8728 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8729 opts_type = OPTS_TYPE_PT_GENERATE_BE
8730 | OPTS_TYPE_PT_ADD80
8731 | OPTS_TYPE_PT_ADDBITS15;
8732 kern_type = KERN_TYPE_SHA11;
8733 dgst_size = DGST_SIZE_4_5;
8734 parse_func = sha1_parse_hash;
8735 sort_by_digest = sort_by_digest_4_5;
8736 opti_type = OPTI_TYPE_ZERO_BYTE
8737 | OPTI_TYPE_PRECOMPUTE_INIT
8738 | OPTI_TYPE_PRECOMPUTE_MERKLE
8739 | OPTI_TYPE_EARLY_SKIP
8740 | OPTI_TYPE_NOT_SALTED;
8741 dgst_pos0 = 3;
8742 dgst_pos1 = 4;
8743 dgst_pos2 = 2;
8744 dgst_pos3 = 1;
8745 break;
8746
8747 case 4700: hash_type = HASH_TYPE_SHA1;
8748 salt_type = SALT_TYPE_NONE;
8749 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8750 opts_type = OPTS_TYPE_PT_GENERATE_LE
8751 | OPTS_TYPE_PT_ADD80
8752 | OPTS_TYPE_PT_ADDBITS14;
8753 kern_type = KERN_TYPE_SHA1_MD5;
8754 dgst_size = DGST_SIZE_4_5;
8755 parse_func = sha1_parse_hash;
8756 sort_by_digest = sort_by_digest_4_5;
8757 opti_type = OPTI_TYPE_ZERO_BYTE
8758 | OPTI_TYPE_PRECOMPUTE_INIT
8759 | OPTI_TYPE_PRECOMPUTE_MERKLE
8760 | OPTI_TYPE_EARLY_SKIP
8761 | OPTI_TYPE_NOT_ITERATED
8762 | OPTI_TYPE_NOT_SALTED
8763 | OPTI_TYPE_RAW_HASH;
8764 dgst_pos0 = 3;
8765 dgst_pos1 = 4;
8766 dgst_pos2 = 2;
8767 dgst_pos3 = 1;
8768 break;
8769
8770 case 4800: hash_type = HASH_TYPE_MD5;
8771 salt_type = SALT_TYPE_EMBEDDED;
8772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8773 opts_type = OPTS_TYPE_PT_GENERATE_LE
8774 | OPTS_TYPE_PT_ADDBITS14;
8775 kern_type = KERN_TYPE_MD5_CHAP;
8776 dgst_size = DGST_SIZE_4_4;
8777 parse_func = chap_parse_hash;
8778 sort_by_digest = sort_by_digest_4_4;
8779 opti_type = OPTI_TYPE_ZERO_BYTE
8780 | OPTI_TYPE_PRECOMPUTE_INIT
8781 | OPTI_TYPE_PRECOMPUTE_MERKLE
8782 | OPTI_TYPE_MEET_IN_MIDDLE
8783 | OPTI_TYPE_EARLY_SKIP
8784 | OPTI_TYPE_NOT_ITERATED
8785 | OPTI_TYPE_RAW_HASH;
8786 dgst_pos0 = 0;
8787 dgst_pos1 = 3;
8788 dgst_pos2 = 2;
8789 dgst_pos3 = 1;
8790 break;
8791
8792 case 4900: hash_type = HASH_TYPE_SHA1;
8793 salt_type = SALT_TYPE_INTERN;
8794 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8795 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8796 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8797 dgst_size = DGST_SIZE_4_5;
8798 parse_func = sha1s_parse_hash;
8799 sort_by_digest = sort_by_digest_4_5;
8800 opti_type = OPTI_TYPE_ZERO_BYTE
8801 | OPTI_TYPE_PRECOMPUTE_INIT
8802 | OPTI_TYPE_PRECOMPUTE_MERKLE
8803 | OPTI_TYPE_EARLY_SKIP;
8804 dgst_pos0 = 3;
8805 dgst_pos1 = 4;
8806 dgst_pos2 = 2;
8807 dgst_pos3 = 1;
8808 break;
8809
8810 case 5000: hash_type = HASH_TYPE_KECCAK;
8811 salt_type = SALT_TYPE_EMBEDDED;
8812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8813 opts_type = OPTS_TYPE_PT_GENERATE_LE
8814 | OPTS_TYPE_PT_ADD01;
8815 kern_type = KERN_TYPE_KECCAK;
8816 dgst_size = DGST_SIZE_8_25;
8817 parse_func = keccak_parse_hash;
8818 sort_by_digest = sort_by_digest_8_25;
8819 opti_type = OPTI_TYPE_ZERO_BYTE
8820 | OPTI_TYPE_USES_BITS_64
8821 | OPTI_TYPE_RAW_HASH;
8822 dgst_pos0 = 2;
8823 dgst_pos1 = 3;
8824 dgst_pos2 = 4;
8825 dgst_pos3 = 5;
8826 break;
8827
8828 case 5100: hash_type = HASH_TYPE_MD5H;
8829 salt_type = SALT_TYPE_NONE;
8830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8831 opts_type = OPTS_TYPE_PT_GENERATE_LE
8832 | OPTS_TYPE_PT_ADD80
8833 | OPTS_TYPE_PT_ADDBITS14;
8834 kern_type = KERN_TYPE_MD5H;
8835 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8836 parse_func = md5half_parse_hash;
8837 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8838 opti_type = OPTI_TYPE_ZERO_BYTE
8839 | OPTI_TYPE_RAW_HASH;
8840 dgst_pos0 = 0;
8841 dgst_pos1 = 1;
8842 dgst_pos2 = 2;
8843 dgst_pos3 = 3;
8844 break;
8845
8846 case 5200: hash_type = HASH_TYPE_SHA256;
8847 salt_type = SALT_TYPE_EMBEDDED;
8848 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8849 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8850 kern_type = KERN_TYPE_PSAFE3;
8851 dgst_size = DGST_SIZE_4_8;
8852 parse_func = psafe3_parse_hash;
8853 sort_by_digest = sort_by_digest_4_8;
8854 opti_type = OPTI_TYPE_ZERO_BYTE;
8855 dgst_pos0 = 0;
8856 dgst_pos1 = 1;
8857 dgst_pos2 = 2;
8858 dgst_pos3 = 3;
8859 break;
8860
8861 case 5300: hash_type = HASH_TYPE_MD5;
8862 salt_type = SALT_TYPE_EMBEDDED;
8863 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8864 opts_type = OPTS_TYPE_PT_GENERATE_LE
8865 | OPTS_TYPE_ST_ADD80;
8866 kern_type = KERN_TYPE_IKEPSK_MD5;
8867 dgst_size = DGST_SIZE_4_4;
8868 parse_func = ikepsk_md5_parse_hash;
8869 sort_by_digest = sort_by_digest_4_4;
8870 opti_type = OPTI_TYPE_ZERO_BYTE;
8871 dgst_pos0 = 0;
8872 dgst_pos1 = 3;
8873 dgst_pos2 = 2;
8874 dgst_pos3 = 1;
8875 break;
8876
8877 case 5400: hash_type = HASH_TYPE_SHA1;
8878 salt_type = SALT_TYPE_EMBEDDED;
8879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8880 opts_type = OPTS_TYPE_PT_GENERATE_BE
8881 | OPTS_TYPE_ST_ADD80;
8882 kern_type = KERN_TYPE_IKEPSK_SHA1;
8883 dgst_size = DGST_SIZE_4_5;
8884 parse_func = ikepsk_sha1_parse_hash;
8885 sort_by_digest = sort_by_digest_4_5;
8886 opti_type = OPTI_TYPE_ZERO_BYTE;
8887 dgst_pos0 = 3;
8888 dgst_pos1 = 4;
8889 dgst_pos2 = 2;
8890 dgst_pos3 = 1;
8891 break;
8892
8893 case 5500: hash_type = HASH_TYPE_NETNTLM;
8894 salt_type = SALT_TYPE_EMBEDDED;
8895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8896 opts_type = OPTS_TYPE_PT_GENERATE_LE
8897 | OPTS_TYPE_PT_ADD80
8898 | OPTS_TYPE_PT_ADDBITS14
8899 | OPTS_TYPE_PT_UNICODE
8900 | OPTS_TYPE_ST_HEX;
8901 kern_type = KERN_TYPE_NETNTLMv1;
8902 dgst_size = DGST_SIZE_4_4;
8903 parse_func = netntlmv1_parse_hash;
8904 sort_by_digest = sort_by_digest_4_4;
8905 opti_type = OPTI_TYPE_ZERO_BYTE
8906 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8907 dgst_pos0 = 0;
8908 dgst_pos1 = 1;
8909 dgst_pos2 = 2;
8910 dgst_pos3 = 3;
8911 break;
8912
8913 case 5600: hash_type = HASH_TYPE_MD5;
8914 salt_type = SALT_TYPE_EMBEDDED;
8915 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8916 opts_type = OPTS_TYPE_PT_GENERATE_LE
8917 | OPTS_TYPE_PT_ADD80
8918 | OPTS_TYPE_PT_ADDBITS14
8919 | OPTS_TYPE_PT_UNICODE;
8920 kern_type = KERN_TYPE_NETNTLMv2;
8921 dgst_size = DGST_SIZE_4_4;
8922 parse_func = netntlmv2_parse_hash;
8923 sort_by_digest = sort_by_digest_4_4;
8924 opti_type = OPTI_TYPE_ZERO_BYTE;
8925 dgst_pos0 = 0;
8926 dgst_pos1 = 3;
8927 dgst_pos2 = 2;
8928 dgst_pos3 = 1;
8929 break;
8930
8931 case 5700: hash_type = HASH_TYPE_SHA256;
8932 salt_type = SALT_TYPE_NONE;
8933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8934 opts_type = OPTS_TYPE_PT_GENERATE_BE
8935 | OPTS_TYPE_PT_ADD80
8936 | OPTS_TYPE_PT_ADDBITS15;
8937 kern_type = KERN_TYPE_SHA256;
8938 dgst_size = DGST_SIZE_4_8;
8939 parse_func = cisco4_parse_hash;
8940 sort_by_digest = sort_by_digest_4_8;
8941 opti_type = OPTI_TYPE_ZERO_BYTE
8942 | OPTI_TYPE_PRECOMPUTE_INIT
8943 | OPTI_TYPE_PRECOMPUTE_MERKLE
8944 | OPTI_TYPE_EARLY_SKIP
8945 | OPTI_TYPE_NOT_ITERATED
8946 | OPTI_TYPE_NOT_SALTED
8947 | OPTI_TYPE_RAW_HASH;
8948 dgst_pos0 = 3;
8949 dgst_pos1 = 7;
8950 dgst_pos2 = 2;
8951 dgst_pos3 = 6;
8952 break;
8953
8954 case 5800: hash_type = HASH_TYPE_SHA1;
8955 salt_type = SALT_TYPE_INTERN;
8956 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8957 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8958 | OPTS_TYPE_ST_ADD80;
8959 kern_type = KERN_TYPE_ANDROIDPIN;
8960 dgst_size = DGST_SIZE_4_5;
8961 parse_func = androidpin_parse_hash;
8962 sort_by_digest = sort_by_digest_4_5;
8963 opti_type = OPTI_TYPE_ZERO_BYTE;
8964 dgst_pos0 = 0;
8965 dgst_pos1 = 1;
8966 dgst_pos2 = 2;
8967 dgst_pos3 = 3;
8968 break;
8969
8970 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8971 salt_type = SALT_TYPE_NONE;
8972 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8973 opts_type = OPTS_TYPE_PT_GENERATE_LE
8974 | OPTS_TYPE_PT_ADD80;
8975 kern_type = KERN_TYPE_RIPEMD160;
8976 dgst_size = DGST_SIZE_4_5;
8977 parse_func = ripemd160_parse_hash;
8978 sort_by_digest = sort_by_digest_4_5;
8979 opti_type = OPTI_TYPE_ZERO_BYTE;
8980 dgst_pos0 = 0;
8981 dgst_pos1 = 1;
8982 dgst_pos2 = 2;
8983 dgst_pos3 = 3;
8984 break;
8985
8986 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8987 salt_type = SALT_TYPE_NONE;
8988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8989 opts_type = OPTS_TYPE_PT_GENERATE_BE
8990 | OPTS_TYPE_PT_ADD80;
8991 kern_type = KERN_TYPE_WHIRLPOOL;
8992 dgst_size = DGST_SIZE_4_16;
8993 parse_func = whirlpool_parse_hash;
8994 sort_by_digest = sort_by_digest_4_16;
8995 opti_type = OPTI_TYPE_ZERO_BYTE;
8996 dgst_pos0 = 0;
8997 dgst_pos1 = 1;
8998 dgst_pos2 = 2;
8999 dgst_pos3 = 3;
9000 break;
9001
9002 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9003 salt_type = SALT_TYPE_EMBEDDED;
9004 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9005 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9006 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9007 dgst_size = DGST_SIZE_4_5;
9008 parse_func = truecrypt_parse_hash_2k;
9009 sort_by_digest = sort_by_digest_4_5;
9010 opti_type = OPTI_TYPE_ZERO_BYTE;
9011 dgst_pos0 = 0;
9012 dgst_pos1 = 1;
9013 dgst_pos2 = 2;
9014 dgst_pos3 = 3;
9015 break;
9016
9017 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9018 salt_type = SALT_TYPE_EMBEDDED;
9019 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9020 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9021 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9022 dgst_size = DGST_SIZE_4_5;
9023 parse_func = truecrypt_parse_hash_2k;
9024 sort_by_digest = sort_by_digest_4_5;
9025 opti_type = OPTI_TYPE_ZERO_BYTE;
9026 dgst_pos0 = 0;
9027 dgst_pos1 = 1;
9028 dgst_pos2 = 2;
9029 dgst_pos3 = 3;
9030 break;
9031
9032 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9033 salt_type = SALT_TYPE_EMBEDDED;
9034 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9035 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9036 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9037 dgst_size = DGST_SIZE_4_5;
9038 parse_func = truecrypt_parse_hash_2k;
9039 sort_by_digest = sort_by_digest_4_5;
9040 opti_type = OPTI_TYPE_ZERO_BYTE;
9041 dgst_pos0 = 0;
9042 dgst_pos1 = 1;
9043 dgst_pos2 = 2;
9044 dgst_pos3 = 3;
9045 break;
9046
9047 case 6221: hash_type = HASH_TYPE_SHA512;
9048 salt_type = SALT_TYPE_EMBEDDED;
9049 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9050 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9051 kern_type = KERN_TYPE_TCSHA512_XTS512;
9052 dgst_size = DGST_SIZE_8_8;
9053 parse_func = truecrypt_parse_hash_1k;
9054 sort_by_digest = sort_by_digest_8_8;
9055 opti_type = OPTI_TYPE_ZERO_BYTE
9056 | OPTI_TYPE_USES_BITS_64;
9057 dgst_pos0 = 0;
9058 dgst_pos1 = 1;
9059 dgst_pos2 = 2;
9060 dgst_pos3 = 3;
9061 break;
9062
9063 case 6222: hash_type = HASH_TYPE_SHA512;
9064 salt_type = SALT_TYPE_EMBEDDED;
9065 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9066 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9067 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9068 dgst_size = DGST_SIZE_8_8;
9069 parse_func = truecrypt_parse_hash_1k;
9070 sort_by_digest = sort_by_digest_8_8;
9071 opti_type = OPTI_TYPE_ZERO_BYTE
9072 | OPTI_TYPE_USES_BITS_64;
9073 dgst_pos0 = 0;
9074 dgst_pos1 = 1;
9075 dgst_pos2 = 2;
9076 dgst_pos3 = 3;
9077 break;
9078
9079 case 6223: hash_type = HASH_TYPE_SHA512;
9080 salt_type = SALT_TYPE_EMBEDDED;
9081 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9082 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9083 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9084 dgst_size = DGST_SIZE_8_8;
9085 parse_func = truecrypt_parse_hash_1k;
9086 sort_by_digest = sort_by_digest_8_8;
9087 opti_type = OPTI_TYPE_ZERO_BYTE
9088 | OPTI_TYPE_USES_BITS_64;
9089 dgst_pos0 = 0;
9090 dgst_pos1 = 1;
9091 dgst_pos2 = 2;
9092 dgst_pos3 = 3;
9093 break;
9094
9095 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9096 salt_type = SALT_TYPE_EMBEDDED;
9097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9098 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9099 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9100 dgst_size = DGST_SIZE_4_8;
9101 parse_func = truecrypt_parse_hash_1k;
9102 sort_by_digest = sort_by_digest_4_8;
9103 opti_type = OPTI_TYPE_ZERO_BYTE;
9104 dgst_pos0 = 0;
9105 dgst_pos1 = 1;
9106 dgst_pos2 = 2;
9107 dgst_pos3 = 3;
9108 break;
9109
9110 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9111 salt_type = SALT_TYPE_EMBEDDED;
9112 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9113 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9114 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9115 dgst_size = DGST_SIZE_4_8;
9116 parse_func = truecrypt_parse_hash_1k;
9117 sort_by_digest = sort_by_digest_4_8;
9118 opti_type = OPTI_TYPE_ZERO_BYTE;
9119 dgst_pos0 = 0;
9120 dgst_pos1 = 1;
9121 dgst_pos2 = 2;
9122 dgst_pos3 = 3;
9123 break;
9124
9125 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9126 salt_type = SALT_TYPE_EMBEDDED;
9127 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9128 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9129 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9130 dgst_size = DGST_SIZE_4_8;
9131 parse_func = truecrypt_parse_hash_1k;
9132 sort_by_digest = sort_by_digest_4_8;
9133 opti_type = OPTI_TYPE_ZERO_BYTE;
9134 dgst_pos0 = 0;
9135 dgst_pos1 = 1;
9136 dgst_pos2 = 2;
9137 dgst_pos3 = 3;
9138 break;
9139
9140 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9141 salt_type = SALT_TYPE_EMBEDDED;
9142 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9143 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9144 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9145 dgst_size = DGST_SIZE_4_5;
9146 parse_func = truecrypt_parse_hash_1k;
9147 sort_by_digest = sort_by_digest_4_5;
9148 opti_type = OPTI_TYPE_ZERO_BYTE;
9149 dgst_pos0 = 0;
9150 dgst_pos1 = 1;
9151 dgst_pos2 = 2;
9152 dgst_pos3 = 3;
9153 break;
9154
9155 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9156 salt_type = SALT_TYPE_EMBEDDED;
9157 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9158 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9159 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9160 dgst_size = DGST_SIZE_4_5;
9161 parse_func = truecrypt_parse_hash_1k;
9162 sort_by_digest = sort_by_digest_4_5;
9163 opti_type = OPTI_TYPE_ZERO_BYTE;
9164 dgst_pos0 = 0;
9165 dgst_pos1 = 1;
9166 dgst_pos2 = 2;
9167 dgst_pos3 = 3;
9168 break;
9169
9170 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9171 salt_type = SALT_TYPE_EMBEDDED;
9172 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9173 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9174 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9175 dgst_size = DGST_SIZE_4_5;
9176 parse_func = truecrypt_parse_hash_1k;
9177 sort_by_digest = sort_by_digest_4_5;
9178 opti_type = OPTI_TYPE_ZERO_BYTE;
9179 dgst_pos0 = 0;
9180 dgst_pos1 = 1;
9181 dgst_pos2 = 2;
9182 dgst_pos3 = 3;
9183 break;
9184
9185 case 6300: hash_type = HASH_TYPE_MD5;
9186 salt_type = SALT_TYPE_EMBEDDED;
9187 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9188 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9189 kern_type = KERN_TYPE_MD5AIX;
9190 dgst_size = DGST_SIZE_4_4;
9191 parse_func = md5aix_parse_hash;
9192 sort_by_digest = sort_by_digest_4_4;
9193 opti_type = OPTI_TYPE_ZERO_BYTE;
9194 dgst_pos0 = 0;
9195 dgst_pos1 = 1;
9196 dgst_pos2 = 2;
9197 dgst_pos3 = 3;
9198 break;
9199
9200 case 6400: hash_type = HASH_TYPE_SHA256;
9201 salt_type = SALT_TYPE_EMBEDDED;
9202 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9203 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9204 kern_type = KERN_TYPE_SHA256AIX;
9205 dgst_size = DGST_SIZE_4_8;
9206 parse_func = sha256aix_parse_hash;
9207 sort_by_digest = sort_by_digest_4_8;
9208 opti_type = OPTI_TYPE_ZERO_BYTE;
9209 dgst_pos0 = 0;
9210 dgst_pos1 = 1;
9211 dgst_pos2 = 2;
9212 dgst_pos3 = 3;
9213 break;
9214
9215 case 6500: hash_type = HASH_TYPE_SHA512;
9216 salt_type = SALT_TYPE_EMBEDDED;
9217 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9218 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9219 kern_type = KERN_TYPE_SHA512AIX;
9220 dgst_size = DGST_SIZE_8_8;
9221 parse_func = sha512aix_parse_hash;
9222 sort_by_digest = sort_by_digest_8_8;
9223 opti_type = OPTI_TYPE_ZERO_BYTE
9224 | OPTI_TYPE_USES_BITS_64;
9225 dgst_pos0 = 0;
9226 dgst_pos1 = 1;
9227 dgst_pos2 = 2;
9228 dgst_pos3 = 3;
9229 break;
9230
9231 case 6600: hash_type = HASH_TYPE_AES;
9232 salt_type = SALT_TYPE_EMBEDDED;
9233 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9234 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9235 kern_type = KERN_TYPE_AGILEKEY;
9236 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9237 parse_func = agilekey_parse_hash;
9238 sort_by_digest = sort_by_digest_4_5;
9239 opti_type = OPTI_TYPE_ZERO_BYTE;
9240 dgst_pos0 = 0;
9241 dgst_pos1 = 1;
9242 dgst_pos2 = 2;
9243 dgst_pos3 = 3;
9244 break;
9245
9246 case 6700: hash_type = HASH_TYPE_SHA1;
9247 salt_type = SALT_TYPE_EMBEDDED;
9248 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9249 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9250 kern_type = KERN_TYPE_SHA1AIX;
9251 dgst_size = DGST_SIZE_4_5;
9252 parse_func = sha1aix_parse_hash;
9253 sort_by_digest = sort_by_digest_4_5;
9254 opti_type = OPTI_TYPE_ZERO_BYTE;
9255 dgst_pos0 = 0;
9256 dgst_pos1 = 1;
9257 dgst_pos2 = 2;
9258 dgst_pos3 = 3;
9259 break;
9260
9261 case 6800: hash_type = HASH_TYPE_AES;
9262 salt_type = SALT_TYPE_EMBEDDED;
9263 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9264 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9265 kern_type = KERN_TYPE_LASTPASS;
9266 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9267 parse_func = lastpass_parse_hash;
9268 sort_by_digest = sort_by_digest_4_8;
9269 opti_type = OPTI_TYPE_ZERO_BYTE;
9270 dgst_pos0 = 0;
9271 dgst_pos1 = 1;
9272 dgst_pos2 = 2;
9273 dgst_pos3 = 3;
9274 break;
9275
9276 case 6900: hash_type = HASH_TYPE_GOST;
9277 salt_type = SALT_TYPE_NONE;
9278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9279 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9280 kern_type = KERN_TYPE_GOST;
9281 dgst_size = DGST_SIZE_4_8;
9282 parse_func = gost_parse_hash;
9283 sort_by_digest = sort_by_digest_4_8;
9284 opti_type = OPTI_TYPE_ZERO_BYTE;
9285 dgst_pos0 = 0;
9286 dgst_pos1 = 1;
9287 dgst_pos2 = 2;
9288 dgst_pos3 = 3;
9289 break;
9290
9291 case 7100: hash_type = HASH_TYPE_SHA512;
9292 salt_type = SALT_TYPE_EMBEDDED;
9293 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9294 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9295 kern_type = KERN_TYPE_PBKDF2_SHA512;
9296 dgst_size = DGST_SIZE_8_16;
9297 parse_func = sha512osx_parse_hash;
9298 sort_by_digest = sort_by_digest_8_16;
9299 opti_type = OPTI_TYPE_ZERO_BYTE
9300 | OPTI_TYPE_USES_BITS_64
9301 | OPTI_TYPE_SLOW_HASH_SIMD;
9302 dgst_pos0 = 0;
9303 dgst_pos1 = 1;
9304 dgst_pos2 = 2;
9305 dgst_pos3 = 3;
9306 break;
9307
9308 case 7200: hash_type = HASH_TYPE_SHA512;
9309 salt_type = SALT_TYPE_EMBEDDED;
9310 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9311 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9312 kern_type = KERN_TYPE_PBKDF2_SHA512;
9313 dgst_size = DGST_SIZE_8_16;
9314 parse_func = sha512grub_parse_hash;
9315 sort_by_digest = sort_by_digest_8_16;
9316 opti_type = OPTI_TYPE_ZERO_BYTE
9317 | OPTI_TYPE_USES_BITS_64
9318 | OPTI_TYPE_SLOW_HASH_SIMD;
9319 dgst_pos0 = 0;
9320 dgst_pos1 = 1;
9321 dgst_pos2 = 2;
9322 dgst_pos3 = 3;
9323 break;
9324
9325 case 7300: hash_type = HASH_TYPE_SHA1;
9326 salt_type = SALT_TYPE_EMBEDDED;
9327 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9328 opts_type = OPTS_TYPE_PT_GENERATE_BE
9329 | OPTS_TYPE_ST_ADD80
9330 | OPTS_TYPE_ST_ADDBITS15;
9331 kern_type = KERN_TYPE_RAKP;
9332 dgst_size = DGST_SIZE_4_5;
9333 parse_func = rakp_parse_hash;
9334 sort_by_digest = sort_by_digest_4_5;
9335 opti_type = OPTI_TYPE_ZERO_BYTE
9336 | OPTI_TYPE_NOT_ITERATED;
9337 dgst_pos0 = 3;
9338 dgst_pos1 = 4;
9339 dgst_pos2 = 2;
9340 dgst_pos3 = 1;
9341 break;
9342
9343 case 7400: hash_type = HASH_TYPE_SHA256;
9344 salt_type = SALT_TYPE_EMBEDDED;
9345 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9346 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9347 kern_type = KERN_TYPE_SHA256CRYPT;
9348 dgst_size = DGST_SIZE_4_8;
9349 parse_func = sha256crypt_parse_hash;
9350 sort_by_digest = sort_by_digest_4_8;
9351 opti_type = OPTI_TYPE_ZERO_BYTE;
9352 dgst_pos0 = 0;
9353 dgst_pos1 = 1;
9354 dgst_pos2 = 2;
9355 dgst_pos3 = 3;
9356 break;
9357
9358 case 7500: hash_type = HASH_TYPE_KRB5PA;
9359 salt_type = SALT_TYPE_EMBEDDED;
9360 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9361 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9362 kern_type = KERN_TYPE_KRB5PA;
9363 dgst_size = DGST_SIZE_4_4;
9364 parse_func = krb5pa_parse_hash;
9365 sort_by_digest = sort_by_digest_4_4;
9366 opti_type = OPTI_TYPE_ZERO_BYTE
9367 | OPTI_TYPE_NOT_ITERATED;
9368 dgst_pos0 = 0;
9369 dgst_pos1 = 1;
9370 dgst_pos2 = 2;
9371 dgst_pos3 = 3;
9372 break;
9373
9374 case 7600: hash_type = HASH_TYPE_SHA1;
9375 salt_type = SALT_TYPE_INTERN;
9376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9377 opts_type = OPTS_TYPE_PT_GENERATE_BE
9378 | OPTS_TYPE_PT_ADD80
9379 | OPTS_TYPE_PT_ADDBITS15;
9380 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9381 dgst_size = DGST_SIZE_4_5;
9382 parse_func = redmine_parse_hash;
9383 sort_by_digest = sort_by_digest_4_5;
9384 opti_type = OPTI_TYPE_ZERO_BYTE
9385 | OPTI_TYPE_PRECOMPUTE_INIT
9386 | OPTI_TYPE_EARLY_SKIP
9387 | OPTI_TYPE_NOT_ITERATED
9388 | OPTI_TYPE_PREPENDED_SALT;
9389 dgst_pos0 = 3;
9390 dgst_pos1 = 4;
9391 dgst_pos2 = 2;
9392 dgst_pos3 = 1;
9393 break;
9394
9395 case 7700: hash_type = HASH_TYPE_SAPB;
9396 salt_type = SALT_TYPE_EMBEDDED;
9397 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9398 opts_type = OPTS_TYPE_PT_GENERATE_LE
9399 | OPTS_TYPE_PT_UPPER
9400 | OPTS_TYPE_ST_UPPER;
9401 kern_type = KERN_TYPE_SAPB;
9402 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9403 parse_func = sapb_parse_hash;
9404 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9405 opti_type = OPTI_TYPE_ZERO_BYTE
9406 | OPTI_TYPE_PRECOMPUTE_INIT
9407 | OPTI_TYPE_NOT_ITERATED;
9408 dgst_pos0 = 0;
9409 dgst_pos1 = 1;
9410 dgst_pos2 = 2;
9411 dgst_pos3 = 3;
9412 break;
9413
9414 case 7800: hash_type = HASH_TYPE_SAPG;
9415 salt_type = SALT_TYPE_EMBEDDED;
9416 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9417 opts_type = OPTS_TYPE_PT_GENERATE_BE
9418 | OPTS_TYPE_ST_ADD80
9419 | OPTS_TYPE_ST_UPPER;
9420 kern_type = KERN_TYPE_SAPG;
9421 dgst_size = DGST_SIZE_4_5;
9422 parse_func = sapg_parse_hash;
9423 sort_by_digest = sort_by_digest_4_5;
9424 opti_type = OPTI_TYPE_ZERO_BYTE
9425 | OPTI_TYPE_PRECOMPUTE_INIT
9426 | OPTI_TYPE_NOT_ITERATED;
9427 dgst_pos0 = 3;
9428 dgst_pos1 = 4;
9429 dgst_pos2 = 2;
9430 dgst_pos3 = 1;
9431 break;
9432
9433 case 7900: hash_type = HASH_TYPE_SHA512;
9434 salt_type = SALT_TYPE_EMBEDDED;
9435 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9436 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9437 kern_type = KERN_TYPE_DRUPAL7;
9438 dgst_size = DGST_SIZE_8_8;
9439 parse_func = drupal7_parse_hash;
9440 sort_by_digest = sort_by_digest_8_8;
9441 opti_type = OPTI_TYPE_ZERO_BYTE
9442 | OPTI_TYPE_USES_BITS_64;
9443 dgst_pos0 = 0;
9444 dgst_pos1 = 1;
9445 dgst_pos2 = 2;
9446 dgst_pos3 = 3;
9447 break;
9448
9449 case 8000: hash_type = HASH_TYPE_SHA256;
9450 salt_type = SALT_TYPE_EMBEDDED;
9451 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9452 opts_type = OPTS_TYPE_PT_GENERATE_BE
9453 | OPTS_TYPE_PT_UNICODE
9454 | OPTS_TYPE_ST_ADD80
9455 | OPTS_TYPE_ST_HEX;
9456 kern_type = KERN_TYPE_SYBASEASE;
9457 dgst_size = DGST_SIZE_4_8;
9458 parse_func = sybasease_parse_hash;
9459 sort_by_digest = sort_by_digest_4_8;
9460 opti_type = OPTI_TYPE_ZERO_BYTE
9461 | OPTI_TYPE_PRECOMPUTE_INIT
9462 | OPTI_TYPE_EARLY_SKIP
9463 | OPTI_TYPE_NOT_ITERATED
9464 | OPTI_TYPE_RAW_HASH;
9465 dgst_pos0 = 3;
9466 dgst_pos1 = 7;
9467 dgst_pos2 = 2;
9468 dgst_pos3 = 6;
9469 break;
9470
9471 case 8100: 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 kern_type = KERN_TYPE_NETSCALER;
9476 dgst_size = DGST_SIZE_4_5;
9477 parse_func = netscaler_parse_hash;
9478 sort_by_digest = sort_by_digest_4_5;
9479 opti_type = OPTI_TYPE_ZERO_BYTE
9480 | OPTI_TYPE_PRECOMPUTE_INIT
9481 | OPTI_TYPE_PRECOMPUTE_MERKLE
9482 | OPTI_TYPE_EARLY_SKIP
9483 | OPTI_TYPE_NOT_ITERATED
9484 | OPTI_TYPE_PREPENDED_SALT
9485 | OPTI_TYPE_RAW_HASH;
9486 dgst_pos0 = 3;
9487 dgst_pos1 = 4;
9488 dgst_pos2 = 2;
9489 dgst_pos3 = 1;
9490 break;
9491
9492 case 8200: hash_type = HASH_TYPE_SHA256;
9493 salt_type = SALT_TYPE_EMBEDDED;
9494 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9495 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9496 kern_type = KERN_TYPE_CLOUDKEY;
9497 dgst_size = DGST_SIZE_4_8;
9498 parse_func = cloudkey_parse_hash;
9499 sort_by_digest = sort_by_digest_4_8;
9500 opti_type = OPTI_TYPE_ZERO_BYTE;
9501 dgst_pos0 = 0;
9502 dgst_pos1 = 1;
9503 dgst_pos2 = 2;
9504 dgst_pos3 = 3;
9505 break;
9506
9507 case 8300: hash_type = HASH_TYPE_SHA1;
9508 salt_type = SALT_TYPE_EMBEDDED;
9509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9510 opts_type = OPTS_TYPE_PT_GENERATE_BE
9511 | OPTS_TYPE_ST_HEX
9512 | OPTS_TYPE_ST_ADD80;
9513 kern_type = KERN_TYPE_NSEC3;
9514 dgst_size = DGST_SIZE_4_5;
9515 parse_func = nsec3_parse_hash;
9516 sort_by_digest = sort_by_digest_4_5;
9517 opti_type = OPTI_TYPE_ZERO_BYTE;
9518 dgst_pos0 = 3;
9519 dgst_pos1 = 4;
9520 dgst_pos2 = 2;
9521 dgst_pos3 = 1;
9522 break;
9523
9524 case 8400: hash_type = HASH_TYPE_SHA1;
9525 salt_type = SALT_TYPE_INTERN;
9526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9527 opts_type = OPTS_TYPE_PT_GENERATE_BE
9528 | OPTS_TYPE_PT_ADD80
9529 | OPTS_TYPE_PT_ADDBITS15;
9530 kern_type = KERN_TYPE_WBB3;
9531 dgst_size = DGST_SIZE_4_5;
9532 parse_func = wbb3_parse_hash;
9533 sort_by_digest = sort_by_digest_4_5;
9534 opti_type = OPTI_TYPE_ZERO_BYTE
9535 | OPTI_TYPE_PRECOMPUTE_INIT
9536 | OPTI_TYPE_NOT_ITERATED;
9537 dgst_pos0 = 3;
9538 dgst_pos1 = 4;
9539 dgst_pos2 = 2;
9540 dgst_pos3 = 1;
9541 break;
9542
9543 case 8500: hash_type = HASH_TYPE_DESRACF;
9544 salt_type = SALT_TYPE_EMBEDDED;
9545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9546 opts_type = OPTS_TYPE_PT_GENERATE_LE
9547 | OPTS_TYPE_ST_UPPER;
9548 kern_type = KERN_TYPE_RACF;
9549 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9550 parse_func = racf_parse_hash;
9551 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9552 opti_type = OPTI_TYPE_ZERO_BYTE
9553 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9554 dgst_pos0 = 0;
9555 dgst_pos1 = 1;
9556 dgst_pos2 = 2;
9557 dgst_pos3 = 3;
9558 break;
9559
9560 case 8600: hash_type = HASH_TYPE_LOTUS5;
9561 salt_type = SALT_TYPE_NONE;
9562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9563 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9564 kern_type = KERN_TYPE_LOTUS5;
9565 dgst_size = DGST_SIZE_4_4;
9566 parse_func = lotus5_parse_hash;
9567 sort_by_digest = sort_by_digest_4_4;
9568 opti_type = OPTI_TYPE_EARLY_SKIP
9569 | OPTI_TYPE_NOT_ITERATED
9570 | OPTI_TYPE_NOT_SALTED
9571 | OPTI_TYPE_RAW_HASH;
9572 dgst_pos0 = 0;
9573 dgst_pos1 = 1;
9574 dgst_pos2 = 2;
9575 dgst_pos3 = 3;
9576 break;
9577
9578 case 8700: hash_type = HASH_TYPE_LOTUS6;
9579 salt_type = SALT_TYPE_EMBEDDED;
9580 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9581 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9582 kern_type = KERN_TYPE_LOTUS6;
9583 dgst_size = DGST_SIZE_4_4;
9584 parse_func = lotus6_parse_hash;
9585 sort_by_digest = sort_by_digest_4_4;
9586 opti_type = OPTI_TYPE_EARLY_SKIP
9587 | OPTI_TYPE_NOT_ITERATED
9588 | OPTI_TYPE_RAW_HASH;
9589 dgst_pos0 = 0;
9590 dgst_pos1 = 1;
9591 dgst_pos2 = 2;
9592 dgst_pos3 = 3;
9593 break;
9594
9595 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9596 salt_type = SALT_TYPE_EMBEDDED;
9597 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9598 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9599 kern_type = KERN_TYPE_ANDROIDFDE;
9600 dgst_size = DGST_SIZE_4_4;
9601 parse_func = androidfde_parse_hash;
9602 sort_by_digest = sort_by_digest_4_4;
9603 opti_type = OPTI_TYPE_ZERO_BYTE;
9604 dgst_pos0 = 0;
9605 dgst_pos1 = 1;
9606 dgst_pos2 = 2;
9607 dgst_pos3 = 3;
9608 break;
9609
9610 case 8900: hash_type = HASH_TYPE_SCRYPT;
9611 salt_type = SALT_TYPE_EMBEDDED;
9612 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9613 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9614 kern_type = KERN_TYPE_SCRYPT;
9615 dgst_size = DGST_SIZE_4_8;
9616 parse_func = scrypt_parse_hash;
9617 sort_by_digest = sort_by_digest_4_8;
9618 opti_type = OPTI_TYPE_ZERO_BYTE;
9619 dgst_pos0 = 0;
9620 dgst_pos1 = 1;
9621 dgst_pos2 = 2;
9622 dgst_pos3 = 3;
9623 break;
9624
9625 case 9000: hash_type = HASH_TYPE_SHA1;
9626 salt_type = SALT_TYPE_EMBEDDED;
9627 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9628 opts_type = OPTS_TYPE_PT_GENERATE_LE
9629 | OPTS_TYPE_ST_GENERATE_LE;
9630 kern_type = KERN_TYPE_PSAFE2;
9631 dgst_size = DGST_SIZE_4_5;
9632 parse_func = psafe2_parse_hash;
9633 sort_by_digest = sort_by_digest_4_5;
9634 opti_type = OPTI_TYPE_ZERO_BYTE;
9635 dgst_pos0 = 0;
9636 dgst_pos1 = 1;
9637 dgst_pos2 = 2;
9638 dgst_pos3 = 3;
9639 break;
9640
9641 case 9100: hash_type = HASH_TYPE_LOTUS8;
9642 salt_type = SALT_TYPE_EMBEDDED;
9643 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9644 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9645 kern_type = KERN_TYPE_LOTUS8;
9646 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9647 parse_func = lotus8_parse_hash;
9648 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9649 opti_type = OPTI_TYPE_ZERO_BYTE;
9650 dgst_pos0 = 0;
9651 dgst_pos1 = 1;
9652 dgst_pos2 = 2;
9653 dgst_pos3 = 3;
9654 break;
9655
9656 case 9200: hash_type = HASH_TYPE_SHA256;
9657 salt_type = SALT_TYPE_EMBEDDED;
9658 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9659 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9660 kern_type = KERN_TYPE_PBKDF2_SHA256;
9661 dgst_size = DGST_SIZE_4_32;
9662 parse_func = cisco8_parse_hash;
9663 sort_by_digest = sort_by_digest_4_32;
9664 opti_type = OPTI_TYPE_ZERO_BYTE
9665 | OPTI_TYPE_SLOW_HASH_SIMD;
9666 dgst_pos0 = 0;
9667 dgst_pos1 = 1;
9668 dgst_pos2 = 2;
9669 dgst_pos3 = 3;
9670 break;
9671
9672 case 9300: hash_type = HASH_TYPE_SCRYPT;
9673 salt_type = SALT_TYPE_EMBEDDED;
9674 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9675 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9676 kern_type = KERN_TYPE_SCRYPT;
9677 dgst_size = DGST_SIZE_4_8;
9678 parse_func = cisco9_parse_hash;
9679 sort_by_digest = sort_by_digest_4_8;
9680 opti_type = OPTI_TYPE_ZERO_BYTE;
9681 dgst_pos0 = 0;
9682 dgst_pos1 = 1;
9683 dgst_pos2 = 2;
9684 dgst_pos3 = 3;
9685 break;
9686
9687 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9688 salt_type = SALT_TYPE_EMBEDDED;
9689 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9690 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9691 kern_type = KERN_TYPE_OFFICE2007;
9692 dgst_size = DGST_SIZE_4_4;
9693 parse_func = office2007_parse_hash;
9694 sort_by_digest = sort_by_digest_4_4;
9695 opti_type = OPTI_TYPE_ZERO_BYTE;
9696 dgst_pos0 = 0;
9697 dgst_pos1 = 1;
9698 dgst_pos2 = 2;
9699 dgst_pos3 = 3;
9700 break;
9701
9702 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9703 salt_type = SALT_TYPE_EMBEDDED;
9704 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9705 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9706 kern_type = KERN_TYPE_OFFICE2010;
9707 dgst_size = DGST_SIZE_4_4;
9708 parse_func = office2010_parse_hash;
9709 sort_by_digest = sort_by_digest_4_4;
9710 opti_type = OPTI_TYPE_ZERO_BYTE;
9711 dgst_pos0 = 0;
9712 dgst_pos1 = 1;
9713 dgst_pos2 = 2;
9714 dgst_pos3 = 3;
9715 break;
9716
9717 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9718 salt_type = SALT_TYPE_EMBEDDED;
9719 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9720 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9721 kern_type = KERN_TYPE_OFFICE2013;
9722 dgst_size = DGST_SIZE_4_4;
9723 parse_func = office2013_parse_hash;
9724 sort_by_digest = sort_by_digest_4_4;
9725 opti_type = OPTI_TYPE_ZERO_BYTE;
9726 dgst_pos0 = 0;
9727 dgst_pos1 = 1;
9728 dgst_pos2 = 2;
9729 dgst_pos3 = 3;
9730 break;
9731
9732 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9733 salt_type = SALT_TYPE_EMBEDDED;
9734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9735 opts_type = OPTS_TYPE_PT_GENERATE_LE
9736 | OPTS_TYPE_PT_ADD80
9737 | OPTS_TYPE_PT_UNICODE;
9738 kern_type = KERN_TYPE_OLDOFFICE01;
9739 dgst_size = DGST_SIZE_4_4;
9740 parse_func = oldoffice01_parse_hash;
9741 sort_by_digest = sort_by_digest_4_4;
9742 opti_type = OPTI_TYPE_ZERO_BYTE
9743 | OPTI_TYPE_PRECOMPUTE_INIT
9744 | OPTI_TYPE_NOT_ITERATED;
9745 dgst_pos0 = 0;
9746 dgst_pos1 = 1;
9747 dgst_pos2 = 2;
9748 dgst_pos3 = 3;
9749 break;
9750
9751 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9752 salt_type = SALT_TYPE_EMBEDDED;
9753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9754 opts_type = OPTS_TYPE_PT_GENERATE_LE
9755 | OPTS_TYPE_PT_ADD80;
9756 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9757 dgst_size = DGST_SIZE_4_4;
9758 parse_func = oldoffice01cm1_parse_hash;
9759 sort_by_digest = sort_by_digest_4_4;
9760 opti_type = OPTI_TYPE_ZERO_BYTE
9761 | OPTI_TYPE_PRECOMPUTE_INIT
9762 | OPTI_TYPE_NOT_ITERATED;
9763 dgst_pos0 = 0;
9764 dgst_pos1 = 1;
9765 dgst_pos2 = 2;
9766 dgst_pos3 = 3;
9767 break;
9768
9769 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9770 salt_type = SALT_TYPE_EMBEDDED;
9771 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9772 opts_type = OPTS_TYPE_PT_GENERATE_LE
9773 | OPTS_TYPE_PT_ADD80
9774 | OPTS_TYPE_PT_UNICODE
9775 | OPTS_TYPE_PT_NEVERCRACK;
9776 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9777 dgst_size = DGST_SIZE_4_4;
9778 parse_func = oldoffice01cm2_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 9800: 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 kern_type = KERN_TYPE_OLDOFFICE34;
9796 dgst_size = DGST_SIZE_4_4;
9797 parse_func = oldoffice34_parse_hash;
9798 sort_by_digest = sort_by_digest_4_4;
9799 opti_type = OPTI_TYPE_ZERO_BYTE
9800 | OPTI_TYPE_PRECOMPUTE_INIT
9801 | OPTI_TYPE_NOT_ITERATED;
9802 dgst_pos0 = 0;
9803 dgst_pos1 = 1;
9804 dgst_pos2 = 2;
9805 dgst_pos3 = 3;
9806 break;
9807
9808 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9809 salt_type = SALT_TYPE_EMBEDDED;
9810 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9811 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9812 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9813 dgst_size = DGST_SIZE_4_4;
9814 parse_func = oldoffice34cm1_parse_hash;
9815 sort_by_digest = sort_by_digest_4_4;
9816 opti_type = OPTI_TYPE_ZERO_BYTE
9817 | OPTI_TYPE_PRECOMPUTE_INIT
9818 | OPTI_TYPE_NOT_ITERATED;
9819 dgst_pos0 = 0;
9820 dgst_pos1 = 1;
9821 dgst_pos2 = 2;
9822 dgst_pos3 = 3;
9823 break;
9824
9825 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9826 salt_type = SALT_TYPE_EMBEDDED;
9827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9828 opts_type = OPTS_TYPE_PT_GENERATE_BE
9829 | OPTS_TYPE_PT_ADD80
9830 | OPTS_TYPE_PT_UNICODE
9831 | OPTS_TYPE_PT_NEVERCRACK;
9832 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9833 dgst_size = DGST_SIZE_4_4;
9834 parse_func = oldoffice34cm2_parse_hash;
9835 sort_by_digest = sort_by_digest_4_4;
9836 opti_type = OPTI_TYPE_ZERO_BYTE
9837 | OPTI_TYPE_PRECOMPUTE_INIT
9838 | OPTI_TYPE_NOT_ITERATED;
9839 dgst_pos0 = 0;
9840 dgst_pos1 = 1;
9841 dgst_pos2 = 2;
9842 dgst_pos3 = 3;
9843 break;
9844
9845 case 9900: hash_type = HASH_TYPE_MD5;
9846 salt_type = SALT_TYPE_NONE;
9847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9848 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9849 kern_type = KERN_TYPE_RADMIN2;
9850 dgst_size = DGST_SIZE_4_4;
9851 parse_func = radmin2_parse_hash;
9852 sort_by_digest = sort_by_digest_4_4;
9853 opti_type = OPTI_TYPE_ZERO_BYTE
9854 | OPTI_TYPE_PRECOMPUTE_INIT
9855 | OPTI_TYPE_EARLY_SKIP
9856 | OPTI_TYPE_NOT_ITERATED
9857 | OPTI_TYPE_NOT_SALTED;
9858 dgst_pos0 = 0;
9859 dgst_pos1 = 3;
9860 dgst_pos2 = 2;
9861 dgst_pos3 = 1;
9862 break;
9863
9864 case 10000: hash_type = HASH_TYPE_SHA256;
9865 salt_type = SALT_TYPE_EMBEDDED;
9866 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9867 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9868 kern_type = KERN_TYPE_PBKDF2_SHA256;
9869 dgst_size = DGST_SIZE_4_32;
9870 parse_func = djangopbkdf2_parse_hash;
9871 sort_by_digest = sort_by_digest_4_32;
9872 opti_type = OPTI_TYPE_ZERO_BYTE
9873 | OPTI_TYPE_SLOW_HASH_SIMD;
9874 dgst_pos0 = 0;
9875 dgst_pos1 = 1;
9876 dgst_pos2 = 2;
9877 dgst_pos3 = 3;
9878 break;
9879
9880 case 10100: hash_type = HASH_TYPE_SIPHASH;
9881 salt_type = SALT_TYPE_EMBEDDED;
9882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9883 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9884 kern_type = KERN_TYPE_SIPHASH;
9885 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9886 parse_func = siphash_parse_hash;
9887 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9888 opti_type = OPTI_TYPE_ZERO_BYTE
9889 | OPTI_TYPE_NOT_ITERATED
9890 | OPTI_TYPE_RAW_HASH;
9891 dgst_pos0 = 0;
9892 dgst_pos1 = 1;
9893 dgst_pos2 = 2;
9894 dgst_pos3 = 3;
9895 break;
9896
9897 case 10200: hash_type = HASH_TYPE_MD5;
9898 salt_type = SALT_TYPE_EMBEDDED;
9899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9900 opts_type = OPTS_TYPE_PT_GENERATE_LE
9901 | OPTS_TYPE_ST_ADD80
9902 | OPTS_TYPE_ST_ADDBITS14;
9903 kern_type = KERN_TYPE_HMACMD5_PW;
9904 dgst_size = DGST_SIZE_4_4;
9905 parse_func = crammd5_parse_hash;
9906 sort_by_digest = sort_by_digest_4_4;
9907 opti_type = OPTI_TYPE_ZERO_BYTE
9908 | OPTI_TYPE_NOT_ITERATED;
9909 dgst_pos0 = 0;
9910 dgst_pos1 = 3;
9911 dgst_pos2 = 2;
9912 dgst_pos3 = 1;
9913 break;
9914
9915 case 10300: hash_type = HASH_TYPE_SHA1;
9916 salt_type = SALT_TYPE_EMBEDDED;
9917 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9918 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9919 kern_type = KERN_TYPE_SAPH_SHA1;
9920 dgst_size = DGST_SIZE_4_5;
9921 parse_func = saph_sha1_parse_hash;
9922 sort_by_digest = sort_by_digest_4_5;
9923 opti_type = OPTI_TYPE_ZERO_BYTE;
9924 dgst_pos0 = 0;
9925 dgst_pos1 = 1;
9926 dgst_pos2 = 2;
9927 dgst_pos3 = 3;
9928 break;
9929
9930 case 10400: hash_type = HASH_TYPE_PDFU16;
9931 salt_type = SALT_TYPE_EMBEDDED;
9932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9933 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9934 kern_type = KERN_TYPE_PDF11;
9935 dgst_size = DGST_SIZE_4_4;
9936 parse_func = pdf11_parse_hash;
9937 sort_by_digest = sort_by_digest_4_4;
9938 opti_type = OPTI_TYPE_ZERO_BYTE
9939 | OPTI_TYPE_NOT_ITERATED;
9940 dgst_pos0 = 0;
9941 dgst_pos1 = 1;
9942 dgst_pos2 = 2;
9943 dgst_pos3 = 3;
9944 break;
9945
9946 case 10410: hash_type = HASH_TYPE_PDFU16;
9947 salt_type = SALT_TYPE_EMBEDDED;
9948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9949 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9950 kern_type = KERN_TYPE_PDF11CM1;
9951 dgst_size = DGST_SIZE_4_4;
9952 parse_func = pdf11cm1_parse_hash;
9953 sort_by_digest = sort_by_digest_4_4;
9954 opti_type = OPTI_TYPE_ZERO_BYTE
9955 | OPTI_TYPE_NOT_ITERATED;
9956 dgst_pos0 = 0;
9957 dgst_pos1 = 1;
9958 dgst_pos2 = 2;
9959 dgst_pos3 = 3;
9960 break;
9961
9962 case 10420: hash_type = HASH_TYPE_PDFU16;
9963 salt_type = SALT_TYPE_EMBEDDED;
9964 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9965 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9966 kern_type = KERN_TYPE_PDF11CM2;
9967 dgst_size = DGST_SIZE_4_4;
9968 parse_func = pdf11cm2_parse_hash;
9969 sort_by_digest = sort_by_digest_4_4;
9970 opti_type = OPTI_TYPE_ZERO_BYTE
9971 | OPTI_TYPE_NOT_ITERATED;
9972 dgst_pos0 = 0;
9973 dgst_pos1 = 1;
9974 dgst_pos2 = 2;
9975 dgst_pos3 = 3;
9976 break;
9977
9978 case 10500: hash_type = HASH_TYPE_PDFU16;
9979 salt_type = SALT_TYPE_EMBEDDED;
9980 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9981 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9982 kern_type = KERN_TYPE_PDF14;
9983 dgst_size = DGST_SIZE_4_4;
9984 parse_func = pdf14_parse_hash;
9985 sort_by_digest = sort_by_digest_4_4;
9986 opti_type = OPTI_TYPE_ZERO_BYTE
9987 | OPTI_TYPE_NOT_ITERATED;
9988 dgst_pos0 = 0;
9989 dgst_pos1 = 1;
9990 dgst_pos2 = 2;
9991 dgst_pos3 = 3;
9992 break;
9993
9994 case 10600: hash_type = HASH_TYPE_SHA256;
9995 salt_type = SALT_TYPE_EMBEDDED;
9996 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9997 opts_type = OPTS_TYPE_PT_GENERATE_BE
9998 | OPTS_TYPE_ST_ADD80
9999 | OPTS_TYPE_ST_ADDBITS15
10000 | OPTS_TYPE_HASH_COPY;
10001 kern_type = KERN_TYPE_SHA256_PWSLT;
10002 dgst_size = DGST_SIZE_4_8;
10003 parse_func = pdf17l3_parse_hash;
10004 sort_by_digest = sort_by_digest_4_8;
10005 opti_type = OPTI_TYPE_ZERO_BYTE
10006 | OPTI_TYPE_PRECOMPUTE_INIT
10007 | OPTI_TYPE_PRECOMPUTE_MERKLE
10008 | OPTI_TYPE_EARLY_SKIP
10009 | OPTI_TYPE_NOT_ITERATED
10010 | OPTI_TYPE_APPENDED_SALT
10011 | OPTI_TYPE_RAW_HASH;
10012 dgst_pos0 = 3;
10013 dgst_pos1 = 7;
10014 dgst_pos2 = 2;
10015 dgst_pos3 = 6;
10016 break;
10017
10018 case 10700: hash_type = HASH_TYPE_PDFU32;
10019 salt_type = SALT_TYPE_EMBEDDED;
10020 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10021 opts_type = OPTS_TYPE_PT_GENERATE_LE
10022 | OPTS_TYPE_HASH_COPY;
10023 kern_type = KERN_TYPE_PDF17L8;
10024 dgst_size = DGST_SIZE_4_8;
10025 parse_func = pdf17l8_parse_hash;
10026 sort_by_digest = sort_by_digest_4_8;
10027 opti_type = OPTI_TYPE_ZERO_BYTE
10028 | OPTI_TYPE_NOT_ITERATED;
10029 dgst_pos0 = 0;
10030 dgst_pos1 = 1;
10031 dgst_pos2 = 2;
10032 dgst_pos3 = 3;
10033 break;
10034
10035 case 10800: hash_type = HASH_TYPE_SHA384;
10036 salt_type = SALT_TYPE_NONE;
10037 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10038 opts_type = OPTS_TYPE_PT_GENERATE_BE
10039 | OPTS_TYPE_PT_ADD80
10040 | OPTS_TYPE_PT_ADDBITS15;
10041 kern_type = KERN_TYPE_SHA384;
10042 dgst_size = DGST_SIZE_8_8;
10043 parse_func = sha384_parse_hash;
10044 sort_by_digest = sort_by_digest_8_8;
10045 opti_type = OPTI_TYPE_ZERO_BYTE
10046 | OPTI_TYPE_PRECOMPUTE_INIT
10047 | OPTI_TYPE_PRECOMPUTE_MERKLE
10048 | OPTI_TYPE_EARLY_SKIP
10049 | OPTI_TYPE_NOT_ITERATED
10050 | OPTI_TYPE_NOT_SALTED
10051 | OPTI_TYPE_USES_BITS_64
10052 | OPTI_TYPE_RAW_HASH;
10053 dgst_pos0 = 6;
10054 dgst_pos1 = 7;
10055 dgst_pos2 = 4;
10056 dgst_pos3 = 5;
10057 break;
10058
10059 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10060 salt_type = SALT_TYPE_EMBEDDED;
10061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10062 opts_type = OPTS_TYPE_PT_GENERATE_LE
10063 | OPTS_TYPE_ST_BASE64
10064 | OPTS_TYPE_HASH_COPY;
10065 kern_type = KERN_TYPE_PBKDF2_SHA256;
10066 dgst_size = DGST_SIZE_4_32;
10067 parse_func = pbkdf2_sha256_parse_hash;
10068 sort_by_digest = sort_by_digest_4_32;
10069 opti_type = OPTI_TYPE_ZERO_BYTE
10070 | OPTI_TYPE_SLOW_HASH_SIMD;
10071 dgst_pos0 = 0;
10072 dgst_pos1 = 1;
10073 dgst_pos2 = 2;
10074 dgst_pos3 = 3;
10075 break;
10076
10077 case 11000: hash_type = HASH_TYPE_MD5;
10078 salt_type = SALT_TYPE_INTERN;
10079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10080 opts_type = OPTS_TYPE_PT_GENERATE_LE
10081 | OPTS_TYPE_PT_ADD80;
10082 kern_type = KERN_TYPE_PRESTASHOP;
10083 dgst_size = DGST_SIZE_4_4;
10084 parse_func = prestashop_parse_hash;
10085 sort_by_digest = sort_by_digest_4_4;
10086 opti_type = OPTI_TYPE_ZERO_BYTE
10087 | OPTI_TYPE_PRECOMPUTE_INIT
10088 | OPTI_TYPE_NOT_ITERATED
10089 | OPTI_TYPE_PREPENDED_SALT;
10090 dgst_pos0 = 0;
10091 dgst_pos1 = 3;
10092 dgst_pos2 = 2;
10093 dgst_pos3 = 1;
10094 break;
10095
10096 case 11100: hash_type = HASH_TYPE_MD5;
10097 salt_type = SALT_TYPE_EMBEDDED;
10098 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10099 opts_type = OPTS_TYPE_PT_GENERATE_LE
10100 | OPTS_TYPE_ST_ADD80;
10101 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10102 dgst_size = DGST_SIZE_4_4;
10103 parse_func = postgresql_auth_parse_hash;
10104 sort_by_digest = sort_by_digest_4_4;
10105 opti_type = OPTI_TYPE_ZERO_BYTE
10106 | OPTI_TYPE_PRECOMPUTE_INIT
10107 | OPTI_TYPE_PRECOMPUTE_MERKLE
10108 | OPTI_TYPE_EARLY_SKIP;
10109 dgst_pos0 = 0;
10110 dgst_pos1 = 3;
10111 dgst_pos2 = 2;
10112 dgst_pos3 = 1;
10113 break;
10114
10115 case 11200: hash_type = HASH_TYPE_SHA1;
10116 salt_type = SALT_TYPE_EMBEDDED;
10117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10118 opts_type = OPTS_TYPE_PT_GENERATE_BE
10119 | OPTS_TYPE_PT_ADD80
10120 | OPTS_TYPE_ST_HEX;
10121 kern_type = KERN_TYPE_MYSQL_AUTH;
10122 dgst_size = DGST_SIZE_4_5;
10123 parse_func = mysql_auth_parse_hash;
10124 sort_by_digest = sort_by_digest_4_5;
10125 opti_type = OPTI_TYPE_ZERO_BYTE
10126 | OPTI_TYPE_EARLY_SKIP;
10127 dgst_pos0 = 3;
10128 dgst_pos1 = 4;
10129 dgst_pos2 = 2;
10130 dgst_pos3 = 1;
10131 break;
10132
10133 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10134 salt_type = SALT_TYPE_EMBEDDED;
10135 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10136 opts_type = OPTS_TYPE_PT_GENERATE_LE
10137 | OPTS_TYPE_ST_HEX
10138 | OPTS_TYPE_ST_ADD80;
10139 kern_type = KERN_TYPE_BITCOIN_WALLET;
10140 dgst_size = DGST_SIZE_4_4;
10141 parse_func = bitcoin_wallet_parse_hash;
10142 sort_by_digest = sort_by_digest_4_4;
10143 opti_type = OPTI_TYPE_ZERO_BYTE;
10144 dgst_pos0 = 0;
10145 dgst_pos1 = 1;
10146 dgst_pos2 = 2;
10147 dgst_pos3 = 3;
10148 break;
10149
10150 case 11400: hash_type = HASH_TYPE_MD5;
10151 salt_type = SALT_TYPE_EMBEDDED;
10152 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10153 opts_type = OPTS_TYPE_PT_GENERATE_LE
10154 | OPTS_TYPE_PT_ADD80
10155 | OPTS_TYPE_HASH_COPY;
10156 kern_type = KERN_TYPE_SIP_AUTH;
10157 dgst_size = DGST_SIZE_4_4;
10158 parse_func = sip_auth_parse_hash;
10159 sort_by_digest = sort_by_digest_4_4;
10160 opti_type = OPTI_TYPE_ZERO_BYTE;
10161 dgst_pos0 = 0;
10162 dgst_pos1 = 3;
10163 dgst_pos2 = 2;
10164 dgst_pos3 = 1;
10165 break;
10166
10167 case 11500: hash_type = HASH_TYPE_CRC32;
10168 salt_type = SALT_TYPE_INTERN;
10169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10170 opts_type = OPTS_TYPE_PT_GENERATE_LE
10171 | OPTS_TYPE_ST_GENERATE_LE
10172 | OPTS_TYPE_ST_HEX;
10173 kern_type = KERN_TYPE_CRC32;
10174 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10175 parse_func = crc32_parse_hash;
10176 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10177 opti_type = OPTI_TYPE_ZERO_BYTE;
10178 dgst_pos0 = 0;
10179 dgst_pos1 = 1;
10180 dgst_pos2 = 2;
10181 dgst_pos3 = 3;
10182 break;
10183
10184 case 11600: hash_type = HASH_TYPE_AES;
10185 salt_type = SALT_TYPE_EMBEDDED;
10186 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10187 opts_type = OPTS_TYPE_PT_GENERATE_LE
10188 | OPTS_TYPE_PT_NEVERCRACK;
10189 kern_type = KERN_TYPE_SEVEN_ZIP;
10190 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10191 parse_func = seven_zip_parse_hash;
10192 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10193 opti_type = OPTI_TYPE_ZERO_BYTE;
10194 dgst_pos0 = 0;
10195 dgst_pos1 = 1;
10196 dgst_pos2 = 2;
10197 dgst_pos3 = 3;
10198 break;
10199
10200 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10201 salt_type = SALT_TYPE_NONE;
10202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10203 opts_type = OPTS_TYPE_PT_GENERATE_LE
10204 | OPTS_TYPE_PT_ADD01;
10205 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10206 dgst_size = DGST_SIZE_4_8;
10207 parse_func = gost2012sbog_256_parse_hash;
10208 sort_by_digest = sort_by_digest_4_8;
10209 opti_type = OPTI_TYPE_ZERO_BYTE;
10210 dgst_pos0 = 0;
10211 dgst_pos1 = 1;
10212 dgst_pos2 = 2;
10213 dgst_pos3 = 3;
10214 break;
10215
10216 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10217 salt_type = SALT_TYPE_NONE;
10218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10219 opts_type = OPTS_TYPE_PT_GENERATE_LE
10220 | OPTS_TYPE_PT_ADD01;
10221 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10222 dgst_size = DGST_SIZE_4_16;
10223 parse_func = gost2012sbog_512_parse_hash;
10224 sort_by_digest = sort_by_digest_4_16;
10225 opti_type = OPTI_TYPE_ZERO_BYTE;
10226 dgst_pos0 = 0;
10227 dgst_pos1 = 1;
10228 dgst_pos2 = 2;
10229 dgst_pos3 = 3;
10230 break;
10231
10232 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
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_MD5;
10239 dgst_size = DGST_SIZE_4_32;
10240 parse_func = pbkdf2_md5_parse_hash;
10241 sort_by_digest = sort_by_digest_4_32;
10242 opti_type = OPTI_TYPE_ZERO_BYTE
10243 | OPTI_TYPE_SLOW_HASH_SIMD;
10244 dgst_pos0 = 0;
10245 dgst_pos1 = 1;
10246 dgst_pos2 = 2;
10247 dgst_pos3 = 3;
10248 break;
10249
10250 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10251 salt_type = SALT_TYPE_EMBEDDED;
10252 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10253 opts_type = OPTS_TYPE_PT_GENERATE_LE
10254 | OPTS_TYPE_ST_BASE64
10255 | OPTS_TYPE_HASH_COPY;
10256 kern_type = KERN_TYPE_PBKDF2_SHA1;
10257 dgst_size = DGST_SIZE_4_32;
10258 parse_func = pbkdf2_sha1_parse_hash;
10259 sort_by_digest = sort_by_digest_4_32;
10260 opti_type = OPTI_TYPE_ZERO_BYTE
10261 | OPTI_TYPE_SLOW_HASH_SIMD;
10262 dgst_pos0 = 0;
10263 dgst_pos1 = 1;
10264 dgst_pos2 = 2;
10265 dgst_pos3 = 3;
10266 break;
10267
10268 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10269 salt_type = SALT_TYPE_EMBEDDED;
10270 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10271 opts_type = OPTS_TYPE_PT_GENERATE_LE
10272 | OPTS_TYPE_ST_BASE64
10273 | OPTS_TYPE_HASH_COPY;
10274 kern_type = KERN_TYPE_PBKDF2_SHA512;
10275 dgst_size = DGST_SIZE_8_16;
10276 parse_func = pbkdf2_sha512_parse_hash;
10277 sort_by_digest = sort_by_digest_8_16;
10278 opti_type = OPTI_TYPE_ZERO_BYTE
10279 | OPTI_TYPE_USES_BITS_64
10280 | OPTI_TYPE_SLOW_HASH_SIMD;
10281 dgst_pos0 = 0;
10282 dgst_pos1 = 1;
10283 dgst_pos2 = 2;
10284 dgst_pos3 = 3;
10285 break;
10286
10287 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10288 salt_type = SALT_TYPE_EMBEDDED;
10289 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10290 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10291 kern_type = KERN_TYPE_ECRYPTFS;
10292 dgst_size = DGST_SIZE_8_8;
10293 parse_func = ecryptfs_parse_hash;
10294 sort_by_digest = sort_by_digest_8_8;
10295 opti_type = OPTI_TYPE_ZERO_BYTE
10296 | OPTI_TYPE_USES_BITS_64;
10297 dgst_pos0 = 0;
10298 dgst_pos1 = 1;
10299 dgst_pos2 = 2;
10300 dgst_pos3 = 3;
10301 break;
10302
10303 case 12300: hash_type = HASH_TYPE_ORACLET;
10304 salt_type = SALT_TYPE_EMBEDDED;
10305 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10306 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10307 kern_type = KERN_TYPE_ORACLET;
10308 dgst_size = DGST_SIZE_8_16;
10309 parse_func = oraclet_parse_hash;
10310 sort_by_digest = sort_by_digest_8_16;
10311 opti_type = OPTI_TYPE_ZERO_BYTE
10312 | OPTI_TYPE_USES_BITS_64;
10313 dgst_pos0 = 0;
10314 dgst_pos1 = 1;
10315 dgst_pos2 = 2;
10316 dgst_pos3 = 3;
10317 break;
10318
10319 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10320 salt_type = SALT_TYPE_EMBEDDED;
10321 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10322 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10323 kern_type = KERN_TYPE_BSDICRYPT;
10324 dgst_size = DGST_SIZE_4_4;
10325 parse_func = bsdicrypt_parse_hash;
10326 sort_by_digest = sort_by_digest_4_4;
10327 opti_type = OPTI_TYPE_ZERO_BYTE
10328 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10329 dgst_pos0 = 0;
10330 dgst_pos1 = 1;
10331 dgst_pos2 = 2;
10332 dgst_pos3 = 3;
10333 break;
10334
10335 case 12500: hash_type = HASH_TYPE_RAR3HP;
10336 salt_type = SALT_TYPE_EMBEDDED;
10337 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10338 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10339 kern_type = KERN_TYPE_RAR3;
10340 dgst_size = DGST_SIZE_4_4;
10341 parse_func = rar3hp_parse_hash;
10342 sort_by_digest = sort_by_digest_4_4;
10343 opti_type = OPTI_TYPE_ZERO_BYTE;
10344 dgst_pos0 = 0;
10345 dgst_pos1 = 1;
10346 dgst_pos2 = 2;
10347 dgst_pos3 = 3;
10348 break;
10349
10350 case 12600: hash_type = HASH_TYPE_SHA256;
10351 salt_type = SALT_TYPE_INTERN;
10352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10353 opts_type = OPTS_TYPE_PT_GENERATE_BE
10354 | OPTS_TYPE_PT_ADD80;
10355 kern_type = KERN_TYPE_CF10;
10356 dgst_size = DGST_SIZE_4_8;
10357 parse_func = cf10_parse_hash;
10358 sort_by_digest = sort_by_digest_4_8;
10359 opti_type = OPTI_TYPE_ZERO_BYTE
10360 | OPTI_TYPE_PRECOMPUTE_INIT
10361 | OPTI_TYPE_EARLY_SKIP
10362 | OPTI_TYPE_NOT_ITERATED;
10363 dgst_pos0 = 3;
10364 dgst_pos1 = 7;
10365 dgst_pos2 = 2;
10366 dgst_pos3 = 6;
10367 break;
10368
10369 case 12700: hash_type = HASH_TYPE_AES;
10370 salt_type = SALT_TYPE_EMBEDDED;
10371 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10372 opts_type = OPTS_TYPE_PT_GENERATE_LE
10373 | OPTS_TYPE_HASH_COPY;
10374 kern_type = KERN_TYPE_MYWALLET;
10375 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10376 parse_func = mywallet_parse_hash;
10377 sort_by_digest = sort_by_digest_4_5;
10378 opti_type = OPTI_TYPE_ZERO_BYTE;
10379 dgst_pos0 = 0;
10380 dgst_pos1 = 1;
10381 dgst_pos2 = 2;
10382 dgst_pos3 = 3;
10383 break;
10384
10385 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10386 salt_type = SALT_TYPE_EMBEDDED;
10387 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10388 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10389 kern_type = KERN_TYPE_MS_DRSR;
10390 dgst_size = DGST_SIZE_4_8;
10391 parse_func = ms_drsr_parse_hash;
10392 sort_by_digest = sort_by_digest_4_8;
10393 opti_type = OPTI_TYPE_ZERO_BYTE;
10394 dgst_pos0 = 0;
10395 dgst_pos1 = 1;
10396 dgst_pos2 = 2;
10397 dgst_pos3 = 3;
10398 break;
10399
10400 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10401 salt_type = SALT_TYPE_EMBEDDED;
10402 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10403 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10404 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10405 dgst_size = DGST_SIZE_4_8;
10406 parse_func = androidfde_samsung_parse_hash;
10407 sort_by_digest = sort_by_digest_4_8;
10408 opti_type = OPTI_TYPE_ZERO_BYTE;
10409 dgst_pos0 = 0;
10410 dgst_pos1 = 1;
10411 dgst_pos2 = 2;
10412 dgst_pos3 = 3;
10413 break;
10414
10415 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10416 salt_type = SALT_TYPE_EMBEDDED;
10417 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10418 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10419 kern_type = KERN_TYPE_RAR5;
10420 dgst_size = DGST_SIZE_4_4;
10421 parse_func = rar5_parse_hash;
10422 sort_by_digest = sort_by_digest_4_4;
10423 opti_type = OPTI_TYPE_ZERO_BYTE;
10424 dgst_pos0 = 0;
10425 dgst_pos1 = 1;
10426 dgst_pos2 = 2;
10427 dgst_pos3 = 3;
10428 break;
10429
10430 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10431 salt_type = SALT_TYPE_EMBEDDED;
10432 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10433 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10434 kern_type = KERN_TYPE_KRB5TGS;
10435 dgst_size = DGST_SIZE_4_4;
10436 parse_func = krb5tgs_parse_hash;
10437 sort_by_digest = sort_by_digest_4_4;
10438 opti_type = OPTI_TYPE_ZERO_BYTE
10439 | OPTI_TYPE_NOT_ITERATED;
10440 dgst_pos0 = 0;
10441 dgst_pos1 = 1;
10442 dgst_pos2 = 2;
10443 dgst_pos3 = 3;
10444 break;
10445
10446 case 13200: 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_AXCRYPT;
10451 dgst_size = DGST_SIZE_4_4;
10452 parse_func = axcrypt_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 13300: hash_type = HASH_TYPE_SHA1;
10462 salt_type = SALT_TYPE_NONE;
10463 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10464 opts_type = OPTS_TYPE_PT_GENERATE_BE
10465 | OPTS_TYPE_PT_ADD80
10466 | OPTS_TYPE_PT_ADDBITS15;
10467 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10468 dgst_size = DGST_SIZE_4_5;
10469 parse_func = sha1axcrypt_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_NOT_SALTED;
10476 dgst_pos0 = 0;
10477 dgst_pos1 = 4;
10478 dgst_pos2 = 3;
10479 dgst_pos3 = 2;
10480 break;
10481
10482 case 13400: hash_type = HASH_TYPE_AES;
10483 salt_type = SALT_TYPE_EMBEDDED;
10484 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10485 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10486 kern_type = KERN_TYPE_KEEPASS;
10487 dgst_size = DGST_SIZE_4_4;
10488 parse_func = keepass_parse_hash;
10489 sort_by_digest = sort_by_digest_4_4;
10490 opti_type = OPTI_TYPE_ZERO_BYTE;
10491 dgst_pos0 = 0;
10492 dgst_pos1 = 1;
10493 dgst_pos2 = 2;
10494 dgst_pos3 = 3;
10495 break;
10496
10497 case 13500: hash_type = HASH_TYPE_SHA1;
10498 salt_type = SALT_TYPE_EMBEDDED;
10499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10500 opts_type = OPTS_TYPE_PT_GENERATE_BE
10501 | OPTS_TYPE_PT_UNICODE
10502 | OPTS_TYPE_PT_ADD80;
10503 kern_type = KERN_TYPE_PSTOKEN;
10504 dgst_size = DGST_SIZE_4_5;
10505 parse_func = pstoken_parse_hash;
10506 sort_by_digest = sort_by_digest_4_5;
10507 opti_type = OPTI_TYPE_ZERO_BYTE
10508 | OPTI_TYPE_PRECOMPUTE_INIT
10509 | OPTI_TYPE_EARLY_SKIP
10510 | OPTI_TYPE_NOT_ITERATED
10511 | OPTI_TYPE_PREPENDED_SALT
10512 | OPTI_TYPE_RAW_HASH;
10513 dgst_pos0 = 3;
10514 dgst_pos1 = 4;
10515 dgst_pos2 = 2;
10516 dgst_pos3 = 1;
10517 break;
10518
10519 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10520 salt_type = SALT_TYPE_EMBEDDED;
10521 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10522 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10523 kern_type = KERN_TYPE_ZIP2;
10524 dgst_size = DGST_SIZE_4_4;
10525 parse_func = zip2_parse_hash;
10526 sort_by_digest = sort_by_digest_4_4;
10527 opti_type = OPTI_TYPE_ZERO_BYTE;
10528 dgst_pos0 = 0;
10529 dgst_pos1 = 1;
10530 dgst_pos2 = 2;
10531 dgst_pos3 = 3;
10532 break;
10533
10534 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10535 salt_type = SALT_TYPE_EMBEDDED;
10536 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10537 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10538 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10539 dgst_size = DGST_SIZE_4_5;
10540 parse_func = veracrypt_parse_hash_655331;
10541 sort_by_digest = sort_by_digest_4_5;
10542 opti_type = OPTI_TYPE_ZERO_BYTE;
10543 dgst_pos0 = 0;
10544 dgst_pos1 = 1;
10545 dgst_pos2 = 2;
10546 dgst_pos3 = 3;
10547 break;
10548
10549 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10550 salt_type = SALT_TYPE_EMBEDDED;
10551 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10552 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10553 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10554 dgst_size = DGST_SIZE_4_5;
10555 parse_func = veracrypt_parse_hash_655331;
10556 sort_by_digest = sort_by_digest_4_5;
10557 opti_type = OPTI_TYPE_ZERO_BYTE;
10558 dgst_pos0 = 0;
10559 dgst_pos1 = 1;
10560 dgst_pos2 = 2;
10561 dgst_pos3 = 3;
10562 break;
10563
10564 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10565 salt_type = SALT_TYPE_EMBEDDED;
10566 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10567 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10568 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10569 dgst_size = DGST_SIZE_4_5;
10570 parse_func = veracrypt_parse_hash_655331;
10571 sort_by_digest = sort_by_digest_4_5;
10572 opti_type = OPTI_TYPE_ZERO_BYTE;
10573 dgst_pos0 = 0;
10574 dgst_pos1 = 1;
10575 dgst_pos2 = 2;
10576 dgst_pos3 = 3;
10577 break;
10578
10579 case 13721: hash_type = HASH_TYPE_SHA512;
10580 salt_type = SALT_TYPE_EMBEDDED;
10581 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10582 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10583 kern_type = KERN_TYPE_TCSHA512_XTS512;
10584 dgst_size = DGST_SIZE_8_8;
10585 parse_func = veracrypt_parse_hash_500000;
10586 sort_by_digest = sort_by_digest_8_8;
10587 opti_type = OPTI_TYPE_ZERO_BYTE
10588 | OPTI_TYPE_USES_BITS_64;
10589 dgst_pos0 = 0;
10590 dgst_pos1 = 1;
10591 dgst_pos2 = 2;
10592 dgst_pos3 = 3;
10593 break;
10594
10595 case 13722: hash_type = HASH_TYPE_SHA512;
10596 salt_type = SALT_TYPE_EMBEDDED;
10597 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10598 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10599 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10600 dgst_size = DGST_SIZE_8_8;
10601 parse_func = veracrypt_parse_hash_500000;
10602 sort_by_digest = sort_by_digest_8_8;
10603 opti_type = OPTI_TYPE_ZERO_BYTE
10604 | OPTI_TYPE_USES_BITS_64;
10605 dgst_pos0 = 0;
10606 dgst_pos1 = 1;
10607 dgst_pos2 = 2;
10608 dgst_pos3 = 3;
10609 break;
10610
10611 case 13723: hash_type = HASH_TYPE_SHA512;
10612 salt_type = SALT_TYPE_EMBEDDED;
10613 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10614 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10615 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10616 dgst_size = DGST_SIZE_8_8;
10617 parse_func = veracrypt_parse_hash_500000;
10618 sort_by_digest = sort_by_digest_8_8;
10619 opti_type = OPTI_TYPE_ZERO_BYTE
10620 | OPTI_TYPE_USES_BITS_64;
10621 dgst_pos0 = 0;
10622 dgst_pos1 = 1;
10623 dgst_pos2 = 2;
10624 dgst_pos3 = 3;
10625 break;
10626
10627 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10628 salt_type = SALT_TYPE_EMBEDDED;
10629 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10630 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10631 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10632 dgst_size = DGST_SIZE_4_8;
10633 parse_func = veracrypt_parse_hash_500000;
10634 sort_by_digest = sort_by_digest_4_8;
10635 opti_type = OPTI_TYPE_ZERO_BYTE;
10636 dgst_pos0 = 0;
10637 dgst_pos1 = 1;
10638 dgst_pos2 = 2;
10639 dgst_pos3 = 3;
10640 break;
10641
10642 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10643 salt_type = SALT_TYPE_EMBEDDED;
10644 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10645 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10646 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10647 dgst_size = DGST_SIZE_4_8;
10648 parse_func = veracrypt_parse_hash_500000;
10649 sort_by_digest = sort_by_digest_4_8;
10650 opti_type = OPTI_TYPE_ZERO_BYTE;
10651 dgst_pos0 = 0;
10652 dgst_pos1 = 1;
10653 dgst_pos2 = 2;
10654 dgst_pos3 = 3;
10655 break;
10656
10657 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10658 salt_type = SALT_TYPE_EMBEDDED;
10659 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10660 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10661 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10662 dgst_size = DGST_SIZE_4_8;
10663 parse_func = veracrypt_parse_hash_500000;
10664 sort_by_digest = sort_by_digest_4_8;
10665 opti_type = OPTI_TYPE_ZERO_BYTE;
10666 dgst_pos0 = 0;
10667 dgst_pos1 = 1;
10668 dgst_pos2 = 2;
10669 dgst_pos3 = 3;
10670 break;
10671
10672 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10673 salt_type = SALT_TYPE_EMBEDDED;
10674 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10675 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10676 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10677 dgst_size = DGST_SIZE_4_5;
10678 parse_func = veracrypt_parse_hash_327661;
10679 sort_by_digest = sort_by_digest_4_5;
10680 opti_type = OPTI_TYPE_ZERO_BYTE;
10681 dgst_pos0 = 0;
10682 dgst_pos1 = 1;
10683 dgst_pos2 = 2;
10684 dgst_pos3 = 3;
10685 break;
10686
10687 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10688 salt_type = SALT_TYPE_EMBEDDED;
10689 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10690 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10691 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10692 dgst_size = DGST_SIZE_4_5;
10693 parse_func = veracrypt_parse_hash_327661;
10694 sort_by_digest = sort_by_digest_4_5;
10695 opti_type = OPTI_TYPE_ZERO_BYTE;
10696 dgst_pos0 = 0;
10697 dgst_pos1 = 1;
10698 dgst_pos2 = 2;
10699 dgst_pos3 = 3;
10700 break;
10701
10702 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10703 salt_type = SALT_TYPE_EMBEDDED;
10704 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10705 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10706 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10707 dgst_size = DGST_SIZE_4_5;
10708 parse_func = veracrypt_parse_hash_327661;
10709 sort_by_digest = sort_by_digest_4_5;
10710 opti_type = OPTI_TYPE_ZERO_BYTE;
10711 dgst_pos0 = 0;
10712 dgst_pos1 = 1;
10713 dgst_pos2 = 2;
10714 dgst_pos3 = 3;
10715 break;
10716
10717 case 13751: hash_type = HASH_TYPE_SHA256;
10718 salt_type = SALT_TYPE_EMBEDDED;
10719 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10720 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10721 kern_type = KERN_TYPE_VCSHA256_XTS512;
10722 dgst_size = DGST_SIZE_4_8;
10723 parse_func = veracrypt_parse_hash_500000;
10724 sort_by_digest = sort_by_digest_4_8;
10725 opti_type = OPTI_TYPE_ZERO_BYTE;
10726 dgst_pos0 = 0;
10727 dgst_pos1 = 1;
10728 dgst_pos2 = 2;
10729 dgst_pos3 = 3;
10730 break;
10731
10732 case 13752: hash_type = HASH_TYPE_SHA256;
10733 salt_type = SALT_TYPE_EMBEDDED;
10734 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10735 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10736 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10737 dgst_size = DGST_SIZE_4_8;
10738 parse_func = veracrypt_parse_hash_500000;
10739 sort_by_digest = sort_by_digest_4_8;
10740 opti_type = OPTI_TYPE_ZERO_BYTE;
10741 dgst_pos0 = 0;
10742 dgst_pos1 = 1;
10743 dgst_pos2 = 2;
10744 dgst_pos3 = 3;
10745 break;
10746
10747 case 13753: hash_type = HASH_TYPE_SHA256;
10748 salt_type = SALT_TYPE_EMBEDDED;
10749 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10750 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10751 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10752 dgst_size = DGST_SIZE_4_8;
10753 parse_func = veracrypt_parse_hash_500000;
10754 sort_by_digest = sort_by_digest_4_8;
10755 opti_type = OPTI_TYPE_ZERO_BYTE;
10756 dgst_pos0 = 0;
10757 dgst_pos1 = 1;
10758 dgst_pos2 = 2;
10759 dgst_pos3 = 3;
10760 break;
10761
10762 case 13761: hash_type = HASH_TYPE_SHA256;
10763 salt_type = SALT_TYPE_EMBEDDED;
10764 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10765 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10766 kern_type = KERN_TYPE_VCSHA256_XTS512;
10767 dgst_size = DGST_SIZE_4_8;
10768 parse_func = veracrypt_parse_hash_200000;
10769 sort_by_digest = sort_by_digest_4_8;
10770 opti_type = OPTI_TYPE_ZERO_BYTE;
10771 dgst_pos0 = 0;
10772 dgst_pos1 = 1;
10773 dgst_pos2 = 2;
10774 dgst_pos3 = 3;
10775 break;
10776
10777 case 13762: hash_type = HASH_TYPE_SHA256;
10778 salt_type = SALT_TYPE_EMBEDDED;
10779 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10780 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10781 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10782 dgst_size = DGST_SIZE_4_8;
10783 parse_func = veracrypt_parse_hash_200000;
10784 sort_by_digest = sort_by_digest_4_8;
10785 opti_type = OPTI_TYPE_ZERO_BYTE;
10786 dgst_pos0 = 0;
10787 dgst_pos1 = 1;
10788 dgst_pos2 = 2;
10789 dgst_pos3 = 3;
10790 break;
10791
10792 case 13763: hash_type = HASH_TYPE_SHA256;
10793 salt_type = SALT_TYPE_EMBEDDED;
10794 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10795 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10796 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10797 dgst_size = DGST_SIZE_4_8;
10798 parse_func = veracrypt_parse_hash_200000;
10799 sort_by_digest = sort_by_digest_4_8;
10800 opti_type = OPTI_TYPE_ZERO_BYTE;
10801 dgst_pos0 = 0;
10802 dgst_pos1 = 1;
10803 dgst_pos2 = 2;
10804 dgst_pos3 = 3;
10805 break;
10806
10807
10808 default: usage_mini_print (PROGNAME); return (-1);
10809 }
10810
10811 /**
10812 * parser
10813 */
10814
10815 data.parse_func = parse_func;
10816
10817 /**
10818 * misc stuff
10819 */
10820
10821 if (hex_salt)
10822 {
10823 if (salt_type == SALT_TYPE_INTERN)
10824 {
10825 opts_type |= OPTS_TYPE_ST_HEX;
10826 }
10827 else
10828 {
10829 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10830
10831 return (-1);
10832 }
10833 }
10834
10835 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10836 | (salt_type == SALT_TYPE_EXTERN)
10837 | (salt_type == SALT_TYPE_EMBEDDED)
10838 | (salt_type == SALT_TYPE_VIRTUAL));
10839
10840 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10841
10842 data.hash_type = hash_type;
10843 data.attack_mode = attack_mode;
10844 data.attack_kern = attack_kern;
10845 data.attack_exec = attack_exec;
10846 data.kern_type = kern_type;
10847 data.opts_type = opts_type;
10848 data.dgst_size = dgst_size;
10849 data.salt_type = salt_type;
10850 data.isSalted = isSalted;
10851 data.sort_by_digest = sort_by_digest;
10852 data.dgst_pos0 = dgst_pos0;
10853 data.dgst_pos1 = dgst_pos1;
10854 data.dgst_pos2 = dgst_pos2;
10855 data.dgst_pos3 = dgst_pos3;
10856
10857 esalt_size = 0;
10858
10859 switch (hash_mode)
10860 {
10861 case 2500: esalt_size = sizeof (wpa_t); break;
10862 case 5300: esalt_size = sizeof (ikepsk_t); break;
10863 case 5400: esalt_size = sizeof (ikepsk_t); break;
10864 case 5500: esalt_size = sizeof (netntlm_t); break;
10865 case 5600: esalt_size = sizeof (netntlm_t); break;
10866 case 6211: esalt_size = sizeof (tc_t); break;
10867 case 6212: esalt_size = sizeof (tc_t); break;
10868 case 6213: esalt_size = sizeof (tc_t); break;
10869 case 6221: esalt_size = sizeof (tc_t); break;
10870 case 6222: esalt_size = sizeof (tc_t); break;
10871 case 6223: esalt_size = sizeof (tc_t); break;
10872 case 6231: esalt_size = sizeof (tc_t); break;
10873 case 6232: esalt_size = sizeof (tc_t); break;
10874 case 6233: esalt_size = sizeof (tc_t); break;
10875 case 6241: esalt_size = sizeof (tc_t); break;
10876 case 6242: esalt_size = sizeof (tc_t); break;
10877 case 6243: esalt_size = sizeof (tc_t); break;
10878 case 6600: esalt_size = sizeof (agilekey_t); break;
10879 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10880 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10881 case 7300: esalt_size = sizeof (rakp_t); break;
10882 case 7500: esalt_size = sizeof (krb5pa_t); break;
10883 case 8200: esalt_size = sizeof (cloudkey_t); break;
10884 case 8800: esalt_size = sizeof (androidfde_t); break;
10885 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10886 case 9400: esalt_size = sizeof (office2007_t); break;
10887 case 9500: esalt_size = sizeof (office2010_t); break;
10888 case 9600: esalt_size = sizeof (office2013_t); break;
10889 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10890 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10891 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10892 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10893 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10894 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10895 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10896 case 10200: esalt_size = sizeof (cram_md5_t); break;
10897 case 10400: esalt_size = sizeof (pdf_t); break;
10898 case 10410: esalt_size = sizeof (pdf_t); break;
10899 case 10420: esalt_size = sizeof (pdf_t); break;
10900 case 10500: esalt_size = sizeof (pdf_t); break;
10901 case 10600: esalt_size = sizeof (pdf_t); break;
10902 case 10700: esalt_size = sizeof (pdf_t); break;
10903 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10904 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10905 case 11400: esalt_size = sizeof (sip_t); break;
10906 case 11600: esalt_size = sizeof (seven_zip_t); break;
10907 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10908 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10909 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10910 case 13000: esalt_size = sizeof (rar5_t); break;
10911 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10912 case 13400: esalt_size = sizeof (keepass_t); break;
10913 case 13500: esalt_size = sizeof (pstoken_t); break;
10914 case 13600: esalt_size = sizeof (zip2_t); break;
10915 case 13711: esalt_size = sizeof (tc_t); break;
10916 case 13712: esalt_size = sizeof (tc_t); break;
10917 case 13713: esalt_size = sizeof (tc_t); break;
10918 case 13721: esalt_size = sizeof (tc_t); break;
10919 case 13722: esalt_size = sizeof (tc_t); break;
10920 case 13723: esalt_size = sizeof (tc_t); break;
10921 case 13731: esalt_size = sizeof (tc_t); break;
10922 case 13732: esalt_size = sizeof (tc_t); break;
10923 case 13733: esalt_size = sizeof (tc_t); break;
10924 case 13741: esalt_size = sizeof (tc_t); break;
10925 case 13742: esalt_size = sizeof (tc_t); break;
10926 case 13743: esalt_size = sizeof (tc_t); break;
10927 case 13751: esalt_size = sizeof (tc_t); break;
10928 case 13752: esalt_size = sizeof (tc_t); break;
10929 case 13753: esalt_size = sizeof (tc_t); break;
10930 case 13761: esalt_size = sizeof (tc_t); break;
10931 case 13762: esalt_size = sizeof (tc_t); break;
10932 case 13763: esalt_size = sizeof (tc_t); break;
10933 }
10934
10935 data.esalt_size = esalt_size;
10936
10937 /**
10938 * choose dictionary parser
10939 */
10940
10941 if (hash_type == HASH_TYPE_LM)
10942 {
10943 get_next_word_func = get_next_word_lm;
10944 }
10945 else if (opts_type & OPTS_TYPE_PT_UPPER)
10946 {
10947 get_next_word_func = get_next_word_uc;
10948 }
10949 else
10950 {
10951 get_next_word_func = get_next_word_std;
10952 }
10953
10954 /**
10955 * dictstat
10956 */
10957
10958 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10959
10960 #ifdef _POSIX
10961 size_t dictstat_nmemb = 0;
10962 #endif
10963
10964 #ifdef _WIN
10965 uint dictstat_nmemb = 0;
10966 #endif
10967
10968 char dictstat[256] = { 0 };
10969
10970 FILE *dictstat_fp = NULL;
10971
10972 if (keyspace == 0)
10973 {
10974 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10975
10976 dictstat_fp = fopen (dictstat, "rb");
10977
10978 if (dictstat_fp)
10979 {
10980 #ifdef _POSIX
10981 struct stat tmpstat;
10982
10983 fstat (fileno (dictstat_fp), &tmpstat);
10984 #endif
10985
10986 #ifdef _WIN
10987 struct stat64 tmpstat;
10988
10989 _fstat64 (fileno (dictstat_fp), &tmpstat);
10990 #endif
10991
10992 if (tmpstat.st_mtime < COMPTIME)
10993 {
10994 /* with v0.15 the format changed so we have to ensure user is using a good version
10995 since there is no version-header in the dictstat file */
10996
10997 fclose (dictstat_fp);
10998
10999 unlink (dictstat);
11000 }
11001 else
11002 {
11003 while (!feof (dictstat_fp))
11004 {
11005 dictstat_t d;
11006
11007 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11008
11009 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11010
11011 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11012 {
11013 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11014
11015 return -1;
11016 }
11017 }
11018
11019 fclose (dictstat_fp);
11020 }
11021 }
11022 }
11023
11024 /**
11025 * potfile
11026 */
11027
11028 char potfile[256] = { 0 };
11029
11030 if (potfile_path == NULL)
11031 {
11032 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11033 }
11034 else
11035 {
11036 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11037 }
11038
11039 data.pot_fp = NULL;
11040
11041 FILE *out_fp = NULL;
11042 FILE *pot_fp = NULL;
11043
11044 if (show == 1 || left == 1)
11045 {
11046 pot_fp = fopen (potfile, "rb");
11047
11048 if (pot_fp == NULL)
11049 {
11050 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11051
11052 return (-1);
11053 }
11054
11055 if (outfile != NULL)
11056 {
11057 if ((out_fp = fopen (outfile, "ab")) == NULL)
11058 {
11059 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11060
11061 fclose (pot_fp);
11062
11063 return (-1);
11064 }
11065 }
11066 else
11067 {
11068 out_fp = stdout;
11069 }
11070 }
11071 else
11072 {
11073 if (potfile_disable == 0)
11074 {
11075 pot_fp = fopen (potfile, "ab");
11076
11077 if (pot_fp == NULL)
11078 {
11079 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11080
11081 return (-1);
11082 }
11083
11084 data.pot_fp = pot_fp;
11085 }
11086 }
11087
11088 pot_t *pot = NULL;
11089
11090 uint pot_cnt = 0;
11091 uint pot_avail = 0;
11092
11093 if (show == 1 || left == 1)
11094 {
11095 SUPPRESS_OUTPUT = 1;
11096
11097 pot_avail = count_lines (pot_fp);
11098
11099 rewind (pot_fp);
11100
11101 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11102
11103 uint pot_hashes_avail = 0;
11104
11105 uint line_num = 0;
11106
11107 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11108
11109 while (!feof (pot_fp))
11110 {
11111 line_num++;
11112
11113 int line_len = fgetl (pot_fp, line_buf);
11114
11115 if (line_len == 0) continue;
11116
11117 char *plain_buf = line_buf + line_len;
11118
11119 pot_t *pot_ptr = &pot[pot_cnt];
11120
11121 hash_t *hashes_buf = &pot_ptr->hash;
11122
11123 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11124 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11125
11126 if (pot_cnt == pot_hashes_avail)
11127 {
11128 uint pos = 0;
11129
11130 for (pos = 0; pos < INCR_POT; pos++)
11131 {
11132 if ((pot_cnt + pos) >= pot_avail) break;
11133
11134 pot_t *tmp_pot = &pot[pot_cnt + pos];
11135
11136 hash_t *tmp_hash = &tmp_pot->hash;
11137
11138 tmp_hash->digest = mymalloc (dgst_size);
11139
11140 if (isSalted)
11141 {
11142 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11143 }
11144
11145 if (esalt_size)
11146 {
11147 tmp_hash->esalt = mymalloc (esalt_size);
11148 }
11149
11150 pot_hashes_avail++;
11151 }
11152 }
11153
11154 int plain_len = 0;
11155
11156 int parser_status;
11157
11158 int iter = MAX_CUT_TRIES;
11159
11160 do
11161 {
11162 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11163 {
11164 if (line_buf[i] == ':')
11165 {
11166 line_len--;
11167
11168 break;
11169 }
11170 }
11171
11172 if (data.hash_mode != 2500)
11173 {
11174 parser_status = parse_func (line_buf, line_len, hashes_buf);
11175 }
11176 else
11177 {
11178 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11179
11180 if (line_len > max_salt_size)
11181 {
11182 parser_status = PARSER_GLOBAL_LENGTH;
11183 }
11184 else
11185 {
11186 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11187
11188 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11189
11190 hashes_buf->salt->salt_len = line_len;
11191
11192 parser_status = PARSER_OK;
11193 }
11194 }
11195
11196 // if NOT parsed without error, we add the ":" to the plain
11197
11198 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11199 {
11200 plain_len++;
11201 plain_buf--;
11202 }
11203
11204 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11205
11206 if (parser_status < PARSER_GLOBAL_ZERO)
11207 {
11208 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11209
11210 continue;
11211 }
11212
11213 if (plain_len >= 255) continue;
11214
11215 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11216
11217 pot_ptr->plain_len = plain_len;
11218
11219 pot_cnt++;
11220 }
11221
11222 myfree (line_buf);
11223
11224 fclose (pot_fp);
11225
11226 SUPPRESS_OUTPUT = 0;
11227
11228 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11229 }
11230
11231 /**
11232 * word len
11233 */
11234
11235 uint pw_min = PW_MIN;
11236 uint pw_max = PW_MAX;
11237
11238 switch (hash_mode)
11239 {
11240 case 125: if (pw_max > 32) pw_max = 32;
11241 break;
11242 case 400: if (pw_max > 40) pw_max = 40;
11243 break;
11244 case 500: if (pw_max > 16) pw_max = 16;
11245 break;
11246 case 1500: if (pw_max > 8) pw_max = 8;
11247 break;
11248 case 1600: if (pw_max > 16) pw_max = 16;
11249 break;
11250 case 1800: if (pw_max > 16) pw_max = 16;
11251 break;
11252 case 2100: if (pw_max > 16) pw_max = 16;
11253 break;
11254 case 2500: if (pw_min < 8) pw_min = 8;
11255 break;
11256 case 3000: if (pw_max > 7) pw_max = 7;
11257 break;
11258 case 5200: if (pw_max > 24) pw_max = 24;
11259 break;
11260 case 5800: if (pw_max > 16) pw_max = 16;
11261 break;
11262 case 6300: if (pw_max > 16) pw_max = 16;
11263 break;
11264 case 7400: if (pw_max > 16) pw_max = 16;
11265 break;
11266 case 7500: if (pw_max > 8) pw_max = 8;
11267 break;
11268 case 7900: if (pw_max > 48) pw_max = 48;
11269 break;
11270 case 8500: if (pw_max > 8) pw_max = 8;
11271 break;
11272 case 8600: if (pw_max > 16) pw_max = 16;
11273 break;
11274 case 9710: pw_min = 5;
11275 pw_max = 5;
11276 break;
11277 case 9810: pw_min = 5;
11278 pw_max = 5;
11279 break;
11280 case 10410: pw_min = 5;
11281 pw_max = 5;
11282 break;
11283 case 10300: if (pw_max < 3) pw_min = 3;
11284 if (pw_max > 40) pw_max = 40;
11285 break;
11286 case 10500: if (pw_max < 3) pw_min = 3;
11287 if (pw_max > 40) pw_max = 40;
11288 break;
11289 case 10700: if (pw_max > 16) pw_max = 16;
11290 break;
11291 case 11300: if (pw_max > 40) pw_max = 40;
11292 break;
11293 case 11600: if (pw_max > 32) pw_max = 32;
11294 break;
11295 case 12500: if (pw_max > 20) pw_max = 20;
11296 break;
11297 case 12800: if (pw_max > 24) pw_max = 24;
11298 break;
11299 }
11300
11301 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11302 {
11303 switch (attack_kern)
11304 {
11305 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11306 break;
11307 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11308 break;
11309 }
11310 }
11311
11312 /**
11313 * charsets : keep them together for more easy maintainnce
11314 */
11315
11316 cs_t mp_sys[6] = { { { 0 }, 0 } };
11317 cs_t mp_usr[4] = { { { 0 }, 0 } };
11318
11319 mp_setup_sys (mp_sys);
11320
11321 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11322 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11323 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11324 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11325
11326 /**
11327 * load hashes, part I: find input mode, count hashes
11328 */
11329
11330 uint hashlist_mode = 0;
11331 uint hashlist_format = HLFMT_HASHCAT;
11332
11333 uint hashes_avail = 0;
11334
11335 if (benchmark == 0)
11336 {
11337 struct stat f;
11338
11339 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11340
11341 if ((hash_mode == 2500) ||
11342 (hash_mode == 5200) ||
11343 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11344 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11345 (hash_mode == 9000))
11346 {
11347 hashlist_mode = HL_MODE_ARG;
11348
11349 char *hashfile = myargv[optind];
11350
11351 data.hashfile = hashfile;
11352
11353 logfile_top_var_string ("target", hashfile);
11354 }
11355
11356 if (hashlist_mode == HL_MODE_ARG)
11357 {
11358 if (hash_mode == 2500)
11359 {
11360 struct stat st;
11361
11362 if (stat (data.hashfile, &st) == -1)
11363 {
11364 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11365
11366 return (-1);
11367 }
11368
11369 hashes_avail = st.st_size / sizeof (hccap_t);
11370 }
11371 else
11372 {
11373 hashes_avail = 1;
11374 }
11375 }
11376 else if (hashlist_mode == HL_MODE_FILE)
11377 {
11378 char *hashfile = myargv[optind];
11379
11380 data.hashfile = hashfile;
11381
11382 logfile_top_var_string ("target", hashfile);
11383
11384 FILE *fp = NULL;
11385
11386 if ((fp = fopen (hashfile, "rb")) == NULL)
11387 {
11388 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11389
11390 return (-1);
11391 }
11392
11393 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11394
11395 hashes_avail = count_lines (fp);
11396
11397 rewind (fp);
11398
11399 if (hashes_avail == 0)
11400 {
11401 log_error ("ERROR: hashfile is empty or corrupt");
11402
11403 fclose (fp);
11404
11405 return (-1);
11406 }
11407
11408 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11409
11410 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11411 {
11412 log_error ("ERROR: remove not supported in native hashfile-format mode");
11413
11414 fclose (fp);
11415
11416 return (-1);
11417 }
11418
11419 fclose (fp);
11420 }
11421 }
11422 else
11423 {
11424 hashlist_mode = HL_MODE_ARG;
11425
11426 hashes_avail = 1;
11427 }
11428
11429 if (hash_mode == 3000) hashes_avail *= 2;
11430
11431 data.hashlist_mode = hashlist_mode;
11432 data.hashlist_format = hashlist_format;
11433
11434 logfile_top_uint (hashlist_mode);
11435 logfile_top_uint (hashlist_format);
11436
11437 /**
11438 * load hashes, part II: allocate required memory, set pointers
11439 */
11440
11441 hash_t *hashes_buf = NULL;
11442 void *digests_buf = NULL;
11443 salt_t *salts_buf = NULL;
11444 void *esalts_buf = NULL;
11445
11446 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11447
11448 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11449
11450 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11451 {
11452 u32 hash_pos;
11453
11454 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11455 {
11456 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11457
11458 hashes_buf[hash_pos].hash_info = hash_info;
11459
11460 if (username && (remove || show || left))
11461 {
11462 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11463 }
11464
11465 if (benchmark)
11466 {
11467 hash_info->orighash = (char *) mymalloc (256);
11468 }
11469 }
11470 }
11471
11472 if (isSalted)
11473 {
11474 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11475
11476 if (esalt_size)
11477 {
11478 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11479 }
11480 }
11481 else
11482 {
11483 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11484 }
11485
11486 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11487 {
11488 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11489
11490 if (isSalted)
11491 {
11492 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11493
11494 if (esalt_size)
11495 {
11496 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11497 }
11498 }
11499 else
11500 {
11501 hashes_buf[hash_pos].salt = &salts_buf[0];
11502 }
11503 }
11504
11505 /**
11506 * load hashes, part III: parse hashes or generate them if benchmark
11507 */
11508
11509 uint hashes_cnt = 0;
11510
11511 if (benchmark == 0)
11512 {
11513 if (keyspace == 1)
11514 {
11515 // useless to read hash file for keyspace, cheat a little bit w/ optind
11516 }
11517 else if (hashes_avail == 0)
11518 {
11519 }
11520 else if (hashlist_mode == HL_MODE_ARG)
11521 {
11522 char *input_buf = myargv[optind];
11523
11524 uint input_len = strlen (input_buf);
11525
11526 logfile_top_var_string ("target", input_buf);
11527
11528 char *hash_buf = NULL;
11529 int hash_len = 0;
11530
11531 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11532
11533 bool hash_fmt_error = 0;
11534
11535 if (hash_len < 1) hash_fmt_error = 1;
11536 if (hash_buf == NULL) hash_fmt_error = 1;
11537
11538 if (hash_fmt_error)
11539 {
11540 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11541 }
11542 else
11543 {
11544 if (opts_type & OPTS_TYPE_HASH_COPY)
11545 {
11546 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11547
11548 hash_info_tmp->orighash = mystrdup (hash_buf);
11549 }
11550
11551 if (isSalted)
11552 {
11553 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11554 }
11555
11556 int parser_status = PARSER_OK;
11557
11558 if (hash_mode == 2500)
11559 {
11560 if (hash_len == 0)
11561 {
11562 log_error ("ERROR: hccap file not specified");
11563
11564 return (-1);
11565 }
11566
11567 hashlist_mode = HL_MODE_FILE;
11568
11569 data.hashlist_mode = hashlist_mode;
11570
11571 FILE *fp = fopen (hash_buf, "rb");
11572
11573 if (fp == NULL)
11574 {
11575 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11576
11577 return (-1);
11578 }
11579
11580 if (hashes_avail < 1)
11581 {
11582 log_error ("ERROR: hccap file is empty or corrupt");
11583
11584 fclose (fp);
11585
11586 return (-1);
11587 }
11588
11589 uint hccap_size = sizeof (hccap_t);
11590
11591 char *in = (char *) mymalloc (hccap_size);
11592
11593 while (!feof (fp))
11594 {
11595 int n = fread (in, hccap_size, 1, fp);
11596
11597 if (n != 1)
11598 {
11599 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11600
11601 break;
11602 }
11603
11604 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11605
11606 if (parser_status != PARSER_OK)
11607 {
11608 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11609
11610 continue;
11611 }
11612
11613 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11614
11615 if ((show == 1) || (left == 1))
11616 {
11617 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11618
11619 char *salt_ptr = (char *) tmp_salt->salt_buf;
11620
11621 int cur_pos = tmp_salt->salt_len;
11622 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11623
11624 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11625
11626 // do the appending task
11627
11628 snprintf (salt_ptr + cur_pos,
11629 rem_len,
11630 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11631 wpa->orig_mac1[0],
11632 wpa->orig_mac1[1],
11633 wpa->orig_mac1[2],
11634 wpa->orig_mac1[3],
11635 wpa->orig_mac1[4],
11636 wpa->orig_mac1[5],
11637 wpa->orig_mac2[0],
11638 wpa->orig_mac2[1],
11639 wpa->orig_mac2[2],
11640 wpa->orig_mac2[3],
11641 wpa->orig_mac2[4],
11642 wpa->orig_mac2[5]);
11643
11644 // memset () the remaining part of the salt
11645
11646 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11647 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11648
11649 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11650
11651 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11652 }
11653
11654 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);
11655 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);
11656
11657 hashes_cnt++;
11658 }
11659
11660 fclose (fp);
11661
11662 myfree (in);
11663 }
11664 else if (hash_mode == 3000)
11665 {
11666 if (hash_len == 32)
11667 {
11668 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11669
11670 hash_t *lm_hash_left = NULL;
11671
11672 if (parser_status == PARSER_OK)
11673 {
11674 lm_hash_left = &hashes_buf[hashes_cnt];
11675
11676 hashes_cnt++;
11677 }
11678 else
11679 {
11680 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11681 }
11682
11683 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11684
11685 hash_t *lm_hash_right = NULL;
11686
11687 if (parser_status == PARSER_OK)
11688 {
11689 lm_hash_right = &hashes_buf[hashes_cnt];
11690
11691 hashes_cnt++;
11692 }
11693 else
11694 {
11695 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11696 }
11697
11698 // show / left
11699
11700 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11701 {
11702 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);
11703 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);
11704 }
11705 }
11706 else
11707 {
11708 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11709
11710 if (parser_status == PARSER_OK)
11711 {
11712 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11713 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11714 }
11715
11716 if (parser_status == PARSER_OK)
11717 {
11718 hashes_cnt++;
11719 }
11720 else
11721 {
11722 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11723 }
11724 }
11725 }
11726 else
11727 {
11728 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11729
11730 if (parser_status == PARSER_OK)
11731 {
11732 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11733 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11734 }
11735
11736 if (parser_status == PARSER_OK)
11737 {
11738 hashes_cnt++;
11739 }
11740 else
11741 {
11742 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11743 }
11744 }
11745 }
11746 }
11747 else if (hashlist_mode == HL_MODE_FILE)
11748 {
11749 char *hashfile = data.hashfile;
11750
11751 FILE *fp;
11752
11753 if ((fp = fopen (hashfile, "rb")) == NULL)
11754 {
11755 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11756
11757 return (-1);
11758 }
11759
11760 uint line_num = 0;
11761
11762 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11763
11764 while (!feof (fp))
11765 {
11766 line_num++;
11767
11768 int line_len = fgetl (fp, line_buf);
11769
11770 if (line_len == 0) continue;
11771
11772 char *hash_buf = NULL;
11773 int hash_len = 0;
11774
11775 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11776
11777 bool hash_fmt_error = 0;
11778
11779 if (hash_len < 1) hash_fmt_error = 1;
11780 if (hash_buf == NULL) hash_fmt_error = 1;
11781
11782 if (hash_fmt_error)
11783 {
11784 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11785
11786 continue;
11787 }
11788
11789 if (username)
11790 {
11791 char *user_buf = NULL;
11792 int user_len = 0;
11793
11794 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11795
11796 if (remove || show)
11797 {
11798 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11799
11800 *user = (user_t *) mymalloc (sizeof (user_t));
11801
11802 user_t *user_ptr = *user;
11803
11804 if (user_buf != NULL)
11805 {
11806 user_ptr->user_name = mystrdup (user_buf);
11807 }
11808 else
11809 {
11810 user_ptr->user_name = mystrdup ("");
11811 }
11812
11813 user_ptr->user_len = user_len;
11814 }
11815 }
11816
11817 if (opts_type & OPTS_TYPE_HASH_COPY)
11818 {
11819 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11820
11821 hash_info_tmp->orighash = mystrdup (hash_buf);
11822 }
11823
11824 if (isSalted)
11825 {
11826 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11827 }
11828
11829 if (hash_mode == 3000)
11830 {
11831 if (hash_len == 32)
11832 {
11833 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11834
11835 if (parser_status < PARSER_GLOBAL_ZERO)
11836 {
11837 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11838
11839 continue;
11840 }
11841
11842 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11843
11844 hashes_cnt++;
11845
11846 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11847
11848 if (parser_status < PARSER_GLOBAL_ZERO)
11849 {
11850 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11851
11852 continue;
11853 }
11854
11855 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11856
11857 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);
11858
11859 hashes_cnt++;
11860
11861 // show / left
11862
11863 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);
11864 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);
11865 }
11866 else
11867 {
11868 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11869
11870 if (parser_status < PARSER_GLOBAL_ZERO)
11871 {
11872 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11873
11874 continue;
11875 }
11876
11877 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);
11878
11879 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11880 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11881
11882 hashes_cnt++;
11883 }
11884 }
11885 else
11886 {
11887 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11888
11889 if (parser_status < PARSER_GLOBAL_ZERO)
11890 {
11891 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11892
11893 continue;
11894 }
11895
11896 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);
11897
11898 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11899 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11900
11901 hashes_cnt++;
11902 }
11903 }
11904
11905 myfree (line_buf);
11906
11907 fclose (fp);
11908
11909 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11910
11911 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11912 }
11913 }
11914 else
11915 {
11916 if (isSalted)
11917 {
11918 hashes_buf[0].salt->salt_len = 8;
11919
11920 // special salt handling
11921
11922 switch (hash_mode)
11923 {
11924 case 1500: hashes_buf[0].salt->salt_len = 2;
11925 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11926 break;
11927 case 1731: hashes_buf[0].salt->salt_len = 4;
11928 break;
11929 case 2410: hashes_buf[0].salt->salt_len = 4;
11930 break;
11931 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11932 break;
11933 case 3100: hashes_buf[0].salt->salt_len = 1;
11934 break;
11935 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11936 break;
11937 case 5800: hashes_buf[0].salt->salt_len = 16;
11938 break;
11939 case 6800: hashes_buf[0].salt->salt_len = 32;
11940 break;
11941 case 8400: hashes_buf[0].salt->salt_len = 40;
11942 break;
11943 case 8800: hashes_buf[0].salt->salt_len = 16;
11944 break;
11945 case 8900: hashes_buf[0].salt->salt_len = 16;
11946 hashes_buf[0].salt->scrypt_N = 1024;
11947 hashes_buf[0].salt->scrypt_r = 1;
11948 hashes_buf[0].salt->scrypt_p = 1;
11949 break;
11950 case 9100: hashes_buf[0].salt->salt_len = 16;
11951 break;
11952 case 9300: hashes_buf[0].salt->salt_len = 14;
11953 hashes_buf[0].salt->scrypt_N = 16384;
11954 hashes_buf[0].salt->scrypt_r = 1;
11955 hashes_buf[0].salt->scrypt_p = 1;
11956 break;
11957 case 9400: hashes_buf[0].salt->salt_len = 16;
11958 break;
11959 case 9500: hashes_buf[0].salt->salt_len = 16;
11960 break;
11961 case 9600: hashes_buf[0].salt->salt_len = 16;
11962 break;
11963 case 9700: hashes_buf[0].salt->salt_len = 16;
11964 break;
11965 case 9710: hashes_buf[0].salt->salt_len = 16;
11966 break;
11967 case 9720: hashes_buf[0].salt->salt_len = 16;
11968 break;
11969 case 9800: hashes_buf[0].salt->salt_len = 16;
11970 break;
11971 case 9810: hashes_buf[0].salt->salt_len = 16;
11972 break;
11973 case 9820: hashes_buf[0].salt->salt_len = 16;
11974 break;
11975 case 10300: hashes_buf[0].salt->salt_len = 12;
11976 break;
11977 case 11500: hashes_buf[0].salt->salt_len = 4;
11978 break;
11979 case 11600: hashes_buf[0].salt->salt_len = 4;
11980 break;
11981 case 12400: hashes_buf[0].salt->salt_len = 4;
11982 break;
11983 case 12500: hashes_buf[0].salt->salt_len = 8;
11984 break;
11985 case 12600: hashes_buf[0].salt->salt_len = 64;
11986 break;
11987 }
11988
11989 // special esalt handling
11990
11991 switch (hash_mode)
11992 {
11993 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11994 break;
11995 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11996 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11997 break;
11998 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11999 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12000 break;
12001 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12002 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12003 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12004 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12005 break;
12006 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12007 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12008 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12009 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12010 break;
12011 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12012 break;
12013 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12014 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12015 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12016 break;
12017 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12018 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12019 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12020 break;
12021 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12022 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12023 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12024 break;
12025 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12026 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12027 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12028 break;
12029 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12030 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12031 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12032 break;
12033 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12034 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12035 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12036 break;
12037 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12038 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12039 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12040 break;
12041 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12042 break;
12043 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12044 break;
12045 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12046 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12047 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12048 break;
12049 }
12050 }
12051
12052 // set hashfile
12053
12054 switch (hash_mode)
12055 {
12056 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12057 break;
12058 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12059 break;
12060 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12061 break;
12062 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12063 break;
12064 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12065 break;
12066 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12067 break;
12068 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12069 break;
12070 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12071 break;
12072 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12073 break;
12074 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12075 break;
12076 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12077 break;
12078 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12079 break;
12080 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12081 break;
12082 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12083 break;
12084 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12085 break;
12086 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12087 break;
12088 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12089 break;
12090 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12091 break;
12092 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12093 break;
12094 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12095 break;
12096 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12097 break;
12098 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12099 break;
12100 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12101 break;
12102 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12103 break;
12104 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12105 break;
12106 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12107 break;
12108 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12109 break;
12110 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12111 break;
12112 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12113 break;
12114 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12115 break;
12116 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12117 break;
12118 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12119 break;
12120 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12121 break;
12122 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12123 break;
12124 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12125 break;
12126 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12127 break;
12128 }
12129
12130 // set default iterations
12131
12132 switch (hash_mode)
12133 {
12134 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12135 break;
12136 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12137 break;
12138 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12139 break;
12140 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12141 break;
12142 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12143 break;
12144 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12145 break;
12146 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12147 break;
12148 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12149 break;
12150 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12151 break;
12152 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12153 break;
12154 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12155 break;
12156 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12157 break;
12158 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12159 break;
12160 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12161 break;
12162 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12163 break;
12164 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12165 break;
12166 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12167 break;
12168 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12169 break;
12170 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12171 break;
12172 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12173 break;
12174 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12175 break;
12176 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12177 break;
12178 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12179 break;
12180 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12181 break;
12182 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12183 break;
12184 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12185 break;
12186 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12187 break;
12188 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12189 break;
12190 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12191 break;
12192 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12193 break;
12194 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12195 break;
12196 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12197 break;
12198 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12199 break;
12200 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12201 break;
12202 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12203 break;
12204 case 8900: hashes_buf[0].salt->salt_iter = 1;
12205 break;
12206 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12207 break;
12208 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12209 break;
12210 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12211 break;
12212 case 9300: hashes_buf[0].salt->salt_iter = 1;
12213 break;
12214 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12215 break;
12216 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12217 break;
12218 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12219 break;
12220 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12221 break;
12222 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12223 break;
12224 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12225 break;
12226 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12227 break;
12228 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12229 break;
12230 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12231 break;
12232 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12233 break;
12234 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12235 break;
12236 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12237 break;
12238 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12239 break;
12240 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12241 break;
12242 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12243 break;
12244 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12245 break;
12246 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12247 break;
12248 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12249 break;
12250 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12251 break;
12252 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12253 break;
12254 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12255 break;
12256 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12257 break;
12258 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12259 break;
12260 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12261 break;
12262 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12263 break;
12264 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12265 break;
12266 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12267 break;
12268 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12269 break;
12270 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12271 break;
12272 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12273 break;
12274 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12275 break;
12276 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12277 break;
12278 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12279 break;
12280 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12281 break;
12282 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12283 break;
12284 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12285 break;
12286 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12287 break;
12288 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12289 break;
12290 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12291 break;
12292 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12293 break;
12294 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12295 break;
12296 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12297 break;
12298 }
12299
12300 hashes_cnt = 1;
12301 }
12302
12303 if (show == 1 || left == 1)
12304 {
12305 for (uint i = 0; i < pot_cnt; i++)
12306 {
12307 pot_t *pot_ptr = &pot[i];
12308
12309 hash_t *hashes_buf = &pot_ptr->hash;
12310
12311 local_free (hashes_buf->digest);
12312
12313 if (isSalted)
12314 {
12315 local_free (hashes_buf->salt);
12316 }
12317 }
12318
12319 local_free (pot);
12320
12321 if (data.quiet == 0) log_info_nn ("");
12322
12323 return (0);
12324 }
12325
12326 if (keyspace == 0)
12327 {
12328 if (hashes_cnt == 0)
12329 {
12330 log_error ("ERROR: No hashes loaded");
12331
12332 return (-1);
12333 }
12334 }
12335
12336 /**
12337 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12338 */
12339
12340 if (data.outfile != NULL)
12341 {
12342 if (data.hashfile != NULL)
12343 {
12344 #ifdef _POSIX
12345 struct stat tmpstat_outfile;
12346 struct stat tmpstat_hashfile;
12347 #endif
12348
12349 #ifdef _WIN
12350 struct stat64 tmpstat_outfile;
12351 struct stat64 tmpstat_hashfile;
12352 #endif
12353
12354 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12355
12356 if (tmp_outfile_fp)
12357 {
12358 #ifdef _POSIX
12359 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12360 #endif
12361
12362 #ifdef _WIN
12363 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12364 #endif
12365
12366 fclose (tmp_outfile_fp);
12367 }
12368
12369 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12370
12371 if (tmp_hashfile_fp)
12372 {
12373 #ifdef _POSIX
12374 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12375 #endif
12376
12377 #ifdef _WIN
12378 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12379 #endif
12380
12381 fclose (tmp_hashfile_fp);
12382 }
12383
12384 if (tmp_outfile_fp && tmp_outfile_fp)
12385 {
12386 tmpstat_outfile.st_mode = 0;
12387 tmpstat_outfile.st_nlink = 0;
12388 tmpstat_outfile.st_uid = 0;
12389 tmpstat_outfile.st_gid = 0;
12390 tmpstat_outfile.st_rdev = 0;
12391 tmpstat_outfile.st_atime = 0;
12392
12393 tmpstat_hashfile.st_mode = 0;
12394 tmpstat_hashfile.st_nlink = 0;
12395 tmpstat_hashfile.st_uid = 0;
12396 tmpstat_hashfile.st_gid = 0;
12397 tmpstat_hashfile.st_rdev = 0;
12398 tmpstat_hashfile.st_atime = 0;
12399
12400 #ifdef _POSIX
12401 tmpstat_outfile.st_blksize = 0;
12402 tmpstat_outfile.st_blocks = 0;
12403
12404 tmpstat_hashfile.st_blksize = 0;
12405 tmpstat_hashfile.st_blocks = 0;
12406 #endif
12407
12408 #ifdef _POSIX
12409 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12410 {
12411 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12412
12413 return (-1);
12414 }
12415 #endif
12416
12417 #ifdef _WIN
12418 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12419 {
12420 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12421
12422 return (-1);
12423 }
12424 #endif
12425 }
12426 }
12427 }
12428
12429 /**
12430 * Remove duplicates
12431 */
12432
12433 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12434
12435 if (isSalted)
12436 {
12437 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12438 }
12439 else
12440 {
12441 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12442 }
12443
12444 uint hashes_cnt_orig = hashes_cnt;
12445
12446 hashes_cnt = 1;
12447
12448 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12449 {
12450 if (isSalted)
12451 {
12452 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12453 {
12454 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12455 }
12456 }
12457 else
12458 {
12459 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12460 }
12461
12462 if (hashes_pos > hashes_cnt)
12463 {
12464 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12465 }
12466
12467 hashes_cnt++;
12468 }
12469
12470 /**
12471 * Potfile removes
12472 */
12473
12474 uint potfile_remove_cracks = 0;
12475
12476 if (potfile_disable == 0)
12477 {
12478 hash_t hash_buf;
12479
12480 hash_buf.digest = mymalloc (dgst_size);
12481 hash_buf.salt = NULL;
12482 hash_buf.esalt = NULL;
12483 hash_buf.hash_info = NULL;
12484 hash_buf.cracked = 0;
12485
12486 if (isSalted)
12487 {
12488 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12489 }
12490
12491 if (esalt_size)
12492 {
12493 hash_buf.esalt = mymalloc (esalt_size);
12494 }
12495
12496 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12497
12498 // no solution for these special hash types (for instane because they use hashfile in output etc)
12499 if ((hash_mode != 5200) &&
12500 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12501 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12502 (hash_mode != 9000))
12503 {
12504 FILE *fp = fopen (potfile, "rb");
12505
12506 if (fp != NULL)
12507 {
12508 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12509
12510 // to be safe work with a copy (because of line_len loop, i etc)
12511 // moved up here because it's easier to handle continue case
12512 // it's just 64kb
12513
12514 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12515
12516 while (!feof (fp))
12517 {
12518 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12519
12520 if (ptr == NULL) break;
12521
12522 int line_len = strlen (line_buf);
12523
12524 if (line_len == 0) continue;
12525
12526 int iter = MAX_CUT_TRIES;
12527
12528 for (int i = line_len - 1; i && iter; i--, line_len--)
12529 {
12530 if (line_buf[i] != ':') continue;
12531
12532 if (isSalted)
12533 {
12534 memset (hash_buf.salt, 0, sizeof (salt_t));
12535 }
12536
12537 hash_t *found = NULL;
12538
12539 if (hash_mode == 6800)
12540 {
12541 if (i < 64) // 64 = 16 * uint in salt_buf[]
12542 {
12543 // manipulate salt_buf
12544 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12545
12546 hash_buf.salt->salt_len = i;
12547
12548 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12549 }
12550 }
12551 else if (hash_mode == 2500)
12552 {
12553 if (i < 64) // 64 = 16 * uint in salt_buf[]
12554 {
12555 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12556 // manipulate salt_buf
12557
12558 memcpy (line_buf_cpy, line_buf, i);
12559
12560 char *mac2_pos = strrchr (line_buf_cpy, ':');
12561
12562 if (mac2_pos == NULL) continue;
12563
12564 mac2_pos[0] = 0;
12565 mac2_pos++;
12566
12567 if (strlen (mac2_pos) != 12) continue;
12568
12569 char *mac1_pos = strrchr (line_buf_cpy, ':');
12570
12571 if (mac1_pos == NULL) continue;
12572
12573 mac1_pos[0] = 0;
12574 mac1_pos++;
12575
12576 if (strlen (mac1_pos) != 12) continue;
12577
12578 uint essid_length = mac1_pos - line_buf_cpy - 1;
12579
12580 // here we need the ESSID
12581 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12582
12583 hash_buf.salt->salt_len = essid_length;
12584
12585 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12586
12587 if (found)
12588 {
12589 wpa_t *wpa = (wpa_t *) found->esalt;
12590
12591 // compare hex string(s) vs binary MAC address(es)
12592
12593 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12594 {
12595 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12596 {
12597 found = NULL;
12598
12599 break;
12600 }
12601 }
12602
12603 // early skip ;)
12604 if (!found) continue;
12605
12606 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12607 {
12608 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12609 {
12610 found = NULL;
12611
12612 break;
12613 }
12614 }
12615 }
12616 }
12617 }
12618 else
12619 {
12620 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12621
12622 if (parser_status == PARSER_OK)
12623 {
12624 if (isSalted)
12625 {
12626 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12627 }
12628 else
12629 {
12630 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12631 }
12632 }
12633 }
12634
12635 if (found == NULL) continue;
12636
12637 if (!found->cracked) potfile_remove_cracks++;
12638
12639 found->cracked = 1;
12640
12641 if (found) break;
12642
12643 iter--;
12644 }
12645 }
12646
12647 myfree (line_buf_cpy);
12648
12649 myfree (line_buf);
12650
12651 fclose (fp);
12652 }
12653 }
12654
12655 if (esalt_size)
12656 {
12657 local_free (hash_buf.esalt);
12658 }
12659
12660 if (isSalted)
12661 {
12662 local_free (hash_buf.salt);
12663 }
12664
12665 local_free (hash_buf.digest);
12666 }
12667
12668 /**
12669 * Now generate all the buffers required for later
12670 */
12671
12672 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12673
12674 salt_t *salts_buf_new = NULL;
12675 void *esalts_buf_new = NULL;
12676
12677 if (isSalted)
12678 {
12679 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12680
12681 if (esalt_size)
12682 {
12683 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12684 }
12685 }
12686 else
12687 {
12688 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12689 }
12690
12691 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12692
12693 uint digests_cnt = hashes_cnt;
12694 uint digests_done = 0;
12695
12696 size_t size_digests = digests_cnt * dgst_size;
12697 size_t size_shown = digests_cnt * sizeof (uint);
12698
12699 uint *digests_shown = (uint *) mymalloc (size_shown);
12700 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12701
12702 uint salts_cnt = 0;
12703 uint salts_done = 0;
12704
12705 hashinfo_t **hash_info = NULL;
12706
12707 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12708 {
12709 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12710
12711 if (username && (remove || show))
12712 {
12713 uint user_pos;
12714
12715 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12716 {
12717 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12718
12719 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12720 }
12721 }
12722 }
12723
12724 uint *salts_shown = (uint *) mymalloc (size_shown);
12725
12726 salt_t *salt_buf;
12727
12728 {
12729 // copied from inner loop
12730
12731 salt_buf = &salts_buf_new[salts_cnt];
12732
12733 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12734
12735 if (esalt_size)
12736 {
12737 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12738 }
12739
12740 salt_buf->digests_cnt = 0;
12741 salt_buf->digests_done = 0;
12742 salt_buf->digests_offset = 0;
12743
12744 salts_cnt++;
12745 }
12746
12747 if (hashes_buf[0].cracked == 1)
12748 {
12749 digests_shown[0] = 1;
12750
12751 digests_done++;
12752
12753 salt_buf->digests_done++;
12754 }
12755
12756 salt_buf->digests_cnt++;
12757
12758 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12759
12760 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12761 {
12762 hash_info[0] = hashes_buf[0].hash_info;
12763 }
12764
12765 // copy from inner loop
12766
12767 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12768 {
12769 if (isSalted)
12770 {
12771 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12772 {
12773 salt_buf = &salts_buf_new[salts_cnt];
12774
12775 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12776
12777 if (esalt_size)
12778 {
12779 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12780 }
12781
12782 salt_buf->digests_cnt = 0;
12783 salt_buf->digests_done = 0;
12784 salt_buf->digests_offset = hashes_pos;
12785
12786 salts_cnt++;
12787 }
12788 }
12789
12790 if (hashes_buf[hashes_pos].cracked == 1)
12791 {
12792 digests_shown[hashes_pos] = 1;
12793
12794 digests_done++;
12795
12796 salt_buf->digests_done++;
12797 }
12798
12799 salt_buf->digests_cnt++;
12800
12801 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12802
12803 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12804 {
12805 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12806 }
12807 }
12808
12809 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12810 {
12811 salt_t *salt_buf = &salts_buf_new[salt_pos];
12812
12813 if (salt_buf->digests_done == salt_buf->digests_cnt)
12814 {
12815 salts_shown[salt_pos] = 1;
12816
12817 salts_done++;
12818 }
12819
12820 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12821 }
12822
12823 local_free (digests_buf);
12824 local_free (salts_buf);
12825 local_free (esalts_buf);
12826
12827 digests_buf = digests_buf_new;
12828 salts_buf = salts_buf_new;
12829 esalts_buf = esalts_buf_new;
12830
12831 local_free (hashes_buf);
12832
12833 /**
12834 * special modification not set from parser
12835 */
12836
12837 switch (hash_mode)
12838 {
12839 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12840 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12841 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12842 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12843 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12844 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12845 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12846 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12847 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12848 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12849 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12850 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12851 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12852 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12853 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12854 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12855 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12856 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12857 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12858 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12859 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12860 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12861 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12862 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12863 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12864 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12865 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12866 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12867 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12868 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12869 }
12870
12871 if (truecrypt_keyfiles)
12872 {
12873 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12874
12875 char *keyfiles = strdup (truecrypt_keyfiles);
12876
12877 char *keyfile = strtok (keyfiles, ",");
12878
12879 do
12880 {
12881 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12882
12883 } while ((keyfile = strtok (NULL, ",")) != NULL);
12884
12885 free (keyfiles);
12886 }
12887
12888 if (veracrypt_keyfiles)
12889 {
12890 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12891
12892 char *keyfiles = strdup (veracrypt_keyfiles);
12893
12894 char *keyfile = strtok (keyfiles, ",");
12895
12896 do
12897 {
12898 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12899
12900 } while ((keyfile = strtok (NULL, ",")) != NULL);
12901
12902 free (keyfiles);
12903 }
12904
12905 data.digests_cnt = digests_cnt;
12906 data.digests_done = digests_done;
12907 data.digests_buf = digests_buf;
12908 data.digests_shown = digests_shown;
12909 data.digests_shown_tmp = digests_shown_tmp;
12910
12911 data.salts_cnt = salts_cnt;
12912 data.salts_done = salts_done;
12913 data.salts_buf = salts_buf;
12914 data.salts_shown = salts_shown;
12915
12916 data.esalts_buf = esalts_buf;
12917 data.hash_info = hash_info;
12918
12919 /**
12920 * Automatic Optimizers
12921 */
12922
12923 if (salts_cnt == 1)
12924 opti_type |= OPTI_TYPE_SINGLE_SALT;
12925
12926 if (digests_cnt == 1)
12927 opti_type |= OPTI_TYPE_SINGLE_HASH;
12928
12929 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12930 opti_type |= OPTI_TYPE_NOT_ITERATED;
12931
12932 if (attack_mode == ATTACK_MODE_BF)
12933 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12934
12935 data.opti_type = opti_type;
12936
12937 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12938 {
12939 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12940 {
12941 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12942 {
12943 if (opts_type & OPTS_TYPE_ST_ADD80)
12944 {
12945 opts_type &= ~OPTS_TYPE_ST_ADD80;
12946 opts_type |= OPTS_TYPE_PT_ADD80;
12947 }
12948
12949 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12950 {
12951 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12952 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12953 }
12954
12955 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12956 {
12957 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12958 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12959 }
12960 }
12961 }
12962 }
12963
12964 /**
12965 * Some algorithm, like descrypt, can benefit from JIT compilation
12966 */
12967
12968 int force_jit_compilation = -1;
12969
12970 if (hash_mode == 8900)
12971 {
12972 force_jit_compilation = 8900;
12973 }
12974 else if (hash_mode == 9300)
12975 {
12976 force_jit_compilation = 8900;
12977 }
12978 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12979 {
12980 force_jit_compilation = 1500;
12981 }
12982
12983 /**
12984 * generate bitmap tables
12985 */
12986
12987 const uint bitmap_shift1 = 5;
12988 const uint bitmap_shift2 = 13;
12989
12990 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12991
12992 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12993 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12994 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12995 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12996 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12997 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12998 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12999 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13000
13001 uint bitmap_bits;
13002 uint bitmap_nums;
13003 uint bitmap_mask;
13004 uint bitmap_size;
13005
13006 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13007 {
13008 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13009
13010 bitmap_nums = 1 << bitmap_bits;
13011
13012 bitmap_mask = bitmap_nums - 1;
13013
13014 bitmap_size = bitmap_nums * sizeof (uint);
13015
13016 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13017
13018 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;
13019 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;
13020
13021 break;
13022 }
13023
13024 bitmap_nums = 1 << bitmap_bits;
13025
13026 bitmap_mask = bitmap_nums - 1;
13027
13028 bitmap_size = bitmap_nums * sizeof (uint);
13029
13030 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);
13031 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);
13032
13033 /**
13034 * prepare quick rule
13035 */
13036
13037 data.rule_buf_l = rule_buf_l;
13038 data.rule_buf_r = rule_buf_r;
13039
13040 int rule_len_l = (int) strlen (rule_buf_l);
13041 int rule_len_r = (int) strlen (rule_buf_r);
13042
13043 data.rule_len_l = rule_len_l;
13044 data.rule_len_r = rule_len_r;
13045
13046 /**
13047 * load rules
13048 */
13049
13050 uint *all_kernel_rules_cnt = NULL;
13051
13052 kernel_rule_t **all_kernel_rules_buf = NULL;
13053
13054 if (rp_files_cnt)
13055 {
13056 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13057
13058 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13059 }
13060
13061 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13062
13063 int rule_len = 0;
13064
13065 for (uint i = 0; i < rp_files_cnt; i++)
13066 {
13067 uint kernel_rules_avail = 0;
13068
13069 uint kernel_rules_cnt = 0;
13070
13071 kernel_rule_t *kernel_rules_buf = NULL;
13072
13073 char *rp_file = rp_files[i];
13074
13075 char in[BLOCK_SIZE] = { 0 };
13076 char out[BLOCK_SIZE] = { 0 };
13077
13078 FILE *fp = NULL;
13079
13080 uint rule_line = 0;
13081
13082 if ((fp = fopen (rp_file, "rb")) == NULL)
13083 {
13084 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13085
13086 return (-1);
13087 }
13088
13089 while (!feof (fp))
13090 {
13091 memset (rule_buf, 0, HCBUFSIZ);
13092
13093 rule_len = fgetl (fp, rule_buf);
13094
13095 rule_line++;
13096
13097 if (rule_len == 0) continue;
13098
13099 if (rule_buf[0] == '#') continue;
13100
13101 if (kernel_rules_avail == kernel_rules_cnt)
13102 {
13103 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13104
13105 kernel_rules_avail += INCR_RULES;
13106 }
13107
13108 memset (in, 0, BLOCK_SIZE);
13109 memset (out, 0, BLOCK_SIZE);
13110
13111 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13112
13113 if (result == -1)
13114 {
13115 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13116
13117 continue;
13118 }
13119
13120 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13121 {
13122 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13123
13124 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13125
13126 continue;
13127 }
13128
13129 /* its so slow
13130 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13131 {
13132 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13133
13134 continue;
13135 }
13136 */
13137
13138 kernel_rules_cnt++;
13139 }
13140
13141 fclose (fp);
13142
13143 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13144
13145 all_kernel_rules_buf[i] = kernel_rules_buf;
13146 }
13147
13148 /**
13149 * merge rules or automatic rule generator
13150 */
13151
13152 uint kernel_rules_cnt = 0;
13153
13154 kernel_rule_t *kernel_rules_buf = NULL;
13155
13156 if (attack_mode == ATTACK_MODE_STRAIGHT)
13157 {
13158 if (rp_files_cnt)
13159 {
13160 kernel_rules_cnt = 1;
13161
13162 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13163
13164 repeats[0] = kernel_rules_cnt;
13165
13166 for (uint i = 0; i < rp_files_cnt; i++)
13167 {
13168 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13169
13170 repeats[i + 1] = kernel_rules_cnt;
13171 }
13172
13173 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13174
13175 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13176
13177 for (uint i = 0; i < kernel_rules_cnt; i++)
13178 {
13179 uint out_pos = 0;
13180
13181 kernel_rule_t *out = &kernel_rules_buf[i];
13182
13183 for (uint j = 0; j < rp_files_cnt; j++)
13184 {
13185 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13186 uint in_pos;
13187
13188 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13189
13190 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13191 {
13192 if (out_pos == RULES_MAX - 1)
13193 {
13194 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13195
13196 break;
13197 }
13198
13199 out->cmds[out_pos] = in->cmds[in_pos];
13200 }
13201 }
13202 }
13203
13204 local_free (repeats);
13205 }
13206 else if (rp_gen)
13207 {
13208 uint kernel_rules_avail = 0;
13209
13210 while (kernel_rules_cnt < rp_gen)
13211 {
13212 if (kernel_rules_avail == kernel_rules_cnt)
13213 {
13214 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13215
13216 kernel_rules_avail += INCR_RULES;
13217 }
13218
13219 memset (rule_buf, 0, HCBUFSIZ);
13220
13221 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13222
13223 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13224
13225 kernel_rules_cnt++;
13226 }
13227 }
13228 }
13229
13230 myfree (rule_buf);
13231
13232 /**
13233 * generate NOP rules
13234 */
13235
13236 if (kernel_rules_cnt == 0)
13237 {
13238 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13239
13240 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13241
13242 kernel_rules_cnt++;
13243 }
13244
13245 data.kernel_rules_cnt = kernel_rules_cnt;
13246 data.kernel_rules_buf = kernel_rules_buf;
13247
13248 /**
13249 * OpenCL platforms: detect
13250 */
13251
13252 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13253 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13254
13255 cl_uint platforms_cnt = 0;
13256 cl_uint platform_devices_cnt = 0;
13257
13258 if (keyspace == 0)
13259 {
13260 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13261
13262 if (platforms_cnt == 0)
13263 {
13264 log_info ("");
13265 log_info ("ATTENTION! No OpenCL compatible platform found");
13266 log_info ("");
13267 log_info ("You're probably missing the OpenCL runtime installation");
13268 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13269 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13270 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13271 log_info ("");
13272
13273 return (-1);
13274 }
13275
13276 if (opencl_platforms_filter != (uint) -1)
13277 {
13278 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13279
13280 if (opencl_platforms_filter > platform_cnt_mask)
13281 {
13282 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13283
13284 return (-1);
13285 }
13286 }
13287 }
13288
13289 /**
13290 * OpenCL device types:
13291 * 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.
13292 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13293 */
13294
13295 if (opencl_device_types == NULL)
13296 {
13297 cl_device_type device_types_all = 0;
13298
13299 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13300 {
13301 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13302
13303 cl_platform_id platform = platforms[platform_id];
13304
13305 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13306
13307 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13308 {
13309 cl_device_id device = platform_devices[platform_devices_id];
13310
13311 cl_device_type device_type;
13312
13313 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13314
13315 device_types_all |= device_type;
13316 }
13317 }
13318
13319 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13320 {
13321 device_types_filter |= CL_DEVICE_TYPE_CPU;
13322 }
13323 }
13324
13325 /**
13326 * OpenCL devices: simply push all devices from all platforms into the same device array
13327 */
13328
13329 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13330
13331 data.devices_param = devices_param;
13332
13333 uint devices_cnt = 0;
13334
13335 uint devices_active = 0;
13336
13337 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13338 {
13339 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13340
13341 cl_platform_id platform = platforms[platform_id];
13342
13343 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13344
13345 char platform_vendor[INFOSZ] = { 0 };
13346
13347 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13348
13349 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13350 // this causes trouble with vendor id based macros
13351 // we'll assign generic to those without special optimization available
13352
13353 cl_uint platform_vendor_id = 0;
13354
13355 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13356 {
13357 platform_vendor_id = VENDOR_ID_AMD;
13358 }
13359 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13360 {
13361 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13362 }
13363 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13364 {
13365 platform_vendor_id = VENDOR_ID_APPLE;
13366 }
13367 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13368 {
13369 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13370 }
13371 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13372 {
13373 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13374 }
13375 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13376 {
13377 platform_vendor_id = VENDOR_ID_MESA;
13378 }
13379 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13380 {
13381 platform_vendor_id = VENDOR_ID_NV;
13382 }
13383 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13384 {
13385 platform_vendor_id = VENDOR_ID_POCL;
13386 }
13387 else
13388 {
13389 platform_vendor_id = VENDOR_ID_GENERIC;
13390 }
13391
13392 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13393 {
13394 size_t param_value_size = 0;
13395
13396 const uint device_id = devices_cnt;
13397
13398 hc_device_param_t *device_param = &data.devices_param[device_id];
13399
13400 device_param->platform_vendor_id = platform_vendor_id;
13401
13402 device_param->device = platform_devices[platform_devices_id];
13403
13404 device_param->device_id = device_id;
13405
13406 device_param->platform_devices_id = platform_devices_id;
13407
13408 // device_type
13409
13410 cl_device_type device_type;
13411
13412 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13413
13414 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13415
13416 device_param->device_type = device_type;
13417
13418 // device_name
13419
13420 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13421
13422 char *device_name = (char *) mymalloc (param_value_size);
13423
13424 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13425
13426 device_param->device_name = device_name;
13427
13428 // device_vendor
13429
13430 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13431
13432 char *device_vendor = (char *) mymalloc (param_value_size);
13433
13434 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13435
13436 device_param->device_vendor = device_vendor;
13437
13438 cl_uint device_vendor_id = 0;
13439
13440 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13441 {
13442 device_vendor_id = VENDOR_ID_AMD;
13443 }
13444 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13445 {
13446 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13447 }
13448 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13449 {
13450 device_vendor_id = VENDOR_ID_APPLE;
13451 }
13452 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13453 {
13454 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13455 }
13456 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13457 {
13458 device_vendor_id = VENDOR_ID_INTEL_SDK;
13459 }
13460 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13461 {
13462 device_vendor_id = VENDOR_ID_MESA;
13463 }
13464 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13465 {
13466 device_vendor_id = VENDOR_ID_NV;
13467 }
13468 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13469 {
13470 device_vendor_id = VENDOR_ID_POCL;
13471 }
13472 else
13473 {
13474 device_vendor_id = VENDOR_ID_GENERIC;
13475 }
13476
13477 device_param->device_vendor_id = device_vendor_id;
13478
13479 // tuning db
13480
13481 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13482
13483 // device_version
13484
13485 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13486
13487 char *device_version = (char *) mymalloc (param_value_size);
13488
13489 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13490
13491 device_param->device_version = device_version;
13492
13493 // device_opencl_version
13494
13495 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13496
13497 char *device_opencl_version = (char *) mymalloc (param_value_size);
13498
13499 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13500
13501 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13502
13503 myfree (device_opencl_version);
13504
13505 // vector_width
13506
13507 cl_uint vector_width;
13508
13509 if (opencl_vector_width_chgd == 0)
13510 {
13511 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13512 {
13513 if (opti_type & OPTI_TYPE_USES_BITS_64)
13514 {
13515 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13516 }
13517 else
13518 {
13519 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13520 }
13521 }
13522 else
13523 {
13524 vector_width = (cl_uint) tuningdb_entry->vector_width;
13525 }
13526 }
13527 else
13528 {
13529 vector_width = opencl_vector_width;
13530 }
13531
13532 if (vector_width > 16) vector_width = 16;
13533
13534 device_param->vector_width = vector_width;
13535
13536 // max_compute_units
13537
13538 cl_uint device_processors;
13539
13540 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13541
13542 device_param->device_processors = device_processors;
13543
13544 // device_maxmem_alloc
13545 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13546
13547 cl_ulong device_maxmem_alloc;
13548
13549 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13550
13551 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13552
13553 // device_global_mem
13554
13555 cl_ulong device_global_mem;
13556
13557 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13558
13559 device_param->device_global_mem = device_global_mem;
13560
13561 // max_work_group_size
13562
13563 size_t device_maxworkgroup_size;
13564
13565 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13566
13567 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13568
13569 // max_clock_frequency
13570
13571 cl_uint device_maxclock_frequency;
13572
13573 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13574
13575 device_param->device_maxclock_frequency = device_maxclock_frequency;
13576
13577 // device_endian_little
13578
13579 cl_bool device_endian_little;
13580
13581 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13582
13583 if (device_endian_little == CL_FALSE)
13584 {
13585 if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13586
13587 device_param->skipped = 1;
13588 }
13589
13590 // device_available
13591
13592 cl_bool device_available;
13593
13594 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13595
13596 if (device_available == CL_FALSE)
13597 {
13598 if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
13599
13600 device_param->skipped = 1;
13601 }
13602
13603 // device_compiler_available
13604
13605 cl_bool device_compiler_available;
13606
13607 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13608
13609 if (device_compiler_available == CL_FALSE)
13610 {
13611 if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13612
13613 device_param->skipped = 1;
13614 }
13615
13616 // device_execution_capabilities
13617
13618 cl_device_exec_capabilities device_execution_capabilities;
13619
13620 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13621
13622 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13623 {
13624 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13625
13626 device_param->skipped = 1;
13627 }
13628
13629 // device_extensions
13630
13631 size_t device_extensions_size;
13632
13633 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13634
13635 char *device_extensions = mymalloc (device_extensions_size + 1);
13636
13637 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13638
13639 if (strstr (device_extensions, "base_atomics") == 0)
13640 {
13641 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13642
13643 device_param->skipped = 1;
13644 }
13645
13646 if (strstr (device_extensions, "byte_addressable_store") == 0)
13647 {
13648 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13649
13650 device_param->skipped = 1;
13651 }
13652
13653 myfree (device_extensions);
13654
13655 // device_local_mem_size
13656
13657 cl_ulong device_local_mem_size;
13658
13659 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13660
13661 if (device_local_mem_size < 32768)
13662 {
13663 if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13664
13665 device_param->skipped = 1;
13666 }
13667
13668 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13669 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13670 // This results in both utilizing it for 50%
13671 // However, Intel has much better SIMD control over their own hardware
13672 // It makes sense to give them full control over their own hardware
13673
13674 if (device_type & CL_DEVICE_TYPE_CPU)
13675 {
13676 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13677 {
13678 if (data.quiet == 0) log_info ("Device #%u: WARNING: not native intel opencl platform", device_id + 1);
13679
13680 device_param->skipped = 1;
13681 }
13682 }
13683
13684 // skipped
13685
13686 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13687 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13688
13689 // driver_version
13690
13691 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13692
13693 char *driver_version = (char *) mymalloc (param_value_size);
13694
13695 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13696
13697 device_param->driver_version = driver_version;
13698
13699 // device_name_chksum
13700
13701 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13702
13703 #if __x86_64__
13704 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);
13705 #else
13706 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);
13707 #endif
13708
13709 uint device_name_digest[4] = { 0 };
13710
13711 md5_64 ((uint *) device_name_chksum, device_name_digest);
13712
13713 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13714
13715 device_param->device_name_chksum = device_name_chksum;
13716
13717 // device_processor_cores
13718
13719 if (device_type & CL_DEVICE_TYPE_CPU)
13720 {
13721 cl_uint device_processor_cores = 1;
13722
13723 device_param->device_processor_cores = device_processor_cores;
13724 }
13725
13726 if (device_type & CL_DEVICE_TYPE_GPU)
13727 {
13728 if (device_vendor_id == VENDOR_ID_AMD)
13729 {
13730 cl_uint device_processor_cores = 0;
13731
13732 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13733
13734 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13735
13736 device_param->device_processor_cores = device_processor_cores;
13737 }
13738 else if (device_vendor_id == VENDOR_ID_NV)
13739 {
13740 cl_uint kernel_exec_timeout = 0;
13741
13742 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13743
13744 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13745
13746 device_param->kernel_exec_timeout = kernel_exec_timeout;
13747
13748 cl_uint device_processor_cores = 0;
13749
13750 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13751
13752 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13753
13754 device_param->device_processor_cores = device_processor_cores;
13755
13756 cl_uint sm_minor = 0;
13757 cl_uint sm_major = 0;
13758
13759 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13760 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13761
13762 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13763 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13764
13765 device_param->sm_minor = sm_minor;
13766 device_param->sm_major = sm_major;
13767 }
13768 else
13769 {
13770 cl_uint device_processor_cores = 1;
13771
13772 device_param->device_processor_cores = device_processor_cores;
13773 }
13774 }
13775
13776 // display results
13777
13778 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13779 {
13780 if (machine_readable == 0)
13781 {
13782 if (device_param->skipped == 0)
13783 {
13784 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13785 device_id + 1,
13786 device_name,
13787 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13788 (unsigned int) (device_global_mem / 1024 / 1024),
13789 (unsigned int) device_processors);
13790 }
13791 else
13792 {
13793 log_info ("Device #%u: %s, skipped",
13794 device_id + 1,
13795 device_name);
13796 }
13797 }
13798 }
13799
13800 // common driver check
13801
13802 if (device_param->skipped == 0)
13803 {
13804 if (device_type & CL_DEVICE_TYPE_GPU)
13805 {
13806 if (platform_vendor_id == VENDOR_ID_AMD)
13807 {
13808 int catalyst_check = (force == 1) ? 0 : 1;
13809
13810 int catalyst_warn = 0;
13811
13812 int catalyst_broken = 0;
13813
13814 if (catalyst_check == 1)
13815 {
13816 catalyst_warn = 1;
13817
13818 // v14.9 and higher
13819 if (atoi (device_param->driver_version) >= 1573)
13820 {
13821 catalyst_warn = 0;
13822 }
13823
13824 catalyst_check = 0;
13825 }
13826
13827 if (catalyst_broken == 1)
13828 {
13829 log_info ("");
13830 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13831 log_info ("It will pass over cracked hashes and does not report them as cracked");
13832 log_info ("You are STRONGLY encouraged not to use it");
13833 log_info ("You can use --force to override this but do not post error reports if you do so");
13834 log_info ("");
13835
13836 return (-1);
13837 }
13838
13839 if (catalyst_warn == 1)
13840 {
13841 log_info ("");
13842 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13843 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13844 log_info ("See hashcat's homepage for official supported catalyst drivers");
13845 #ifdef _WIN
13846 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13847 #endif
13848 log_info ("You can use --force to override this but do not post error reports if you do so");
13849 log_info ("");
13850
13851 return (-1);
13852 }
13853 }
13854 else if (platform_vendor_id == VENDOR_ID_NV)
13855 {
13856 if (device_param->kernel_exec_timeout != 0)
13857 {
13858 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);
13859 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13860 }
13861 }
13862 }
13863
13864 /* turns out pocl still creates segfaults (because of llvm)
13865 if (device_type & CL_DEVICE_TYPE_CPU)
13866 {
13867 if (platform_vendor_id == VENDOR_ID_AMD)
13868 {
13869 if (force == 0)
13870 {
13871 log_info ("");
13872 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13873 log_info ("You are STRONGLY encouraged not to use it");
13874 log_info ("You can use --force to override this but do not post error reports if you do so");
13875 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13876 log_info ("");
13877
13878 return (-1);
13879 }
13880 }
13881 }
13882 */
13883
13884 /**
13885 * kernel accel and loops tuning db adjustment
13886 */
13887
13888 device_param->kernel_accel_min = 1;
13889 device_param->kernel_accel_max = 1024;
13890
13891 device_param->kernel_loops_min = 1;
13892 device_param->kernel_loops_max = 1024;
13893
13894 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13895
13896 if (tuningdb_entry)
13897 {
13898 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13899 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13900
13901 if (_kernel_accel)
13902 {
13903 device_param->kernel_accel_min = _kernel_accel;
13904 device_param->kernel_accel_max = _kernel_accel;
13905 }
13906
13907 if (_kernel_loops)
13908 {
13909 if (workload_profile == 1)
13910 {
13911 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13912 }
13913 else if (workload_profile == 2)
13914 {
13915 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13916 }
13917
13918 device_param->kernel_loops_min = _kernel_loops;
13919 device_param->kernel_loops_max = _kernel_loops;
13920 }
13921 }
13922
13923 // commandline parameters overwrite tuningdb entries
13924
13925 if (kernel_accel)
13926 {
13927 device_param->kernel_accel_min = kernel_accel;
13928 device_param->kernel_accel_max = kernel_accel;
13929 }
13930
13931 if (kernel_loops)
13932 {
13933 device_param->kernel_loops_min = kernel_loops;
13934 device_param->kernel_loops_max = kernel_loops;
13935 }
13936
13937 /**
13938 * activate device
13939 */
13940
13941 devices_active++;
13942 }
13943
13944 // next please
13945
13946 devices_cnt++;
13947 }
13948 }
13949
13950 if (keyspace == 0 && devices_active == 0)
13951 {
13952 log_error ("ERROR: No devices found/left");
13953
13954 return (-1);
13955 }
13956
13957 // 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)
13958
13959 if (devices_filter != (uint) -1)
13960 {
13961 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13962
13963 if (devices_filter > devices_cnt_mask)
13964 {
13965 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13966
13967 return (-1);
13968 }
13969 }
13970
13971 data.devices_cnt = devices_cnt;
13972
13973 data.devices_active = devices_active;
13974
13975 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13976 {
13977 if (machine_readable == 0)
13978 {
13979 log_info ("");
13980 }
13981 }
13982
13983 /**
13984 * HM devices: init
13985 */
13986
13987 #ifdef HAVE_HWMON
13988 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
13989 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
13990
13991 if (gpu_temp_disable == 0)
13992 {
13993 #if defined(WIN)
13994 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13995
13996 if (nvapi_init (nvapi) == 0)
13997 data.hm_nv = nvapi;
13998
13999 if (data.hm_nv)
14000 {
14001 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
14002 {
14003 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
14004
14005 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14006
14007 int tmp_out = 0;
14008
14009 for (int i = 0; i < tmp_in; i++)
14010 {
14011 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14012 }
14013
14014 for (int i = 0; i < tmp_out; i++)
14015 {
14016 NV_GPU_COOLER_SETTINGS pCoolerSettings;
14017
14018 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
14019
14020 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_get_supported = 1;
14021 }
14022 }
14023 }
14024 #endif // WIN
14025
14026 #if defined(LINUX)
14027 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14028
14029 if (nvml_init (nvml) == 0)
14030 data.hm_nv = nvml;
14031
14032 if (data.hm_nv)
14033 {
14034 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
14035 {
14036 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
14037
14038 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14039
14040 int tmp_out = 0;
14041
14042 for (int i = 0; i < tmp_in; i++)
14043 {
14044 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14045 }
14046
14047 for (int i = 0; i < tmp_out; i++)
14048 {
14049 unsigned int speed;
14050
14051 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_get_supported = 1;
14052 }
14053 }
14054 }
14055 #endif // LINUX
14056
14057 data.hm_amd = NULL;
14058
14059 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14060
14061 if (adl_init (adl) == 0)
14062 data.hm_amd = adl;
14063
14064 if (data.hm_amd)
14065 {
14066 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14067 {
14068 // total number of adapters
14069
14070 int hm_adapters_num;
14071
14072 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
14073
14074 // adapter info
14075
14076 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
14077
14078 if (lpAdapterInfo == NULL) return (-1);
14079
14080 // get a list (of ids of) valid/usable adapters
14081
14082 int num_adl_adapters = 0;
14083
14084 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14085
14086 if (num_adl_adapters > 0)
14087 {
14088 hc_thread_mutex_lock (mux_adl);
14089
14090 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
14091
14092 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14093
14094 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14095 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14096
14097 hc_thread_mutex_unlock (mux_adl);
14098 }
14099
14100 myfree (valid_adl_device_list);
14101 myfree (lpAdapterInfo);
14102 }
14103 }
14104
14105 if (data.hm_amd == NULL && data.hm_nv == NULL)
14106 {
14107 gpu_temp_disable = 1;
14108 }
14109 }
14110
14111 /**
14112 * OpenCL devices: allocate buffer for device specific information
14113 */
14114
14115 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14116 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14117
14118 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14119
14120 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14121
14122 /**
14123 * User-defined GPU temp handling
14124 */
14125
14126 if (gpu_temp_disable == 1)
14127 {
14128 gpu_temp_abort = 0;
14129 gpu_temp_retain = 0;
14130 }
14131
14132 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14133 {
14134 if (gpu_temp_abort < gpu_temp_retain)
14135 {
14136 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14137
14138 return (-1);
14139 }
14140 }
14141
14142 data.gpu_temp_disable = gpu_temp_disable;
14143 data.gpu_temp_abort = gpu_temp_abort;
14144 data.gpu_temp_retain = gpu_temp_retain;
14145 #endif
14146
14147 /**
14148 * enable custom signal handler(s)
14149 */
14150
14151 if (benchmark == 0)
14152 {
14153 hc_signal (sigHandler_default);
14154 }
14155 else
14156 {
14157 hc_signal (sigHandler_benchmark);
14158 }
14159
14160 /**
14161 * inform the user
14162 */
14163
14164 if (data.quiet == 0)
14165 {
14166 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14167
14168 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);
14169
14170 if (attack_mode == ATTACK_MODE_STRAIGHT)
14171 {
14172 log_info ("Rules: %u", kernel_rules_cnt);
14173 }
14174
14175 if (opti_type)
14176 {
14177 log_info ("Applicable Optimizers:");
14178
14179 for (uint i = 0; i < 32; i++)
14180 {
14181 const uint opti_bit = 1u << i;
14182
14183 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14184 }
14185 }
14186
14187 /**
14188 * Watchdog and Temperature balance
14189 */
14190
14191 #ifdef HAVE_HWMON
14192 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
14193 {
14194 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14195 }
14196
14197 if (gpu_temp_abort == 0)
14198 {
14199 log_info ("Watchdog: Temperature abort trigger disabled");
14200 }
14201 else
14202 {
14203 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14204 }
14205
14206 if (gpu_temp_retain == 0)
14207 {
14208 log_info ("Watchdog: Temperature retain trigger disabled");
14209 }
14210 else
14211 {
14212 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14213 }
14214
14215 if (data.quiet == 0) log_info ("");
14216 #endif
14217 }
14218
14219 #ifdef HAVE_HWMON
14220
14221 /**
14222 * HM devices: copy
14223 */
14224
14225 if (gpu_temp_disable == 0)
14226 {
14227 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14228 {
14229 hc_device_param_t *device_param = &data.devices_param[device_id];
14230
14231 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14232
14233 if (device_param->skipped) continue;
14234
14235 const uint platform_devices_id = device_param->platform_devices_id;
14236
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
14242 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14243 {
14244 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14245 }
14246 }
14247 }
14248
14249 /**
14250 * Temporary fix:
14251 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14252 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14253 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14254 * Driver / ADL bug?
14255 */
14256
14257 if (powertune_enable == 1)
14258 {
14259 hc_thread_mutex_lock (mux_adl);
14260
14261 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14262 {
14263 hc_device_param_t *device_param = &data.devices_param[device_id];
14264
14265 if (device_param->skipped) continue;
14266
14267 if (data.hm_device[device_id].od_version == 6)
14268 {
14269 // set powertune value only
14270
14271 int powertune_supported = 0;
14272
14273 int ADL_rc = 0;
14274
14275 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14276 {
14277 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14278
14279 return (-1);
14280 }
14281
14282 if (powertune_supported != 0)
14283 {
14284 // powertune set
14285 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14286
14287 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14288 {
14289 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14290
14291 return (-1);
14292 }
14293
14294 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14295 {
14296 log_error ("ERROR: Failed to set new ADL PowerControl values");
14297
14298 return (-1);
14299 }
14300 }
14301 }
14302 }
14303
14304 hc_thread_mutex_unlock (mux_adl);
14305 }
14306
14307 #endif // HAVE_HWMON
14308
14309 #ifdef DEBUG
14310 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14311 #endif
14312
14313 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14314
14315 uint kernel_power_all = 0;
14316
14317 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14318 {
14319 /**
14320 * host buffer
14321 */
14322
14323 hc_device_param_t *device_param = &data.devices_param[device_id];
14324
14325 if (device_param->skipped) continue;
14326
14327 /**
14328 * device properties
14329 */
14330
14331 const char *device_name_chksum = device_param->device_name_chksum;
14332 const u32 device_processors = device_param->device_processors;
14333 const u32 device_processor_cores = device_param->device_processor_cores;
14334
14335 /**
14336 * create context for each device
14337 */
14338
14339 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14340
14341 /**
14342 * create command-queue
14343 */
14344
14345 // not supported with NV
14346 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14347
14348 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14349
14350 /**
14351 * kernel threads: some algorithms need a fixed kernel-threads count
14352 * because of shared memory usage or bitslice
14353 * there needs to be some upper limit, otherwise there's too much overhead
14354 */
14355
14356 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14357
14358 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14359 {
14360 kernel_threads = KERNEL_THREADS_MAX_CPU;
14361 }
14362
14363 if (hash_mode == 1500) kernel_threads = 64; // DES
14364 if (hash_mode == 3000) kernel_threads = 64; // DES
14365 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14366 if (hash_mode == 7500) kernel_threads = 64; // RC4
14367 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14368 if (hash_mode == 9700) kernel_threads = 64; // RC4
14369 if (hash_mode == 9710) kernel_threads = 64; // RC4
14370 if (hash_mode == 9800) kernel_threads = 64; // RC4
14371 if (hash_mode == 9810) kernel_threads = 64; // RC4
14372 if (hash_mode == 10400) kernel_threads = 64; // RC4
14373 if (hash_mode == 10410) kernel_threads = 64; // RC4
14374 if (hash_mode == 10500) kernel_threads = 64; // RC4
14375 if (hash_mode == 13100) kernel_threads = 64; // RC4
14376
14377 /**
14378 * create input buffers on device : calculate size of fixed memory buffers
14379 */
14380
14381 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14382 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14383
14384 device_param->size_root_css = size_root_css;
14385 device_param->size_markov_css = size_markov_css;
14386
14387 size_t size_results = sizeof (uint);
14388
14389 device_param->size_results = size_results;
14390
14391 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14392 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14393
14394 size_t size_plains = digests_cnt * sizeof (plain_t);
14395 size_t size_salts = salts_cnt * sizeof (salt_t);
14396 size_t size_esalts = salts_cnt * esalt_size;
14397
14398 device_param->size_plains = size_plains;
14399 device_param->size_digests = size_digests;
14400 device_param->size_shown = size_shown;
14401 device_param->size_salts = size_salts;
14402
14403 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14404 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14405 size_t size_tm = 32 * sizeof (bs_word_t);
14406
14407 // scryptV stuff
14408
14409 size_t size_scryptV = 1;
14410
14411 if ((hash_mode == 8900) || (hash_mode == 9300))
14412 {
14413 uint tmto_start = 0;
14414 uint tmto_stop = 10;
14415
14416 if (scrypt_tmto)
14417 {
14418 tmto_start = scrypt_tmto;
14419 }
14420 else
14421 {
14422 // in case the user did not specify the tmto manually
14423 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14424 // but set the lower end only in case the user has a device with too less memory
14425
14426 if (hash_mode == 8900)
14427 {
14428 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14429 {
14430 tmto_start = 1;
14431 }
14432 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14433 {
14434 tmto_start = 2;
14435 }
14436 }
14437 else if (hash_mode == 9300)
14438 {
14439 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14440 {
14441 tmto_start = 2;
14442 }
14443 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14444 {
14445 tmto_start = 2;
14446 }
14447 }
14448 }
14449
14450 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14451 {
14452 // TODO: in theory the following calculation needs to be done per salt, not global
14453 // we assume all hashes have the same scrypt settings
14454
14455 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14456
14457 size_scryptV /= 1 << tmto;
14458
14459 size_scryptV *= device_processors * device_processor_cores;
14460
14461 if (size_scryptV > device_param->device_maxmem_alloc)
14462 {
14463 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14464
14465 continue;
14466 }
14467
14468 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14469 {
14470 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14471 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14472 }
14473
14474 break;
14475 }
14476
14477 if (data.salts_buf[0].scrypt_phy == 0)
14478 {
14479 log_error ("ERROR: can't allocate enough device memory");
14480
14481 return -1;
14482 }
14483
14484 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14485 }
14486
14487 /**
14488 * some algorithms need a fixed kernel-loops count
14489 */
14490
14491 if (hash_mode == 1500)
14492 {
14493 const u32 kernel_loops_fixed = 1024;
14494
14495 device_param->kernel_loops_min = kernel_loops_fixed;
14496 device_param->kernel_loops_max = kernel_loops_fixed;
14497 }
14498
14499 if (hash_mode == 3000)
14500 {
14501 const u32 kernel_loops_fixed = 1024;
14502
14503 device_param->kernel_loops_min = kernel_loops_fixed;
14504 device_param->kernel_loops_max = kernel_loops_fixed;
14505 }
14506
14507 if (hash_mode == 8900)
14508 {
14509 const u32 kernel_loops_fixed = 1;
14510
14511 device_param->kernel_loops_min = kernel_loops_fixed;
14512 device_param->kernel_loops_max = kernel_loops_fixed;
14513 }
14514
14515 if (hash_mode == 9300)
14516 {
14517 const u32 kernel_loops_fixed = 1;
14518
14519 device_param->kernel_loops_min = kernel_loops_fixed;
14520 device_param->kernel_loops_max = kernel_loops_fixed;
14521 }
14522
14523 if (hash_mode == 12500)
14524 {
14525 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14526
14527 device_param->kernel_loops_min = kernel_loops_fixed;
14528 device_param->kernel_loops_max = kernel_loops_fixed;
14529 }
14530
14531 /**
14532 * some algorithms have a maximum kernel-loops count
14533 */
14534
14535 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14536 {
14537 u32 innerloop_cnt = 0;
14538
14539 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14540 {
14541 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14542 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14543 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14544 }
14545 else
14546 {
14547 innerloop_cnt = data.salts_buf[0].salt_iter;
14548 }
14549
14550 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14551 (innerloop_cnt <= device_param->kernel_loops_max))
14552 {
14553 device_param->kernel_loops_max = innerloop_cnt;
14554 }
14555 }
14556
14557 u32 kernel_accel_min = device_param->kernel_accel_min;
14558 u32 kernel_accel_max = device_param->kernel_accel_max;
14559
14560 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14561
14562 size_t size_pws = 4;
14563 size_t size_tmps = 4;
14564 size_t size_hooks = 4;
14565
14566 while (kernel_accel_max >= kernel_accel_min)
14567 {
14568 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14569
14570 // size_pws
14571
14572 size_pws = kernel_power_max * sizeof (pw_t);
14573
14574 // size_tmps
14575
14576 switch (hash_mode)
14577 {
14578 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14579 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14580 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14581 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14582 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14583 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14584 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14585 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14586 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14587 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14588 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14589 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14590 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14591 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14592 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14593 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14594 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14595 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14596 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14597 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14598 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14599 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14600 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14601 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14602 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14603 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14604 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14605 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14606 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14607 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14608 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14609 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14610 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14611 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14612 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14613 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14614 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14615 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14616 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14617 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14618 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14619 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14620 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14621 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14622 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14623 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14624 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14625 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14626 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14627 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14628 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14629 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14630 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14631 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14632 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14633 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14634 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14635 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14636 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14637 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14638 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14639 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14640 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14641 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14642 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14643 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14644 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14645 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14646 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14647 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14648 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14649 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14650 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14651 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14652 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14653 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14654 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14655 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14656 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14657 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14658 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14659 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14660 };
14661
14662 // size_hooks
14663
14664 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14665 {
14666 // none yet
14667 }
14668
14669 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14670 // if not, decrease amplifier and try again
14671
14672 int skip = 0;
14673
14674 const u64 size_total
14675 = bitmap_size
14676 + bitmap_size
14677 + bitmap_size
14678 + bitmap_size
14679 + bitmap_size
14680 + bitmap_size
14681 + bitmap_size
14682 + bitmap_size
14683 + size_bfs
14684 + size_combs
14685 + size_digests
14686 + size_esalts
14687 + size_hooks
14688 + size_markov_css
14689 + size_plains
14690 + size_pws
14691 + size_pws // not a bug
14692 + size_results
14693 + size_root_css
14694 + size_rules
14695 + size_rules_c
14696 + size_salts
14697 + size_scryptV
14698 + size_shown
14699 + size_tm
14700 + size_tmps;
14701
14702 // Don't ask me, ask AMD!
14703
14704 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14705 if (size_total > device_param->device_global_mem) skip = 1;
14706
14707 if (skip == 1)
14708 {
14709 kernel_accel_max--;
14710
14711 continue;
14712 }
14713
14714 break;
14715 }
14716
14717 /*
14718 if (kernel_accel_max == 0)
14719 {
14720 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14721
14722 return -1;
14723 }
14724 */
14725
14726 device_param->kernel_accel_min = kernel_accel_min;
14727 device_param->kernel_accel_max = kernel_accel_max;
14728
14729 /*
14730 if (kernel_accel_max < kernel_accel)
14731 {
14732 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14733
14734 device_param->kernel_accel = kernel_accel_max;
14735 }
14736 */
14737
14738 device_param->size_bfs = size_bfs;
14739 device_param->size_combs = size_combs;
14740 device_param->size_rules = size_rules;
14741 device_param->size_rules_c = size_rules_c;
14742 device_param->size_pws = size_pws;
14743 device_param->size_tmps = size_tmps;
14744 device_param->size_hooks = size_hooks;
14745
14746 // do not confuse kernel_accel_max with kernel_accel here
14747
14748 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14749
14750 device_param->kernel_threads = kernel_threads;
14751 device_param->kernel_power_user = kernel_power;
14752
14753 kernel_power_all += kernel_power;
14754
14755 /**
14756 * default building options
14757 */
14758
14759 char build_opts[1024] = { 0 };
14760
14761 // we don't have sm_* on vendors not NV but it doesn't matter
14762
14763 #if _WIN
14764 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);
14765 #else
14766 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);
14767 #endif
14768
14769 char build_opts_new[1024] = { 0 };
14770
14771 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);
14772
14773 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14774
14775 /*
14776 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14777 {
14778 // we do vectorizing much better than the auto-vectorizer
14779
14780 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14781
14782 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14783 }
14784 */
14785
14786 #ifdef DEBUG
14787 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14788 #endif
14789
14790 /**
14791 * main kernel
14792 */
14793
14794 {
14795 /**
14796 * kernel source filename
14797 */
14798
14799 char source_file[256] = { 0 };
14800
14801 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14802
14803 struct stat sst;
14804
14805 if (stat (source_file, &sst) == -1)
14806 {
14807 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14808
14809 return -1;
14810 }
14811
14812 /**
14813 * kernel cached filename
14814 */
14815
14816 char cached_file[256] = { 0 };
14817
14818 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14819
14820 int cached = 1;
14821
14822 struct stat cst;
14823
14824 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14825 {
14826 cached = 0;
14827 }
14828
14829 /**
14830 * kernel compile or load
14831 */
14832
14833 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14834
14835 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14836
14837 if (force_jit_compilation == -1)
14838 {
14839 if (cached == 0)
14840 {
14841 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14842
14843 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14844
14845 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14846
14847 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14848
14849 #ifdef DEBUG
14850 size_t build_log_size = 0;
14851
14852 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14853
14854 if (build_log_size > 1)
14855 {
14856 char *build_log = (char *) malloc (build_log_size + 1);
14857
14858 memset (build_log, 0, build_log_size + 1);
14859
14860 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14861
14862 puts (build_log);
14863
14864 free (build_log);
14865 }
14866 #endif
14867
14868 if (rc != 0)
14869 {
14870 device_param->skipped = true;
14871
14872 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14873
14874 continue;
14875 }
14876
14877 size_t binary_size;
14878
14879 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14880
14881 u8 *binary = (u8 *) mymalloc (binary_size);
14882
14883 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14884
14885 writeProgramBin (cached_file, binary, binary_size);
14886
14887 local_free (binary);
14888 }
14889 else
14890 {
14891 #ifdef DEBUG
14892 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14893 #endif
14894
14895 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14896
14897 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14898
14899 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14900 }
14901 }
14902 else
14903 {
14904 #ifdef DEBUG
14905 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14906 #endif
14907
14908 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14909
14910 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14911
14912 char build_opts_update[1024] = { 0 };
14913
14914 if (force_jit_compilation == 1500)
14915 {
14916 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14917 }
14918 else if (force_jit_compilation == 8900)
14919 {
14920 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);
14921 }
14922 else
14923 {
14924 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14925 }
14926
14927 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14928
14929 #ifdef DEBUG
14930 size_t build_log_size = 0;
14931
14932 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14933
14934 if (build_log_size > 1)
14935 {
14936 char *build_log = (char *) malloc (build_log_size + 1);
14937
14938 memset (build_log, 0, build_log_size + 1);
14939
14940 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14941
14942 puts (build_log);
14943
14944 free (build_log);
14945 }
14946 #endif
14947
14948 if (rc != 0)
14949 {
14950 device_param->skipped = true;
14951
14952 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14953 }
14954 }
14955
14956 local_free (kernel_lengths);
14957 local_free (kernel_sources[0]);
14958 local_free (kernel_sources);
14959 }
14960
14961 /**
14962 * word generator kernel
14963 */
14964
14965 if (attack_mode != ATTACK_MODE_STRAIGHT)
14966 {
14967 /**
14968 * kernel mp source filename
14969 */
14970
14971 char source_file[256] = { 0 };
14972
14973 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14974
14975 struct stat sst;
14976
14977 if (stat (source_file, &sst) == -1)
14978 {
14979 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14980
14981 return -1;
14982 }
14983
14984 /**
14985 * kernel mp cached filename
14986 */
14987
14988 char cached_file[256] = { 0 };
14989
14990 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14991
14992 int cached = 1;
14993
14994 struct stat cst;
14995
14996 if (stat (cached_file, &cst) == -1)
14997 {
14998 cached = 0;
14999 }
15000
15001 /**
15002 * kernel compile or load
15003 */
15004
15005 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15006
15007 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15008
15009 if (cached == 0)
15010 {
15011 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15012 if (quiet == 0) log_info ("");
15013
15014 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15015
15016 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15017
15018 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15019
15020 if (rc != 0)
15021 {
15022 device_param->skipped = true;
15023
15024 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15025
15026 continue;
15027 }
15028
15029 size_t binary_size;
15030
15031 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15032
15033 u8 *binary = (u8 *) mymalloc (binary_size);
15034
15035 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15036
15037 writeProgramBin (cached_file, binary, binary_size);
15038
15039 local_free (binary);
15040 }
15041 else
15042 {
15043 #ifdef DEBUG
15044 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15045 #endif
15046
15047 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15048
15049 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15050
15051 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15052 }
15053
15054 local_free (kernel_lengths);
15055 local_free (kernel_sources[0]);
15056 local_free (kernel_sources);
15057 }
15058
15059 /**
15060 * amplifier kernel
15061 */
15062
15063 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15064 {
15065
15066 }
15067 else
15068 {
15069 /**
15070 * kernel amp source filename
15071 */
15072
15073 char source_file[256] = { 0 };
15074
15075 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15076
15077 struct stat sst;
15078
15079 if (stat (source_file, &sst) == -1)
15080 {
15081 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15082
15083 return -1;
15084 }
15085
15086 /**
15087 * kernel amp cached filename
15088 */
15089
15090 char cached_file[256] = { 0 };
15091
15092 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15093
15094 int cached = 1;
15095
15096 struct stat cst;
15097
15098 if (stat (cached_file, &cst) == -1)
15099 {
15100 cached = 0;
15101 }
15102
15103 /**
15104 * kernel compile or load
15105 */
15106
15107 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15108
15109 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15110
15111 if (cached == 0)
15112 {
15113 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15114 if (quiet == 0) log_info ("");
15115
15116 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15117
15118 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15119
15120 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15121
15122 if (rc != 0)
15123 {
15124 device_param->skipped = true;
15125
15126 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15127
15128 continue;
15129 }
15130
15131 size_t binary_size;
15132
15133 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15134
15135 u8 *binary = (u8 *) mymalloc (binary_size);
15136
15137 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15138
15139 writeProgramBin (cached_file, binary, binary_size);
15140
15141 local_free (binary);
15142 }
15143 else
15144 {
15145 #ifdef DEBUG
15146 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15147 #endif
15148
15149 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15150
15151 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15152
15153 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15154 }
15155
15156 local_free (kernel_lengths);
15157 local_free (kernel_sources[0]);
15158 local_free (kernel_sources);
15159 }
15160
15161 // some algorithm collide too fast, make that impossible
15162
15163 if (benchmark == 1)
15164 {
15165 ((uint *) digests_buf)[0] = -1;
15166 ((uint *) digests_buf)[1] = -1;
15167 ((uint *) digests_buf)[2] = -1;
15168 ((uint *) digests_buf)[3] = -1;
15169 }
15170
15171 /**
15172 * global buffers
15173 */
15174
15175 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15176 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15177 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15178 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15179 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15180 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15181 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15182 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15183 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15184 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15185 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15186 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15187 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15188 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15189 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15190 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15191 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15192 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15193
15194 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);
15195 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);
15196 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);
15197 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);
15198 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);
15199 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);
15200 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);
15201 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);
15202 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15203 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15204 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15205
15206 /**
15207 * special buffers
15208 */
15209
15210 if (attack_kern == ATTACK_KERN_STRAIGHT)
15211 {
15212 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15213 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15214
15215 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15216 }
15217 else if (attack_kern == ATTACK_KERN_COMBI)
15218 {
15219 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15220 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15221 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15222 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15223 }
15224 else if (attack_kern == ATTACK_KERN_BF)
15225 {
15226 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15227 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15228 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15229 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15230 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15231 }
15232
15233 if (size_esalts)
15234 {
15235 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15236
15237 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15238 }
15239
15240 /**
15241 * main host data
15242 */
15243
15244 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15245
15246 device_param->pws_buf = pws_buf;
15247
15248 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15249
15250 device_param->combs_buf = combs_buf;
15251
15252 void *hooks_buf = mymalloc (size_hooks);
15253
15254 device_param->hooks_buf = hooks_buf;
15255
15256 /**
15257 * kernel args
15258 */
15259
15260 device_param->kernel_params_buf32[21] = bitmap_mask;
15261 device_param->kernel_params_buf32[22] = bitmap_shift1;
15262 device_param->kernel_params_buf32[23] = bitmap_shift2;
15263 device_param->kernel_params_buf32[24] = 0; // salt_pos
15264 device_param->kernel_params_buf32[25] = 0; // loop_pos
15265 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15266 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15267 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15268 device_param->kernel_params_buf32[29] = 0; // digests_offset
15269 device_param->kernel_params_buf32[30] = 0; // combs_mode
15270 device_param->kernel_params_buf32[31] = 0; // gid_max
15271
15272 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15273 ? &device_param->d_pws_buf
15274 : &device_param->d_pws_amp_buf;
15275 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15276 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15277 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15278 device_param->kernel_params[ 4] = &device_param->d_tmps;
15279 device_param->kernel_params[ 5] = &device_param->d_hooks;
15280 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15281 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15282 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15283 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15284 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15285 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15286 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15287 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15288 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15289 device_param->kernel_params[15] = &device_param->d_digests_buf;
15290 device_param->kernel_params[16] = &device_param->d_digests_shown;
15291 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15292 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15293 device_param->kernel_params[19] = &device_param->d_result;
15294 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15295 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15296 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15297 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15298 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15299 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15300 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15301 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15302 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15303 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15304 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15305 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15306
15307 device_param->kernel_params_mp_buf64[3] = 0;
15308 device_param->kernel_params_mp_buf32[4] = 0;
15309 device_param->kernel_params_mp_buf32[5] = 0;
15310 device_param->kernel_params_mp_buf32[6] = 0;
15311 device_param->kernel_params_mp_buf32[7] = 0;
15312 device_param->kernel_params_mp_buf32[8] = 0;
15313
15314 device_param->kernel_params_mp[0] = NULL;
15315 device_param->kernel_params_mp[1] = NULL;
15316 device_param->kernel_params_mp[2] = NULL;
15317 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15318 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15319 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15320 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15321 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15322 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15323
15324 device_param->kernel_params_mp_l_buf64[3] = 0;
15325 device_param->kernel_params_mp_l_buf32[4] = 0;
15326 device_param->kernel_params_mp_l_buf32[5] = 0;
15327 device_param->kernel_params_mp_l_buf32[6] = 0;
15328 device_param->kernel_params_mp_l_buf32[7] = 0;
15329 device_param->kernel_params_mp_l_buf32[8] = 0;
15330 device_param->kernel_params_mp_l_buf32[9] = 0;
15331
15332 device_param->kernel_params_mp_l[0] = NULL;
15333 device_param->kernel_params_mp_l[1] = NULL;
15334 device_param->kernel_params_mp_l[2] = NULL;
15335 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15336 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15337 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15338 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15339 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15340 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15341 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15342
15343 device_param->kernel_params_mp_r_buf64[3] = 0;
15344 device_param->kernel_params_mp_r_buf32[4] = 0;
15345 device_param->kernel_params_mp_r_buf32[5] = 0;
15346 device_param->kernel_params_mp_r_buf32[6] = 0;
15347 device_param->kernel_params_mp_r_buf32[7] = 0;
15348 device_param->kernel_params_mp_r_buf32[8] = 0;
15349
15350 device_param->kernel_params_mp_r[0] = NULL;
15351 device_param->kernel_params_mp_r[1] = NULL;
15352 device_param->kernel_params_mp_r[2] = NULL;
15353 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15354 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15355 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15356 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15357 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15358 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15359
15360 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15361 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15362
15363 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15364 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15365 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15366 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15367 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15368 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15369 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15370
15371 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15372 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15373
15374 device_param->kernel_params_memset_buf32[1] = 0; // value
15375 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15376
15377 device_param->kernel_params_memset[0] = NULL;
15378 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15379 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15380
15381 /**
15382 * kernel name
15383 */
15384
15385 size_t kernel_wgs_tmp;
15386
15387 char kernel_name[64] = { 0 };
15388
15389 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15390 {
15391 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15392 {
15393 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15394
15395 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15396
15397 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15398
15399 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15400
15401 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15402
15403 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15404 }
15405 else
15406 {
15407 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15408
15409 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15410
15411 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15412
15413 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15414
15415 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15416
15417 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15418 }
15419
15420 if (data.attack_mode == ATTACK_MODE_BF)
15421 {
15422 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15423 {
15424 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15425
15426 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15427
15428 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);
15429 }
15430 }
15431 }
15432 else
15433 {
15434 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15435
15436 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15437
15438 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15439
15440 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15441
15442 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15443
15444 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15445
15446 if (opts_type & OPTS_TYPE_HOOK12)
15447 {
15448 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15449
15450 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15451
15452 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);
15453 }
15454
15455 if (opts_type & OPTS_TYPE_HOOK23)
15456 {
15457 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15458
15459 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15460
15461 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);
15462 }
15463 }
15464
15465 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);
15466 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);
15467 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);
15468
15469 for (uint i = 0; i <= 20; i++)
15470 {
15471 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15472 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15473 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15474
15475 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15476 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15477 }
15478
15479 for (uint i = 21; i <= 31; i++)
15480 {
15481 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15482 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15483 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15484
15485 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15486 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15487 }
15488
15489 // GPU memset
15490
15491 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15492
15493 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);
15494
15495 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15496 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15497 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15498
15499 // MP start
15500
15501 if (attack_mode == ATTACK_MODE_BF)
15502 {
15503 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15504 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15505
15506 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);
15507 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);
15508
15509 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15510 {
15511 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15512 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15513 }
15514 }
15515 else if (attack_mode == ATTACK_MODE_HYBRID1)
15516 {
15517 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15518
15519 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);
15520 }
15521 else if (attack_mode == ATTACK_MODE_HYBRID2)
15522 {
15523 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15524
15525 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);
15526 }
15527
15528 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15529 {
15530 // nothing to do
15531 }
15532 else
15533 {
15534 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15535
15536 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);
15537 }
15538
15539 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15540 {
15541 // nothing to do
15542 }
15543 else
15544 {
15545 for (uint i = 0; i < 5; i++)
15546 {
15547 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15548 }
15549
15550 for (uint i = 5; i < 7; i++)
15551 {
15552 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15553 }
15554 }
15555
15556 // maybe this has been updated by clGetKernelWorkGroupInfo()
15557 // value can only be decreased, so we don't need to reallocate buffers
15558
15559 device_param->kernel_threads = kernel_threads;
15560
15561 // zero some data buffers
15562
15563 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15564 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15565 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15566 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15567 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15568 run_kernel_bzero (device_param, device_param->d_result, size_results);
15569
15570 /**
15571 * special buffers
15572 */
15573
15574 if (attack_kern == ATTACK_KERN_STRAIGHT)
15575 {
15576 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15577 }
15578 else if (attack_kern == ATTACK_KERN_COMBI)
15579 {
15580 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15581 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15582 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15583 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15584 }
15585 else if (attack_kern == ATTACK_KERN_BF)
15586 {
15587 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15588 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15589 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15590 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15591 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15592 }
15593
15594 #if defined(HAVE_HWMON)
15595
15596 /**
15597 * Store thermal target temperature so we can send a notice to user
15598 */
15599
15600 if (gpu_temp_disable == 0)
15601 {
15602 const int gpu_temp_threshold_slowdown = hm_get_threshold_slowdown_with_device_id (device_id);
15603
15604 data.hm_device[device_id].gpu_temp_threshold_slowdown = (gpu_temp_threshold_slowdown == -1) ? 100000 : gpu_temp_threshold_slowdown;
15605 }
15606
15607 /**
15608 * Store initial fanspeed if gpu_temp_retain is enabled
15609 */
15610
15611 if (gpu_temp_disable == 0)
15612 {
15613 if (gpu_temp_retain != 0)
15614 {
15615 hc_thread_mutex_lock (mux_adl);
15616
15617 if (data.hm_device[device_id].fan_get_supported == 1)
15618 {
15619 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15620 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15621
15622 temp_retain_fanspeed_value[device_id] = fanspeed;
15623 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15624
15625 // we also set it to tell the OS we take control over the fan and it's automatic controller
15626 // if it was set to automatic. we do not control user-defined fanspeeds.
15627
15628 if (fanpolicy == 1)
15629 {
15630 data.hm_device[device_id].fan_set_supported = 1;
15631
15632 int rc = -1;
15633
15634 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15635 {
15636 rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 1);
15637 }
15638 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15639 {
15640 #ifdef _WIN
15641 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
15642 #endif
15643 }
15644
15645 if (rc == 0)
15646 {
15647 data.hm_device[device_id].fan_set_supported = 1;
15648 }
15649 else
15650 {
15651 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15652
15653 data.hm_device[device_id].fan_set_supported = 0;
15654 }
15655 }
15656 else
15657 {
15658 data.hm_device[device_id].fan_set_supported = 0;
15659 }
15660 }
15661
15662 hc_thread_mutex_unlock (mux_adl);
15663 }
15664 }
15665
15666 /**
15667 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15668 */
15669
15670 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15671 {
15672 hc_thread_mutex_lock (mux_adl);
15673
15674 if (data.hm_device[device_id].od_version == 6)
15675 {
15676 int ADL_rc;
15677
15678 // check powertune capabilities first, if not available then skip device
15679
15680 int powertune_supported = 0;
15681
15682 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15683 {
15684 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15685
15686 return (-1);
15687 }
15688
15689 if (powertune_supported != 0)
15690 {
15691 // powercontrol settings
15692
15693 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15694
15695 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15696 {
15697 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15698 }
15699
15700 if (ADL_rc != ADL_OK)
15701 {
15702 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15703
15704 return (-1);
15705 }
15706
15707 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15708 {
15709 log_error ("ERROR: Failed to set new ADL PowerControl values");
15710
15711 return (-1);
15712 }
15713
15714 // clocks
15715
15716 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15717
15718 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15719
15720 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)
15721 {
15722 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15723
15724 return (-1);
15725 }
15726
15727 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15728
15729 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15730
15731 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15732 {
15733 log_error ("ERROR: Failed to get ADL device capabilities");
15734
15735 return (-1);
15736 }
15737
15738 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15739 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15740
15741 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15742 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15743
15744 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15745 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15746
15747 // warning if profile has too low max values
15748
15749 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15750 {
15751 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15752 }
15753
15754 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15755 {
15756 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15757 }
15758
15759 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15760
15761 performance_state->iNumberOfPerformanceLevels = 2;
15762
15763 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15764 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15765 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15766 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15767
15768 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)
15769 {
15770 log_info ("ERROR: Failed to set ADL performance state");
15771
15772 return (-1);
15773 }
15774
15775 local_free (performance_state);
15776 }
15777 }
15778
15779 hc_thread_mutex_unlock (mux_adl);
15780 }
15781
15782 #endif // HAVE_HWMON
15783 }
15784
15785 data.kernel_power_all = kernel_power_all;
15786
15787 if (data.quiet == 0) log_info_nn ("");
15788
15789 /**
15790 * In benchmark-mode, inform user which algorithm is checked
15791 */
15792
15793 if (benchmark == 1)
15794 {
15795 if (machine_readable == 0)
15796 {
15797 quiet = 0;
15798
15799 data.quiet = quiet;
15800
15801 char *hash_type = strhashtype (data.hash_mode); // not a bug
15802
15803 log_info ("Hashtype: %s", hash_type);
15804 log_info ("");
15805 }
15806 }
15807
15808 /**
15809 * keep track of the progress
15810 */
15811
15812 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15813 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15814 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15815
15816 /**
15817 * open filehandles
15818 */
15819
15820 #if _WIN
15821 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15822 {
15823 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15824
15825 return (-1);
15826 }
15827
15828 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15829 {
15830 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15831
15832 return (-1);
15833 }
15834
15835 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15836 {
15837 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15838
15839 return (-1);
15840 }
15841 #endif
15842
15843 /**
15844 * dictionary pad
15845 */
15846
15847 segment_size *= (1024 * 1024);
15848
15849 data.segment_size = segment_size;
15850
15851 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15852
15853 wl_data->buf = (char *) mymalloc (segment_size);
15854 wl_data->avail = segment_size;
15855 wl_data->incr = segment_size;
15856 wl_data->cnt = 0;
15857 wl_data->pos = 0;
15858
15859 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15860
15861 data.wordlist_mode = wordlist_mode;
15862
15863 cs_t *css_buf = NULL;
15864 uint css_cnt = 0;
15865 uint dictcnt = 0;
15866 uint maskcnt = 1;
15867 char **masks = NULL;
15868 char **dictfiles = NULL;
15869
15870 uint mask_from_file = 0;
15871
15872 if (attack_mode == ATTACK_MODE_STRAIGHT)
15873 {
15874 if (wordlist_mode == WL_MODE_FILE)
15875 {
15876 int wls_left = myargc - (optind + 1);
15877
15878 for (int i = 0; i < wls_left; i++)
15879 {
15880 char *l0_filename = myargv[optind + 1 + i];
15881
15882 struct stat l0_stat;
15883
15884 if (stat (l0_filename, &l0_stat) == -1)
15885 {
15886 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15887
15888 return (-1);
15889 }
15890
15891 uint is_dir = S_ISDIR (l0_stat.st_mode);
15892
15893 if (is_dir == 0)
15894 {
15895 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15896
15897 dictcnt++;
15898
15899 dictfiles[dictcnt - 1] = l0_filename;
15900 }
15901 else
15902 {
15903 // do not allow --keyspace w/ a directory
15904
15905 if (keyspace == 1)
15906 {
15907 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15908
15909 return (-1);
15910 }
15911
15912 char **dictionary_files = NULL;
15913
15914 dictionary_files = scan_directory (l0_filename);
15915
15916 if (dictionary_files != NULL)
15917 {
15918 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15919
15920 for (int d = 0; dictionary_files[d] != NULL; d++)
15921 {
15922 char *l1_filename = dictionary_files[d];
15923
15924 struct stat l1_stat;
15925
15926 if (stat (l1_filename, &l1_stat) == -1)
15927 {
15928 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15929
15930 return (-1);
15931 }
15932
15933 if (S_ISREG (l1_stat.st_mode))
15934 {
15935 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15936
15937 dictcnt++;
15938
15939 dictfiles[dictcnt - 1] = strdup (l1_filename);
15940 }
15941 }
15942 }
15943
15944 local_free (dictionary_files);
15945 }
15946 }
15947
15948 if (dictcnt < 1)
15949 {
15950 log_error ("ERROR: No usable dictionary file found.");
15951
15952 return (-1);
15953 }
15954 }
15955 else if (wordlist_mode == WL_MODE_STDIN)
15956 {
15957 dictcnt = 1;
15958 }
15959 }
15960 else if (attack_mode == ATTACK_MODE_COMBI)
15961 {
15962 // display
15963
15964 char *dictfile1 = myargv[optind + 1 + 0];
15965 char *dictfile2 = myargv[optind + 1 + 1];
15966
15967 // find the bigger dictionary and use as base
15968
15969 FILE *fp1 = NULL;
15970 FILE *fp2 = NULL;
15971
15972 struct stat tmp_stat;
15973
15974 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15975 {
15976 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15977
15978 return (-1);
15979 }
15980
15981 if (stat (dictfile1, &tmp_stat) == -1)
15982 {
15983 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15984
15985 fclose (fp1);
15986
15987 return (-1);
15988 }
15989
15990 if (S_ISDIR (tmp_stat.st_mode))
15991 {
15992 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15993
15994 fclose (fp1);
15995
15996 return (-1);
15997 }
15998
15999 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16000 {
16001 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16002
16003 fclose (fp1);
16004
16005 return (-1);
16006 }
16007
16008 if (stat (dictfile2, &tmp_stat) == -1)
16009 {
16010 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16011
16012 fclose (fp1);
16013 fclose (fp2);
16014
16015 return (-1);
16016 }
16017
16018 if (S_ISDIR (tmp_stat.st_mode))
16019 {
16020 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16021
16022 fclose (fp1);
16023 fclose (fp2);
16024
16025 return (-1);
16026 }
16027
16028 data.combs_cnt = 1;
16029
16030 data.quiet = 1;
16031
16032 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16033
16034 data.quiet = quiet;
16035
16036 if (words1_cnt == 0)
16037 {
16038 log_error ("ERROR: %s: empty file", dictfile1);
16039
16040 fclose (fp1);
16041 fclose (fp2);
16042
16043 return (-1);
16044 }
16045
16046 data.combs_cnt = 1;
16047
16048 data.quiet = 1;
16049
16050 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16051
16052 data.quiet = quiet;
16053
16054 if (words2_cnt == 0)
16055 {
16056 log_error ("ERROR: %s: empty file", dictfile2);
16057
16058 fclose (fp1);
16059 fclose (fp2);
16060
16061 return (-1);
16062 }
16063
16064 fclose (fp1);
16065 fclose (fp2);
16066
16067 data.dictfile = dictfile1;
16068 data.dictfile2 = dictfile2;
16069
16070 if (words1_cnt >= words2_cnt)
16071 {
16072 data.combs_cnt = words2_cnt;
16073 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16074
16075 dictfiles = &data.dictfile;
16076
16077 dictcnt = 1;
16078 }
16079 else
16080 {
16081 data.combs_cnt = words1_cnt;
16082 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16083
16084 dictfiles = &data.dictfile2;
16085
16086 dictcnt = 1;
16087
16088 // we also have to switch wordlist related rules!
16089
16090 char *tmpc = data.rule_buf_l;
16091
16092 data.rule_buf_l = data.rule_buf_r;
16093 data.rule_buf_r = tmpc;
16094
16095 int tmpi = data.rule_len_l;
16096
16097 data.rule_len_l = data.rule_len_r;
16098 data.rule_len_r = tmpi;
16099 }
16100 }
16101 else if (attack_mode == ATTACK_MODE_BF)
16102 {
16103 char *mask = NULL;
16104
16105 maskcnt = 0;
16106
16107 if (benchmark == 0)
16108 {
16109 mask = myargv[optind + 1];
16110
16111 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16112
16113 if ((optind + 2) <= myargc)
16114 {
16115 struct stat file_stat;
16116
16117 if (stat (mask, &file_stat) == -1)
16118 {
16119 maskcnt = 1;
16120
16121 masks[maskcnt - 1] = mystrdup (mask);
16122 }
16123 else
16124 {
16125 int wls_left = myargc - (optind + 1);
16126
16127 uint masks_avail = INCR_MASKS;
16128
16129 for (int i = 0; i < wls_left; i++)
16130 {
16131 if (i != 0)
16132 {
16133 mask = myargv[optind + 1 + i];
16134
16135 if (stat (mask, &file_stat) == -1)
16136 {
16137 log_error ("ERROR: %s: %s", mask, strerror (errno));
16138
16139 return (-1);
16140 }
16141 }
16142
16143 uint is_file = S_ISREG (file_stat.st_mode);
16144
16145 if (is_file == 1)
16146 {
16147 FILE *mask_fp;
16148
16149 if ((mask_fp = fopen (mask, "r")) == NULL)
16150 {
16151 log_error ("ERROR: %s: %s", mask, strerror (errno));
16152
16153 return (-1);
16154 }
16155
16156 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16157
16158 while (!feof (mask_fp))
16159 {
16160 memset (line_buf, 0, HCBUFSIZ);
16161
16162 int line_len = fgetl (mask_fp, line_buf);
16163
16164 if (line_len == 0) continue;
16165
16166 if (line_buf[0] == '#') continue;
16167
16168 if (masks_avail == maskcnt)
16169 {
16170 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16171
16172 masks_avail += INCR_MASKS;
16173 }
16174
16175 masks[maskcnt] = mystrdup (line_buf);
16176
16177 maskcnt++;
16178 }
16179
16180 myfree (line_buf);
16181
16182 fclose (mask_fp);
16183 }
16184 else
16185 {
16186 log_error ("ERROR: %s: unsupported file-type", mask);
16187
16188 return (-1);
16189 }
16190 }
16191
16192 mask_from_file = 1;
16193 }
16194 }
16195 else
16196 {
16197 custom_charset_1 = (char *) "?l?d?u";
16198 custom_charset_2 = (char *) "?l?d";
16199 custom_charset_3 = (char *) "?l?d*!$@_";
16200
16201 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16202 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16203 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16204
16205 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16206
16207 wordlist_mode = WL_MODE_MASK;
16208
16209 data.wordlist_mode = wordlist_mode;
16210
16211 increment = 1;
16212
16213 maskcnt = 1;
16214 }
16215 }
16216 else
16217 {
16218 /**
16219 * generate full masks and charsets
16220 */
16221
16222 masks = (char **) mymalloc (sizeof (char *));
16223
16224 switch (hash_mode)
16225 {
16226 case 1731: pw_min = 5;
16227 pw_max = 5;
16228 mask = mystrdup ("?b?b?b?b?b");
16229 break;
16230 case 12500: pw_min = 5;
16231 pw_max = 5;
16232 mask = mystrdup ("?b?b?b?b?b");
16233 break;
16234 default: pw_min = 7;
16235 pw_max = 7;
16236 mask = mystrdup ("?b?b?b?b?b?b?b");
16237 break;
16238 }
16239
16240 maskcnt = 1;
16241
16242 masks[maskcnt - 1] = mystrdup (mask);
16243
16244 wordlist_mode = WL_MODE_MASK;
16245
16246 data.wordlist_mode = wordlist_mode;
16247
16248 increment = 1;
16249 }
16250
16251 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16252
16253 if (increment)
16254 {
16255 if (increment_min > pw_min) pw_min = increment_min;
16256
16257 if (increment_max < pw_max) pw_max = increment_max;
16258 }
16259 }
16260 else if (attack_mode == ATTACK_MODE_HYBRID1)
16261 {
16262 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16263
16264 // display
16265
16266 char *mask = myargv[myargc - 1];
16267
16268 maskcnt = 0;
16269
16270 masks = (char **) mymalloc (1 * sizeof (char *));
16271
16272 // mod
16273
16274 struct stat file_stat;
16275
16276 if (stat (mask, &file_stat) == -1)
16277 {
16278 maskcnt = 1;
16279
16280 masks[maskcnt - 1] = mystrdup (mask);
16281 }
16282 else
16283 {
16284 uint is_file = S_ISREG (file_stat.st_mode);
16285
16286 if (is_file == 1)
16287 {
16288 FILE *mask_fp;
16289
16290 if ((mask_fp = fopen (mask, "r")) == NULL)
16291 {
16292 log_error ("ERROR: %s: %s", mask, strerror (errno));
16293
16294 return (-1);
16295 }
16296
16297 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16298
16299 uint masks_avail = 1;
16300
16301 while (!feof (mask_fp))
16302 {
16303 memset (line_buf, 0, HCBUFSIZ);
16304
16305 int line_len = fgetl (mask_fp, line_buf);
16306
16307 if (line_len == 0) continue;
16308
16309 if (line_buf[0] == '#') continue;
16310
16311 if (masks_avail == maskcnt)
16312 {
16313 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16314
16315 masks_avail += INCR_MASKS;
16316 }
16317
16318 masks[maskcnt] = mystrdup (line_buf);
16319
16320 maskcnt++;
16321 }
16322
16323 myfree (line_buf);
16324
16325 fclose (mask_fp);
16326
16327 mask_from_file = 1;
16328 }
16329 else
16330 {
16331 maskcnt = 1;
16332
16333 masks[maskcnt - 1] = mystrdup (mask);
16334 }
16335 }
16336
16337 // base
16338
16339 int wls_left = myargc - (optind + 2);
16340
16341 for (int i = 0; i < wls_left; i++)
16342 {
16343 char *filename = myargv[optind + 1 + i];
16344
16345 struct stat file_stat;
16346
16347 if (stat (filename, &file_stat) == -1)
16348 {
16349 log_error ("ERROR: %s: %s", filename, strerror (errno));
16350
16351 return (-1);
16352 }
16353
16354 uint is_dir = S_ISDIR (file_stat.st_mode);
16355
16356 if (is_dir == 0)
16357 {
16358 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16359
16360 dictcnt++;
16361
16362 dictfiles[dictcnt - 1] = filename;
16363 }
16364 else
16365 {
16366 // do not allow --keyspace w/ a directory
16367
16368 if (keyspace == 1)
16369 {
16370 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16371
16372 return (-1);
16373 }
16374
16375 char **dictionary_files = NULL;
16376
16377 dictionary_files = scan_directory (filename);
16378
16379 if (dictionary_files != NULL)
16380 {
16381 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16382
16383 for (int d = 0; dictionary_files[d] != NULL; d++)
16384 {
16385 char *l1_filename = dictionary_files[d];
16386
16387 struct stat l1_stat;
16388
16389 if (stat (l1_filename, &l1_stat) == -1)
16390 {
16391 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16392
16393 return (-1);
16394 }
16395
16396 if (S_ISREG (l1_stat.st_mode))
16397 {
16398 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16399
16400 dictcnt++;
16401
16402 dictfiles[dictcnt - 1] = strdup (l1_filename);
16403 }
16404 }
16405 }
16406
16407 local_free (dictionary_files);
16408 }
16409 }
16410
16411 if (dictcnt < 1)
16412 {
16413 log_error ("ERROR: No usable dictionary file found.");
16414
16415 return (-1);
16416 }
16417
16418 if (increment)
16419 {
16420 maskcnt = 0;
16421
16422 uint mask_min = increment_min; // we can't reject smaller masks here
16423 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16424
16425 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16426 {
16427 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16428
16429 if (cur_mask == NULL) break;
16430
16431 masks[maskcnt] = cur_mask;
16432
16433 maskcnt++;
16434
16435 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16436 }
16437 }
16438 }
16439 else if (attack_mode == ATTACK_MODE_HYBRID2)
16440 {
16441 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16442
16443 // display
16444
16445 char *mask = myargv[optind + 1 + 0];
16446
16447 maskcnt = 0;
16448
16449 masks = (char **) mymalloc (1 * sizeof (char *));
16450
16451 // mod
16452
16453 struct stat file_stat;
16454
16455 if (stat (mask, &file_stat) == -1)
16456 {
16457 maskcnt = 1;
16458
16459 masks[maskcnt - 1] = mystrdup (mask);
16460 }
16461 else
16462 {
16463 uint is_file = S_ISREG (file_stat.st_mode);
16464
16465 if (is_file == 1)
16466 {
16467 FILE *mask_fp;
16468
16469 if ((mask_fp = fopen (mask, "r")) == NULL)
16470 {
16471 log_error ("ERROR: %s: %s", mask, strerror (errno));
16472
16473 return (-1);
16474 }
16475
16476 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16477
16478 uint masks_avail = 1;
16479
16480 while (!feof (mask_fp))
16481 {
16482 memset (line_buf, 0, HCBUFSIZ);
16483
16484 int line_len = fgetl (mask_fp, line_buf);
16485
16486 if (line_len == 0) continue;
16487
16488 if (line_buf[0] == '#') continue;
16489
16490 if (masks_avail == maskcnt)
16491 {
16492 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16493
16494 masks_avail += INCR_MASKS;
16495 }
16496
16497 masks[maskcnt] = mystrdup (line_buf);
16498
16499 maskcnt++;
16500 }
16501
16502 myfree (line_buf);
16503
16504 fclose (mask_fp);
16505
16506 mask_from_file = 1;
16507 }
16508 else
16509 {
16510 maskcnt = 1;
16511
16512 masks[maskcnt - 1] = mystrdup (mask);
16513 }
16514 }
16515
16516 // base
16517
16518 int wls_left = myargc - (optind + 2);
16519
16520 for (int i = 0; i < wls_left; i++)
16521 {
16522 char *filename = myargv[optind + 2 + i];
16523
16524 struct stat file_stat;
16525
16526 if (stat (filename, &file_stat) == -1)
16527 {
16528 log_error ("ERROR: %s: %s", filename, strerror (errno));
16529
16530 return (-1);
16531 }
16532
16533 uint is_dir = S_ISDIR (file_stat.st_mode);
16534
16535 if (is_dir == 0)
16536 {
16537 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16538
16539 dictcnt++;
16540
16541 dictfiles[dictcnt - 1] = filename;
16542 }
16543 else
16544 {
16545 // do not allow --keyspace w/ a directory
16546
16547 if (keyspace == 1)
16548 {
16549 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16550
16551 return (-1);
16552 }
16553
16554 char **dictionary_files = NULL;
16555
16556 dictionary_files = scan_directory (filename);
16557
16558 if (dictionary_files != NULL)
16559 {
16560 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16561
16562 for (int d = 0; dictionary_files[d] != NULL; d++)
16563 {
16564 char *l1_filename = dictionary_files[d];
16565
16566 struct stat l1_stat;
16567
16568 if (stat (l1_filename, &l1_stat) == -1)
16569 {
16570 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16571
16572 return (-1);
16573 }
16574
16575 if (S_ISREG (l1_stat.st_mode))
16576 {
16577 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16578
16579 dictcnt++;
16580
16581 dictfiles[dictcnt - 1] = strdup (l1_filename);
16582 }
16583 }
16584 }
16585
16586 local_free (dictionary_files);
16587 }
16588 }
16589
16590 if (dictcnt < 1)
16591 {
16592 log_error ("ERROR: No usable dictionary file found.");
16593
16594 return (-1);
16595 }
16596
16597 if (increment)
16598 {
16599 maskcnt = 0;
16600
16601 uint mask_min = increment_min; // we can't reject smaller masks here
16602 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16603
16604 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16605 {
16606 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16607
16608 if (cur_mask == NULL) break;
16609
16610 masks[maskcnt] = cur_mask;
16611
16612 maskcnt++;
16613
16614 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16615 }
16616 }
16617 }
16618
16619 data.pw_min = pw_min;
16620 data.pw_max = pw_max;
16621
16622 /**
16623 * weak hash check
16624 */
16625
16626 if (weak_hash_threshold >= salts_cnt)
16627 {
16628 hc_device_param_t *device_param = NULL;
16629
16630 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16631 {
16632 device_param = &data.devices_param[device_id];
16633
16634 if (device_param->skipped) continue;
16635
16636 break;
16637 }
16638
16639 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16640
16641 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16642 {
16643 weak_hash_check (device_param, salt_pos);
16644 }
16645
16646 // Display hack, guarantee that there is at least one \r before real start
16647
16648 //if (data.quiet == 0) log_info ("");
16649 }
16650
16651 /**
16652 * status and monitor threads
16653 */
16654
16655 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16656
16657 hc_thread_t i_thread = 0;
16658
16659 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16660 {
16661 hc_thread_create (i_thread, thread_keypress, &benchmark);
16662 }
16663
16664 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16665
16666 uint ni_threads_cnt = 0;
16667
16668 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16669
16670 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16671
16672 ni_threads_cnt++;
16673
16674 /**
16675 * Outfile remove
16676 */
16677
16678 if (keyspace == 0)
16679 {
16680 if (outfile_check_timer != 0)
16681 {
16682 if (data.outfile_check_directory != NULL)
16683 {
16684 if ((hash_mode != 5200) &&
16685 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16686 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16687 (hash_mode != 9000))
16688 {
16689 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16690
16691 ni_threads_cnt++;
16692 }
16693 else
16694 {
16695 outfile_check_timer = 0;
16696 }
16697 }
16698 else
16699 {
16700 outfile_check_timer = 0;
16701 }
16702 }
16703 }
16704
16705 /**
16706 * Inform the user if we got some hashes remove because of the pot file remove feature
16707 */
16708
16709 if (data.quiet == 0)
16710 {
16711 if (potfile_remove_cracks > 0)
16712 {
16713 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16714 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16715 }
16716 }
16717
16718 data.outfile_check_timer = outfile_check_timer;
16719
16720 /**
16721 * main loop
16722 */
16723
16724 char **induction_dictionaries = NULL;
16725
16726 int induction_dictionaries_cnt = 0;
16727
16728 hcstat_table_t *root_table_buf = NULL;
16729 hcstat_table_t *markov_table_buf = NULL;
16730
16731 uint initial_restore_done = 0;
16732
16733 data.maskcnt = maskcnt;
16734
16735 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16736 {
16737 if (data.devices_status == STATUS_CRACKED) break;
16738
16739 data.devices_status = STATUS_INIT;
16740
16741 if (maskpos > rd->maskpos)
16742 {
16743 rd->dictpos = 0;
16744 }
16745
16746 rd->maskpos = maskpos;
16747 data.maskpos = maskpos;
16748
16749 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16750 {
16751 char *mask = masks[maskpos];
16752
16753 if (mask_from_file == 1)
16754 {
16755 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16756
16757 char *str_ptr;
16758 uint str_pos;
16759
16760 uint mask_offset = 0;
16761
16762 uint separator_cnt;
16763
16764 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16765 {
16766 str_ptr = strstr (mask + mask_offset, ",");
16767
16768 if (str_ptr == NULL) break;
16769
16770 str_pos = str_ptr - mask;
16771
16772 // escaped separator, i.e. "\,"
16773
16774 if (str_pos > 0)
16775 {
16776 if (mask[str_pos - 1] == '\\')
16777 {
16778 separator_cnt --;
16779
16780 mask_offset = str_pos + 1;
16781
16782 continue;
16783 }
16784 }
16785
16786 // reset the offset
16787
16788 mask_offset = 0;
16789
16790 mask[str_pos] = '\0';
16791
16792 switch (separator_cnt)
16793 {
16794 case 0:
16795 mp_reset_usr (mp_usr, 0);
16796
16797 custom_charset_1 = mask;
16798 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16799 break;
16800
16801 case 1:
16802 mp_reset_usr (mp_usr, 1);
16803
16804 custom_charset_2 = mask;
16805 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16806 break;
16807
16808 case 2:
16809 mp_reset_usr (mp_usr, 2);
16810
16811 custom_charset_3 = mask;
16812 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16813 break;
16814
16815 case 3:
16816 mp_reset_usr (mp_usr, 3);
16817
16818 custom_charset_4 = mask;
16819 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16820 break;
16821 }
16822
16823 mask = mask + str_pos + 1;
16824 }
16825 }
16826
16827 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16828 {
16829 if (maskpos > 0)
16830 {
16831 local_free (css_buf);
16832 local_free (data.root_css_buf);
16833 local_free (data.markov_css_buf);
16834
16835 local_free (masks[maskpos - 1]);
16836 }
16837
16838 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16839
16840 data.mask = mask;
16841 data.css_cnt = css_cnt;
16842 data.css_buf = css_buf;
16843
16844 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16845
16846 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16847
16848 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16849 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16850
16851 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16852
16853 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16854
16855 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16856 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16857
16858 data.root_css_buf = root_css_buf;
16859 data.markov_css_buf = markov_css_buf;
16860
16861 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16862
16863 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16864
16865 local_free (root_table_buf);
16866 local_free (markov_table_buf);
16867
16868 // args
16869
16870 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16871 {
16872 hc_device_param_t *device_param = &data.devices_param[device_id];
16873
16874 if (device_param->skipped) continue;
16875
16876 device_param->kernel_params_mp[0] = &device_param->d_combs;
16877 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16878 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16879
16880 device_param->kernel_params_mp_buf64[3] = 0;
16881 device_param->kernel_params_mp_buf32[4] = css_cnt;
16882 device_param->kernel_params_mp_buf32[5] = 0;
16883 device_param->kernel_params_mp_buf32[6] = 0;
16884 device_param->kernel_params_mp_buf32[7] = 0;
16885
16886 if (attack_mode == ATTACK_MODE_HYBRID1)
16887 {
16888 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16889 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16890 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16891 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16892 }
16893 else if (attack_mode == ATTACK_MODE_HYBRID2)
16894 {
16895 device_param->kernel_params_mp_buf32[5] = 0;
16896 device_param->kernel_params_mp_buf32[6] = 0;
16897 device_param->kernel_params_mp_buf32[7] = 0;
16898 }
16899
16900 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]);
16901 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]);
16902 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]);
16903
16904 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);
16905 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);
16906 }
16907 }
16908 else if (attack_mode == ATTACK_MODE_BF)
16909 {
16910 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16911
16912 if (increment)
16913 {
16914 for (uint i = 0; i < dictcnt; i++)
16915 {
16916 local_free (dictfiles[i]);
16917 }
16918
16919 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16920 {
16921 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16922
16923 if (l1_filename == NULL) break;
16924
16925 dictcnt++;
16926
16927 dictfiles[dictcnt - 1] = l1_filename;
16928 }
16929 }
16930 else
16931 {
16932 dictcnt++;
16933
16934 dictfiles[dictcnt - 1] = mask;
16935 }
16936
16937 if (dictcnt == 0)
16938 {
16939 log_error ("ERROR: Mask is too small");
16940
16941 return (-1);
16942 }
16943 }
16944 }
16945
16946 free (induction_dictionaries);
16947
16948 // induction_dictionaries_cnt = 0; // implied
16949
16950 if (attack_mode != ATTACK_MODE_BF)
16951 {
16952 if (keyspace == 0)
16953 {
16954 induction_dictionaries = scan_directory (induction_directory);
16955
16956 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16957 }
16958 }
16959
16960 if (induction_dictionaries_cnt)
16961 {
16962 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16963 }
16964
16965 /**
16966 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16967 */
16968 if (keyspace == 1)
16969 {
16970 if ((maskcnt > 1) || (dictcnt > 1))
16971 {
16972 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16973
16974 return (-1);
16975 }
16976 }
16977
16978 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16979 {
16980 char *subid = logfile_generate_subid ();
16981
16982 data.subid = subid;
16983
16984 logfile_sub_msg ("START");
16985
16986 data.devices_status = STATUS_INIT;
16987
16988 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16989 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16990 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16991
16992 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16993
16994 data.cpt_pos = 0;
16995
16996 data.cpt_start = time (NULL);
16997
16998 data.cpt_total = 0;
16999
17000 if (data.restore == 0)
17001 {
17002 rd->words_cur = skip;
17003
17004 skip = 0;
17005
17006 data.skip = 0;
17007 }
17008
17009 data.ms_paused = 0;
17010
17011 data.words_cur = rd->words_cur;
17012
17013 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17014 {
17015 hc_device_param_t *device_param = &data.devices_param[device_id];
17016
17017 if (device_param->skipped) continue;
17018
17019 device_param->speed_pos = 0;
17020
17021 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17022 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17023
17024 device_param->exec_pos = 0;
17025
17026 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17027
17028 device_param->kernel_power = device_param->kernel_power_user;
17029
17030 device_param->outerloop_pos = 0;
17031 device_param->outerloop_left = 0;
17032 device_param->innerloop_pos = 0;
17033 device_param->innerloop_left = 0;
17034
17035 // some more resets:
17036
17037 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17038
17039 device_param->pws_cnt = 0;
17040
17041 device_param->words_off = 0;
17042 device_param->words_done = 0;
17043 }
17044
17045 data.kernel_power_div = 0;
17046
17047 // figure out some workload
17048
17049 if (attack_mode == ATTACK_MODE_STRAIGHT)
17050 {
17051 if (data.wordlist_mode == WL_MODE_FILE)
17052 {
17053 char *dictfile = NULL;
17054
17055 if (induction_dictionaries_cnt)
17056 {
17057 dictfile = induction_dictionaries[0];
17058 }
17059 else
17060 {
17061 dictfile = dictfiles[dictpos];
17062 }
17063
17064 data.dictfile = dictfile;
17065
17066 logfile_sub_string (dictfile);
17067
17068 for (uint i = 0; i < rp_files_cnt; i++)
17069 {
17070 logfile_sub_var_string ("rulefile", rp_files[i]);
17071 }
17072
17073 FILE *fd2 = fopen (dictfile, "rb");
17074
17075 if (fd2 == NULL)
17076 {
17077 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17078
17079 return (-1);
17080 }
17081
17082 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17083
17084 fclose (fd2);
17085
17086 if (data.words_cnt == 0)
17087 {
17088 if (data.devices_status == STATUS_CRACKED) break;
17089 if (data.devices_status == STATUS_ABORTED) break;
17090
17091 dictpos++;
17092
17093 continue;
17094 }
17095 }
17096 }
17097 else if (attack_mode == ATTACK_MODE_COMBI)
17098 {
17099 char *dictfile = data.dictfile;
17100 char *dictfile2 = data.dictfile2;
17101
17102 logfile_sub_string (dictfile);
17103 logfile_sub_string (dictfile2);
17104
17105 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17106 {
17107 FILE *fd2 = fopen (dictfile, "rb");
17108
17109 if (fd2 == NULL)
17110 {
17111 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17112
17113 return (-1);
17114 }
17115
17116 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17117
17118 fclose (fd2);
17119 }
17120 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17121 {
17122 FILE *fd2 = fopen (dictfile2, "rb");
17123
17124 if (fd2 == NULL)
17125 {
17126 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17127
17128 return (-1);
17129 }
17130
17131 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17132
17133 fclose (fd2);
17134 }
17135
17136 if (data.words_cnt == 0)
17137 {
17138 if (data.devices_status == STATUS_CRACKED) break;
17139 if (data.devices_status == STATUS_ABORTED) break;
17140
17141 dictpos++;
17142
17143 continue;
17144 }
17145 }
17146 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17147 {
17148 char *dictfile = NULL;
17149
17150 if (induction_dictionaries_cnt)
17151 {
17152 dictfile = induction_dictionaries[0];
17153 }
17154 else
17155 {
17156 dictfile = dictfiles[dictpos];
17157 }
17158
17159 data.dictfile = dictfile;
17160
17161 char *mask = data.mask;
17162
17163 logfile_sub_string (dictfile);
17164 logfile_sub_string (mask);
17165
17166 FILE *fd2 = fopen (dictfile, "rb");
17167
17168 if (fd2 == NULL)
17169 {
17170 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17171
17172 return (-1);
17173 }
17174
17175 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17176
17177 fclose (fd2);
17178
17179 if (data.words_cnt == 0)
17180 {
17181 if (data.devices_status == STATUS_CRACKED) break;
17182 if (data.devices_status == STATUS_ABORTED) break;
17183
17184 dictpos++;
17185
17186 continue;
17187 }
17188 }
17189 else if (attack_mode == ATTACK_MODE_BF)
17190 {
17191 local_free (css_buf);
17192 local_free (data.root_css_buf);
17193 local_free (data.markov_css_buf);
17194
17195 char *mask = dictfiles[dictpos];
17196
17197 logfile_sub_string (mask);
17198
17199 // base
17200
17201 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17202
17203 if (opts_type & OPTS_TYPE_PT_UNICODE)
17204 {
17205 uint css_cnt_unicode = css_cnt * 2;
17206
17207 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17208
17209 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17210 {
17211 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17212
17213 css_buf_unicode[j + 1].cs_buf[0] = 0;
17214 css_buf_unicode[j + 1].cs_len = 1;
17215 }
17216
17217 free (css_buf);
17218
17219 css_buf = css_buf_unicode;
17220 css_cnt = css_cnt_unicode;
17221 }
17222
17223 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17224
17225 uint mask_min = pw_min;
17226 uint mask_max = pw_max;
17227
17228 if (opts_type & OPTS_TYPE_PT_UNICODE)
17229 {
17230 mask_min *= 2;
17231 mask_max *= 2;
17232 }
17233
17234 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17235 {
17236 if (css_cnt < mask_min)
17237 {
17238 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17239 }
17240
17241 if (css_cnt > mask_max)
17242 {
17243 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17244 }
17245
17246 // skip to next mask
17247
17248 dictpos++;
17249
17250 rd->dictpos = dictpos;
17251
17252 logfile_sub_msg ("STOP");
17253
17254 continue;
17255 }
17256
17257 uint save_css_cnt = css_cnt;
17258
17259 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17260 {
17261 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17262 {
17263 uint salt_len = (uint) data.salts_buf[0].salt_len;
17264 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17265
17266 uint css_cnt_salt = css_cnt + salt_len;
17267
17268 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17269
17270 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17271
17272 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17273 {
17274 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17275 css_buf_salt[j].cs_len = 1;
17276 }
17277
17278 free (css_buf);
17279
17280 css_buf = css_buf_salt;
17281 css_cnt = css_cnt_salt;
17282 }
17283 }
17284
17285 data.mask = mask;
17286 data.css_cnt = css_cnt;
17287 data.css_buf = css_buf;
17288
17289 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17290
17291 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17292
17293 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17294
17295 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17296 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17297
17298 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17299
17300 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17301
17302 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17303 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17304
17305 data.root_css_buf = root_css_buf;
17306 data.markov_css_buf = markov_css_buf;
17307
17308 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17309
17310 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17311
17312 local_free (root_table_buf);
17313 local_free (markov_table_buf);
17314
17315 // copy + args
17316
17317 uint css_cnt_l = css_cnt;
17318 uint css_cnt_r;
17319
17320 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17321 {
17322 if (save_css_cnt < 6)
17323 {
17324 css_cnt_r = 1;
17325 }
17326 else if (save_css_cnt == 6)
17327 {
17328 css_cnt_r = 2;
17329 }
17330 else
17331 {
17332 if (opts_type & OPTS_TYPE_PT_UNICODE)
17333 {
17334 if (save_css_cnt == 8 || save_css_cnt == 10)
17335 {
17336 css_cnt_r = 2;
17337 }
17338 else
17339 {
17340 css_cnt_r = 4;
17341 }
17342 }
17343 else
17344 {
17345 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17346 {
17347 css_cnt_r = 3;
17348 }
17349 else
17350 {
17351 css_cnt_r = 4;
17352 }
17353 }
17354 }
17355 }
17356 else
17357 {
17358 css_cnt_r = 1;
17359
17360 /* unfinished code?
17361 int sum = css_buf[css_cnt_r - 1].cs_len;
17362
17363 for (uint i = 1; i < 4 && i < css_cnt; i++)
17364 {
17365 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17366
17367 css_cnt_r++;
17368
17369 sum *= css_buf[css_cnt_r - 1].cs_len;
17370 }
17371 */
17372 }
17373
17374 css_cnt_l -= css_cnt_r;
17375
17376 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17377
17378 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17379 {
17380 hc_device_param_t *device_param = &data.devices_param[device_id];
17381
17382 if (device_param->skipped) continue;
17383
17384 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17385 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17386 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17387
17388 device_param->kernel_params_mp_l_buf64[3] = 0;
17389 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17390 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17391 device_param->kernel_params_mp_l_buf32[6] = 0;
17392 device_param->kernel_params_mp_l_buf32[7] = 0;
17393 device_param->kernel_params_mp_l_buf32[8] = 0;
17394
17395 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17396 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17397 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17398 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17399
17400 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17401 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17402 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17403
17404 device_param->kernel_params_mp_r_buf64[3] = 0;
17405 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17406 device_param->kernel_params_mp_r_buf32[5] = 0;
17407 device_param->kernel_params_mp_r_buf32[6] = 0;
17408 device_param->kernel_params_mp_r_buf32[7] = 0;
17409
17410 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]);
17411 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]);
17412 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]);
17413
17414 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]);
17415 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]);
17416 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]);
17417
17418 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);
17419 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);
17420 }
17421 }
17422
17423 u64 words_base = data.words_cnt;
17424
17425 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17426 {
17427 if (data.kernel_rules_cnt)
17428 {
17429 words_base /= data.kernel_rules_cnt;
17430 }
17431 }
17432 else if (data.attack_kern == ATTACK_KERN_COMBI)
17433 {
17434 if (data.combs_cnt)
17435 {
17436 words_base /= data.combs_cnt;
17437 }
17438 }
17439 else if (data.attack_kern == ATTACK_KERN_BF)
17440 {
17441 if (data.bfs_cnt)
17442 {
17443 words_base /= data.bfs_cnt;
17444 }
17445 }
17446
17447 data.words_base = words_base;
17448
17449 if (keyspace == 1)
17450 {
17451 log_info ("%llu", (unsigned long long int) words_base);
17452
17453 return (0);
17454 }
17455
17456 if (data.words_cur > data.words_base)
17457 {
17458 log_error ("ERROR: restore value greater keyspace");
17459
17460 return (-1);
17461 }
17462
17463 if (data.words_cur)
17464 {
17465 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17466 {
17467 for (uint i = 0; i < data.salts_cnt; i++)
17468 {
17469 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17470 }
17471 }
17472 else if (data.attack_kern == ATTACK_KERN_COMBI)
17473 {
17474 for (uint i = 0; i < data.salts_cnt; i++)
17475 {
17476 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17477 }
17478 }
17479 else if (data.attack_kern == ATTACK_KERN_BF)
17480 {
17481 for (uint i = 0; i < data.salts_cnt; i++)
17482 {
17483 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17484 }
17485 }
17486 }
17487
17488 /*
17489 * Inform user about possible slow speeds
17490 */
17491
17492 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17493 {
17494 if (data.words_base < kernel_power_all)
17495 {
17496 if (quiet == 0)
17497 {
17498 log_info ("ATTENTION!");
17499 log_info (" The wordlist or mask you are using is too small.");
17500 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17501 log_info (" The cracking speed will drop.");
17502 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17503 log_info ("");
17504 }
17505 }
17506 }
17507
17508 /*
17509 * Update loopback file
17510 */
17511
17512 if (loopback == 1)
17513 {
17514 time_t now;
17515
17516 time (&now);
17517
17518 uint random_num = get_random_num (0, 9999);
17519
17520 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17521
17522 data.loopback_file = loopback_file;
17523 }
17524
17525 /*
17526 * Update dictionary statistic
17527 */
17528
17529 if (keyspace == 0)
17530 {
17531 dictstat_fp = fopen (dictstat, "wb");
17532
17533 if (dictstat_fp)
17534 {
17535 lock_file (dictstat_fp);
17536
17537 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17538
17539 fclose (dictstat_fp);
17540 }
17541 }
17542
17543 data.devices_status = STATUS_RUNNING;
17544
17545 if (initial_restore_done == 0)
17546 {
17547 if (data.restore_disable == 0) cycle_restore ();
17548
17549 initial_restore_done = 1;
17550 }
17551
17552 hc_timer_set (&data.timer_running);
17553
17554 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17555 {
17556 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17557 {
17558 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17559 if (quiet == 0) fflush (stdout);
17560 }
17561 }
17562 else if (wordlist_mode == WL_MODE_STDIN)
17563 {
17564 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17565 if (data.quiet == 0) log_info ("");
17566 }
17567
17568 time_t runtime_start;
17569
17570 time (&runtime_start);
17571
17572 data.runtime_start = runtime_start;
17573
17574 /**
17575 * create cracker threads
17576 */
17577
17578 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17579
17580 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17581 {
17582 hc_device_param_t *device_param = &devices_param[device_id];
17583
17584 if (wordlist_mode == WL_MODE_STDIN)
17585 {
17586 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17587 }
17588 else
17589 {
17590 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17591 }
17592 }
17593
17594 // wait for crack threads to exit
17595
17596 hc_thread_wait (data.devices_cnt, c_threads);
17597
17598 local_free (c_threads);
17599
17600 data.restore = 0;
17601
17602 // finalize task
17603
17604 logfile_sub_var_uint ("status-after-work", data.devices_status);
17605
17606 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17607
17608 if (data.devices_status == STATUS_CRACKED) break;
17609 if (data.devices_status == STATUS_ABORTED) break;
17610
17611 if (data.devices_status == STATUS_BYPASS)
17612 {
17613 data.devices_status = STATUS_RUNNING;
17614 }
17615
17616 if (induction_dictionaries_cnt)
17617 {
17618 unlink (induction_dictionaries[0]);
17619 }
17620
17621 free (induction_dictionaries);
17622
17623 if (attack_mode != ATTACK_MODE_BF)
17624 {
17625 induction_dictionaries = scan_directory (induction_directory);
17626
17627 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17628 }
17629
17630 if (benchmark == 0)
17631 {
17632 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17633 {
17634 if (quiet == 0) clear_prompt ();
17635
17636 if (quiet == 0) log_info ("");
17637
17638 if (status == 1)
17639 {
17640 status_display ();
17641 }
17642 else
17643 {
17644 if (quiet == 0) status_display ();
17645 }
17646
17647 if (quiet == 0) log_info ("");
17648 }
17649 }
17650
17651 if (attack_mode == ATTACK_MODE_BF)
17652 {
17653 dictpos++;
17654
17655 rd->dictpos = dictpos;
17656 }
17657 else
17658 {
17659 if (induction_dictionaries_cnt)
17660 {
17661 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17662 }
17663 else
17664 {
17665 dictpos++;
17666
17667 rd->dictpos = dictpos;
17668 }
17669 }
17670
17671 time_t runtime_stop;
17672
17673 time (&runtime_stop);
17674
17675 data.runtime_stop = runtime_stop;
17676
17677 logfile_sub_uint (runtime_start);
17678 logfile_sub_uint (runtime_stop);
17679
17680 logfile_sub_msg ("STOP");
17681
17682 global_free (subid);
17683 }
17684
17685 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17686
17687 if (data.devices_status == STATUS_CRACKED) break;
17688 if (data.devices_status == STATUS_ABORTED) break;
17689 if (data.devices_status == STATUS_QUIT) break;
17690
17691 if (data.devices_status == STATUS_BYPASS)
17692 {
17693 data.devices_status = STATUS_RUNNING;
17694 }
17695 }
17696
17697 // 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
17698
17699 if (attack_mode == ATTACK_MODE_STRAIGHT)
17700 {
17701 if (data.wordlist_mode == WL_MODE_FILE)
17702 {
17703 if (data.dictfile == NULL)
17704 {
17705 if (dictfiles != NULL)
17706 {
17707 data.dictfile = dictfiles[0];
17708
17709 hc_timer_set (&data.timer_running);
17710 }
17711 }
17712 }
17713 }
17714 // NOTE: combi is okay because it is already set beforehand
17715 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17716 {
17717 if (data.dictfile == NULL)
17718 {
17719 if (dictfiles != NULL)
17720 {
17721 hc_timer_set (&data.timer_running);
17722
17723 data.dictfile = dictfiles[0];
17724 }
17725 }
17726 }
17727 else if (attack_mode == ATTACK_MODE_BF)
17728 {
17729 if (data.mask == NULL)
17730 {
17731 hc_timer_set (&data.timer_running);
17732
17733 data.mask = masks[0];
17734 }
17735 }
17736
17737 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17738 {
17739 data.devices_status = STATUS_EXHAUSTED;
17740 }
17741
17742 // if cracked / aborted remove last induction dictionary
17743
17744 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17745 {
17746 struct stat induct_stat;
17747
17748 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17749 {
17750 unlink (induction_dictionaries[file_pos]);
17751 }
17752 }
17753
17754 // wait for non-interactive threads
17755
17756 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17757 {
17758 hc_thread_wait (1, &ni_threads[thread_idx]);
17759 }
17760
17761 local_free (ni_threads);
17762
17763 // wait for interactive threads
17764
17765 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17766 {
17767 hc_thread_wait (1, &i_thread);
17768 }
17769
17770 // we dont need restore file anymore
17771 if (data.restore_disable == 0)
17772 {
17773 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17774 {
17775 unlink (eff_restore_file);
17776 unlink (new_restore_file);
17777 }
17778 else
17779 {
17780 cycle_restore ();
17781 }
17782 }
17783
17784 // finally save left hashes
17785
17786 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17787 {
17788 save_hash ();
17789 }
17790
17791 /**
17792 * Clean up
17793 */
17794
17795 if (benchmark == 1)
17796 {
17797 status_benchmark ();
17798
17799 if (machine_readable == 0)
17800 {
17801 log_info ("");
17802 }
17803 }
17804 else
17805 {
17806 if (quiet == 0) clear_prompt ();
17807
17808 if (quiet == 0) log_info ("");
17809
17810 if (status == 1)
17811 {
17812 status_display ();
17813 }
17814 else
17815 {
17816 if (quiet == 0) status_display ();
17817 }
17818
17819 if (quiet == 0) log_info ("");
17820 }
17821
17822 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17823 {
17824 hc_device_param_t *device_param = &data.devices_param[device_id];
17825
17826 if (device_param->skipped) continue;
17827
17828 local_free (device_param->combs_buf);
17829
17830 local_free (device_param->hooks_buf);
17831
17832 local_free (device_param->device_name);
17833
17834 local_free (device_param->device_name_chksum);
17835
17836 local_free (device_param->device_version);
17837
17838 local_free (device_param->driver_version);
17839
17840 if (device_param->pws_buf) myfree (device_param->pws_buf);
17841 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17842 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17843 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17844 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17845 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17846 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17847 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17848 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17849 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17850 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17851 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17852 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17853 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17854 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17855 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17856 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17857 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17858 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17859 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17860 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17861 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17862 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17863 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17864 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17865 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17866 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17867 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17868 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17869
17870 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17871 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17872 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17873 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17874 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17875 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17876 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17877 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17878 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17879 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17880 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17881
17882 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17883 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17884 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17885
17886 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17887 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17888 }
17889
17890 // reset default fan speed
17891
17892 #ifdef HAVE_HWMON
17893 if (gpu_temp_disable == 0)
17894 {
17895 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17896 {
17897 hc_thread_mutex_lock (mux_adl);
17898
17899 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17900 {
17901 hc_device_param_t *device_param = &data.devices_param[device_id];
17902
17903 if (device_param->skipped) continue;
17904
17905 if (data.hm_device[device_id].fan_set_supported == 1)
17906 {
17907 int fanspeed = temp_retain_fanspeed_value[device_id];
17908 int fanpolicy = temp_retain_fanpolicy_value[device_id];
17909
17910 if (fanpolicy == 1)
17911 {
17912 int rc = -1;
17913
17914 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17915 {
17916 rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 0);
17917 }
17918 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17919 {
17920 #ifdef _WIN
17921 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 16);
17922 #endif
17923 }
17924
17925 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
17926 }
17927 }
17928 }
17929
17930 hc_thread_mutex_unlock (mux_adl);
17931 }
17932 }
17933
17934 // reset power tuning
17935
17936 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17937 {
17938 hc_thread_mutex_lock (mux_adl);
17939
17940 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17941 {
17942 hc_device_param_t *device_param = &data.devices_param[device_id];
17943
17944 if (device_param->skipped) continue;
17945
17946 if (data.hm_device[device_id].od_version == 6)
17947 {
17948 // check powertune capabilities first, if not available then skip device
17949
17950 int powertune_supported = 0;
17951
17952 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17953 {
17954 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17955
17956 return (-1);
17957 }
17958
17959 if (powertune_supported != 0)
17960 {
17961 // powercontrol settings
17962
17963 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)
17964 {
17965 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17966
17967 return (-1);
17968 }
17969
17970 // clocks
17971
17972 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17973
17974 performance_state->iNumberOfPerformanceLevels = 2;
17975
17976 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17977 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17978 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17979 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17980
17981 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)
17982 {
17983 log_info ("ERROR: Failed to restore ADL performance state");
17984
17985 return (-1);
17986 }
17987
17988 local_free (performance_state);
17989 }
17990 }
17991 }
17992
17993 hc_thread_mutex_unlock (mux_adl);
17994 }
17995
17996 if (gpu_temp_disable == 0)
17997 {
17998 if (data.hm_nv)
17999 {
18000 #if defined(LINUX)
18001
18002 hm_NVML_nvmlShutdown (data.hm_nv);
18003
18004 nvml_close (data.hm_nv);
18005
18006 #elif defined(WIN)
18007
18008 hm_NvAPI_Unload (data.hm_nv);
18009
18010 nvapi_close (data.hm_nv);
18011
18012 #endif
18013
18014 data.hm_nv = NULL;
18015 }
18016
18017 if (data.hm_amd)
18018 {
18019 hm_ADL_Main_Control_Destroy (data.hm_amd);
18020
18021 adl_close (data.hm_amd);
18022
18023 data.hm_amd = NULL;
18024 }
18025 }
18026 #endif // HAVE_HWMON
18027
18028 // free memory
18029
18030 local_free (masks);
18031
18032 local_free (dictstat_base);
18033
18034 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18035 {
18036 pot_t *pot_ptr = &pot[pot_pos];
18037
18038 hash_t *hash = &pot_ptr->hash;
18039
18040 local_free (hash->digest);
18041
18042 if (isSalted)
18043 {
18044 local_free (hash->salt);
18045 }
18046 }
18047
18048 local_free (pot);
18049
18050 local_free (all_kernel_rules_cnt);
18051 local_free (all_kernel_rules_buf);
18052
18053 local_free (wl_data->buf);
18054 local_free (wl_data);
18055
18056 local_free (bitmap_s1_a);
18057 local_free (bitmap_s1_b);
18058 local_free (bitmap_s1_c);
18059 local_free (bitmap_s1_d);
18060 local_free (bitmap_s2_a);
18061 local_free (bitmap_s2_b);
18062 local_free (bitmap_s2_c);
18063 local_free (bitmap_s2_d);
18064
18065 #ifdef HAVE_HWMON
18066 local_free (temp_retain_fanspeed_value);
18067 local_free (od_clock_mem_status);
18068 local_free (od_power_control_status);
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