projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Add NVML support for PCIE Lanes
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define MACHINE_READABLE 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 70
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "- [ Options ] -",
353 "",
354 " Options Short / Long | Type | Description | Example",
355 "===============================|======|======================================================|=======================",
356 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
357 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
358 " -V, --version | | Print version |",
359 " -h, --help | | Print help |",
360 " --quiet | | Suppress output |",
361 " --hex-charset | | Assume charset is given in hex |",
362 " --hex-salt | | Assume salt is given in hex |",
363 " --hex-wordlist | | Assume words in wordlist is given in hex |",
364 " --force | | Ignore warnings |",
365 " --status | | Enable automatic update of the status-screen |",
366 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
367 " --machine-readable | | Display the status view in a machine readable format |",
368 " --loopback | | Add new plains to induct directory |",
369 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
370 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
371 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
372 " --markov-classic | | Enables classic markov-chains, no per-position |",
373 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
374 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
375 " --session | Str | Define specific session name | --session=mysession",
376 " --restore | | Restore session from --session |",
377 " --restore-disable | | Do not write restore file |",
378 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
379 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
380 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
381 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
382 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
383 " --show | | Show cracked passwords only |",
384 " --left | | Show un-cracked passwords only |",
385 " --username | | Enable ignoring of usernames in hashfile |",
386 " --remove | | Enable remove of hash once it is cracked |",
387 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
388 " --potfile-disable | | Do not write potfile |",
389 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
390 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
391 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
392 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
393 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
394 " --logfile-disable | | Disable the logfile |",
395 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
396 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
397 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
398 " -b, --benchmark | | Run benchmark |",
399 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
400 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
401 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
402 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
403 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
404 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
405 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
406 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
407 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
408 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
409 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
410 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
411 #ifdef HAVE_HWMON
412 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
413 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
414 #ifdef HAVE_ADL
415 " --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) |",
416 #endif
417 #endif
418 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
419 " -s, --skip | Num | Skip X words from the start | -s 1000000",
420 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
421 " --keyspace | | Show keyspace base:mod values and quit |",
422 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
423 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
424 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
425 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
426 " --generate-rules-func-min | Num | Force min X funcs per rule |",
427 " --generate-rules-func-max | Num | Force max X funcs per rule |",
428 " --generate-rules-seed | Num | Force RNG seed set to X |",
429 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
430 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
431 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
432 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
433 " -i, --increment | | Enable mask increment mode |",
434 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
435 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
436 "",
437 "- [ Hash modes ] -",
438 "",
439 " # | Name | Category",
440 " ======+==================================================+======================================",
441 " 900 | MD4 | Raw Hash",
442 " 0 | MD5 | Raw Hash",
443 " 5100 | Half MD5 | Raw Hash",
444 " 100 | SHA1 | Raw Hash",
445 " 10800 | SHA-384 | Raw Hash",
446 " 1400 | SHA-256 | Raw Hash",
447 " 1700 | SHA-512 | Raw Hash",
448 " 5000 | SHA-3(Keccak) | Raw Hash",
449 " 10100 | SipHash | Raw Hash",
450 " 6000 | RipeMD160 | Raw Hash",
451 " 6100 | Whirlpool | Raw Hash",
452 " 6900 | GOST R 34.11-94 | Raw Hash",
453 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
454 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
455 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
456 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
457 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
458 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
459 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
460 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
461 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
462 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
463 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
464 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
465 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
466 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
467 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
468 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
469 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
470 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
471 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
472 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
473 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
474 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
475 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
476 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
477 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
478 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
479 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
480 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
481 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
482 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
483 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
484 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
485 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
486 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
487 " 400 | phpass | Generic KDF",
488 " 8900 | scrypt | Generic KDF",
489 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
490 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
491 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
492 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
493 " 23 | Skype | Network protocols",
494 " 2500 | WPA/WPA2 | Network protocols",
495 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
496 " 5300 | IKE-PSK MD5 | Network protocols",
497 " 5400 | IKE-PSK SHA1 | Network protocols",
498 " 5500 | NetNTLMv1 | Network protocols",
499 " 5500 | NetNTLMv1 + ESS | Network protocols",
500 " 5600 | NetNTLMv2 | Network protocols",
501 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
502 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
503 " 8300 | DNSSEC (NSEC3) | Network protocols",
504 " 10200 | Cram MD5 | Network protocols",
505 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
506 " 11200 | MySQL CRAM (SHA1) | Network protocols",
507 " 11400 | SIP digest authentication (MD5) | Network protocols",
508 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
509 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
510 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
511 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
512 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
513 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
514 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
515 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
516 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
517 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
518 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
519 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
520 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
521 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
522 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
523 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
524 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
525 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
526 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
527 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
528 " 12 | PostgreSQL | Database Server",
529 " 131 | MSSQL(2000) | Database Server",
530 " 132 | MSSQL(2005) | Database Server",
531 " 1731 | MSSQL(2012) | Database Server",
532 " 1731 | MSSQL(2014) | Database Server",
533 " 200 | MySQL323 | Database Server",
534 " 300 | MySQL4.1/MySQL5 | Database Server",
535 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
536 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
537 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
538 " 8000 | Sybase ASE | Database Server",
539 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
540 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
541 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
542 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
543 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
544 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
545 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
546 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
547 " 11500 | CRC32 | Checksums",
548 " 3000 | LM | Operating-Systems",
549 " 1000 | NTLM | Operating-Systems",
550 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
551 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
552 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
553 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
554 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
555 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
556 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
557 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
558 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
559 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
560 " 1722 | OSX v10.7 | Operating-Systems",
561 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
562 " 6300 | AIX {smd5} | Operating-Systems",
563 " 6700 | AIX {ssha1} | Operating-Systems",
564 " 6400 | AIX {ssha256} | Operating-Systems",
565 " 6500 | AIX {ssha512} | Operating-Systems",
566 " 2400 | Cisco-PIX | Operating-Systems",
567 " 2410 | Cisco-ASA | Operating-Systems",
568 " 500 | Cisco-IOS $1$ | Operating-Systems",
569 " 5700 | Cisco-IOS $4$ | Operating-Systems",
570 " 9200 | Cisco-IOS $8$ | Operating-Systems",
571 " 9300 | Cisco-IOS $9$ | Operating-Systems",
572 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
573 " 501 | Juniper IVE | Operating-Systems",
574 " 5800 | Android PIN | Operating-Systems",
575 " 8100 | Citrix Netscaler | Operating-Systems",
576 " 8500 | RACF | Operating-Systems",
577 " 7200 | GRUB 2 | Operating-Systems",
578 " 9900 | Radmin2 | Operating-Systems",
579 " 125 | ArubaOS | Operating-Systems",
580 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
581 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
582 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
583 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
584 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
585 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
586 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
587 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
588 " 11600 | 7-Zip | Archives",
589 " 12500 | RAR3-hp | Archives",
590 " 13000 | RAR5 | Archives",
591 " 13200 | AxCrypt | Archives",
592 " 13300 | AxCrypt in memory SHA1 | Archives",
593 " 13600 | WinZip | Archives",
594 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
595 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
596 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
597 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
598 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
599 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
600 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
601 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
602 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
603 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
604 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
605 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
606 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
607 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
608 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
609 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
610 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
611 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
612 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
613 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
614 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
615 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
616 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
617 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
618 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
619 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
620 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
621 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
622 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
623 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
624 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
625 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
626 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
627 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
628 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
629 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
630 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
631 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
632 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
633 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
634 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
635 " 9400 | MS Office 2007 | Documents",
636 " 9500 | MS Office 2010 | Documents",
637 " 9600 | MS Office 2013 | Documents",
638 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
639 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
640 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
641 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
642 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
643 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
644 " 9000 | Password Safe v2 | Password Managers",
645 " 5200 | Password Safe v3 | Password Managers",
646 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
647 " 6600 | 1Password, agilekeychain | Password Managers",
648 " 8200 | 1Password, cloudkeychain | Password Managers",
649 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
650 " 12700 | Blockchain, My Wallet | Password Managers",
651 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
652 "",
653 "- [ Outfile Formats ] -",
654 "",
655 " # | Format",
656 " ===+========",
657 " 1 | hash[:salt]",
658 " 2 | plain",
659 " 3 | hash[:salt]:plain",
660 " 4 | hex_plain",
661 " 5 | hash[:salt]:hex_plain",
662 " 6 | plain:hex_plain",
663 " 7 | hash[:salt]:plain:hex_plain",
664 " 8 | crackpos",
665 " 9 | hash[:salt]:crack_pos",
666 " 10 | plain:crack_pos",
667 " 11 | hash[:salt]:plain:crack_pos",
668 " 12 | hex_plain:crack_pos",
669 " 13 | hash[:salt]:hex_plain:crack_pos",
670 " 14 | plain:hex_plain:crack_pos",
671 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
672 "",
673 "- [ Rule Debugging Modes ] -",
674 "",
675 " # | Format",
676 " ===+========",
677 " 1 | Finding-Rule",
678 " 2 | Original-Word",
679 " 3 | Original-Word:Finding-Rule",
680 " 4 | Original-Word:Finding-Rule:Processed-Word",
681 "",
682 "- [ Attack Modes ] -",
683 "",
684 " # | Mode",
685 " ===+======",
686 " 0 | Straight",
687 " 1 | Combination",
688 " 3 | Brute-force",
689 " 6 | Hybrid Wordlist + Mask",
690 " 7 | Hybrid Mask + Wordlist",
691 "",
692 "- [ Built-in Charsets ] -",
693 "",
694 " ? | Charset",
695 " ===+=========",
696 " l | abcdefghijklmnopqrstuvwxyz",
697 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
698 " d | 0123456789",
699 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
700 " a | ?l?u?d?s",
701 " b | 0x00 - 0xff",
702 "",
703 "- [ OpenCL Device Types ] -",
704 "",
705 " # | Device Type",
706 " ===+=============",
707 " 1 | CPU",
708 " 2 | GPU",
709 " 3 | FPGA, DSP, Co-Processor",
710 "",
711 "- [ Workload Profiles ] -",
712 "",
713 " # | Performance | Runtime | Power Consumption | Desktop Impact",
714 " ===+=============+=========+===================+=================",
715 " 1 | Low | 2 ms | Low | Minimal",
716 " 2 | Default | 12 ms | Economic | Noticeable",
717 " 3 | High | 96 ms | High | Unresponsive",
718 " 4 | Nightmare | 480 ms | Insane | Headless",
719 "",
720 "If you have no idea what just happened then visit the following pages:",
721 "",
722 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
723 "* https://hashcat.net/wiki/#frequently_asked_questions",
724 "",
725 NULL
726 };
727
728 /**
729 * hashcat specific functions
730 */
731
732 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
733 {
734 int exec_pos = (int) device_param->exec_pos - last_num_entries;
735
736 if (exec_pos < 0) exec_pos += EXEC_CACHE;
737
738 double exec_ms_sum = 0;
739
740 int exec_ms_cnt = 0;
741
742 for (int i = 0; i < last_num_entries; i++)
743 {
744 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
745
746 if (exec_ms)
747 {
748 exec_ms_sum += exec_ms;
749
750 exec_ms_cnt++;
751 }
752 }
753
754 if (exec_ms_cnt == 0) return 0;
755
756 return exec_ms_sum / exec_ms_cnt;
757 }
758
759 void status_display_machine_readable ()
760 {
761 FILE *out = stdout;
762
763 fprintf (out, "STATUS\t%u\t", data.devices_status);
764
765 /**
766 * speed new
767 */
768
769 fprintf (out, "SPEED\t");
770
771 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
772 {
773 hc_device_param_t *device_param = &data.devices_param[device_id];
774
775 if (device_param->skipped) continue;
776
777 u64 speed_cnt = 0;
778 double speed_ms = 0;
779
780 for (int i = 0; i < SPEED_CACHE; i++)
781 {
782 speed_cnt += device_param->speed_cnt[i];
783 speed_ms += device_param->speed_ms[i];
784 }
785
786 speed_cnt /= SPEED_CACHE;
787 speed_ms /= SPEED_CACHE;
788
789 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
790 }
791
792 /**
793 * exec time
794 */
795
796 fprintf (out, "EXEC_RUNTIME\t");
797
798 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
799 {
800 hc_device_param_t *device_param = &data.devices_param[device_id];
801
802 if (device_param->skipped) continue;
803
804 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
805
806 fprintf (out, "%f\t", exec_ms_avg);
807 }
808
809 /**
810 * words_cur
811 */
812
813 u64 words_cur = get_lowest_words_done ();
814
815 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
816
817 /**
818 * counter
819 */
820
821 u64 progress_total = data.words_cnt * data.salts_cnt;
822
823 u64 all_done = 0;
824 u64 all_rejected = 0;
825 u64 all_restored = 0;
826
827 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
828 {
829 all_done += data.words_progress_done[salt_pos];
830 all_rejected += data.words_progress_rejected[salt_pos];
831 all_restored += data.words_progress_restored[salt_pos];
832 }
833
834 u64 progress_cur = all_restored + all_done + all_rejected;
835 u64 progress_end = progress_total;
836
837 u64 progress_skip = 0;
838
839 if (data.skip)
840 {
841 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
842
843 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
844 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
845 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
846 }
847
848 if (data.limit)
849 {
850 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
851
852 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
853 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
854 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
855 }
856
857 u64 progress_cur_relative_skip = progress_cur - progress_skip;
858 u64 progress_end_relative_skip = progress_end - progress_skip;
859
860 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
861
862 /**
863 * cracks
864 */
865
866 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
867 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
868
869 /**
870 * temperature
871 */
872
873 #ifdef HAVE_HWMON
874 if (data.gpu_temp_disable == 0)
875 {
876 fprintf (out, "TEMP\t");
877
878 hc_thread_mutex_lock (mux_adl);
879
880 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
881 {
882 hc_device_param_t *device_param = &data.devices_param[device_id];
883
884 if (device_param->skipped) continue;
885
886 int temp = hm_get_temperature_with_device_id (device_id);
887
888 fprintf (out, "%d\t", temp);
889 }
890
891 hc_thread_mutex_unlock (mux_adl);
892 }
893 #endif // HAVE_HWMON
894
895 /**
896 * flush
897 */
898
899 #ifdef _WIN
900 fputc ('\r', out);
901 fputc ('\n', out);
902 #endif
903
904 #ifdef _POSIX
905 fputc ('\n', out);
906 #endif
907
908 fflush (out);
909 }
910
911 void status_display ()
912 {
913 if (data.devices_status == STATUS_INIT) return;
914 if (data.devices_status == STATUS_STARTING) return;
915 if (data.devices_status == STATUS_BYPASS) return;
916
917 if (data.machine_readable == 1)
918 {
919 status_display_machine_readable ();
920
921 return;
922 }
923
924 char tmp_buf[1000] = { 0 };
925
926 uint tmp_len = 0;
927
928 log_info ("Session.Name...: %s", data.session);
929
930 char *status_type = strstatus (data.devices_status);
931
932 uint hash_mode = data.hash_mode;
933
934 char *hash_type = strhashtype (hash_mode); // not a bug
935
936 log_info ("Status.........: %s", status_type);
937
938 /**
939 * show rules
940 */
941
942 if (data.rp_files_cnt)
943 {
944 uint i;
945
946 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
947 {
948 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
949 }
950
951 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
952
953 log_info ("Rules.Type.....: %s", tmp_buf);
954
955 tmp_len = 0;
956 }
957
958 if (data.rp_gen)
959 {
960 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
961
962 if (data.rp_gen_seed)
963 {
964 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
965 }
966 }
967
968 /**
969 * show input
970 */
971
972 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
973 {
974 if (data.wordlist_mode == WL_MODE_FILE)
975 {
976 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
977 }
978 else if (data.wordlist_mode == WL_MODE_STDIN)
979 {
980 log_info ("Input.Mode.....: Pipe");
981 }
982 }
983 else if (data.attack_mode == ATTACK_MODE_COMBI)
984 {
985 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
986 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
987 }
988 else if (data.attack_mode == ATTACK_MODE_BF)
989 {
990 char *mask = data.mask;
991
992 if (mask != NULL)
993 {
994 uint mask_len = data.css_cnt;
995
996 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
997
998 if (mask_len > 0)
999 {
1000 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1001 {
1002 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1003 {
1004 mask_len -= data.salts_buf[0].salt_len;
1005 }
1006 }
1007
1008 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1009
1010 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1011 }
1012
1013 if (data.maskcnt > 1)
1014 {
1015 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1016
1017 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1018 }
1019
1020 log_info ("Input.Mode.....: %s", tmp_buf);
1021 }
1022
1023 tmp_len = 0;
1024 }
1025 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1026 {
1027 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1028 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1029 }
1030 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1031 {
1032 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1033 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1034 }
1035
1036 if (data.digests_cnt == 1)
1037 {
1038 if (data.hash_mode == 2500)
1039 {
1040 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1041
1042 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1043 (char *) data.salts_buf[0].salt_buf,
1044 wpa->orig_mac1[0],
1045 wpa->orig_mac1[1],
1046 wpa->orig_mac1[2],
1047 wpa->orig_mac1[3],
1048 wpa->orig_mac1[4],
1049 wpa->orig_mac1[5],
1050 wpa->orig_mac2[0],
1051 wpa->orig_mac2[1],
1052 wpa->orig_mac2[2],
1053 wpa->orig_mac2[3],
1054 wpa->orig_mac2[4],
1055 wpa->orig_mac2[5]);
1056 }
1057 else if (data.hash_mode == 5200)
1058 {
1059 log_info ("Hash.Target....: File (%s)", data.hashfile);
1060 }
1061 else if (data.hash_mode == 9000)
1062 {
1063 log_info ("Hash.Target....: File (%s)", data.hashfile);
1064 }
1065 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1066 {
1067 log_info ("Hash.Target....: File (%s)", data.hashfile);
1068 }
1069 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1070 {
1071 log_info ("Hash.Target....: File (%s)", data.hashfile);
1072 }
1073 else
1074 {
1075 char out_buf[HCBUFSIZ] = { 0 };
1076
1077 ascii_digest (out_buf, 0, 0);
1078
1079 // limit length
1080 if (strlen (out_buf) > 40)
1081 {
1082 out_buf[41] = '.';
1083 out_buf[42] = '.';
1084 out_buf[43] = '.';
1085 out_buf[44] = 0;
1086 }
1087
1088 log_info ("Hash.Target....: %s", out_buf);
1089 }
1090 }
1091 else
1092 {
1093 if (data.hash_mode == 3000)
1094 {
1095 char out_buf1[32] = { 0 };
1096 char out_buf2[32] = { 0 };
1097
1098 ascii_digest (out_buf1, 0, 0);
1099 ascii_digest (out_buf2, 0, 1);
1100
1101 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1102 }
1103 else
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 }
1108
1109 log_info ("Hash.Type......: %s", hash_type);
1110
1111 /**
1112 * speed new
1113 */
1114
1115 u64 speed_cnt[DEVICES_MAX] = { 0 };
1116 double speed_ms[DEVICES_MAX] = { 0 };
1117
1118 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1119 {
1120 hc_device_param_t *device_param = &data.devices_param[device_id];
1121
1122 if (device_param->skipped) continue;
1123
1124 speed_cnt[device_id] = 0;
1125 speed_ms[device_id] = 0;
1126
1127 for (int i = 0; i < SPEED_CACHE; i++)
1128 {
1129 speed_cnt[device_id] += device_param->speed_cnt[i];
1130 speed_ms[device_id] += device_param->speed_ms[i];
1131 }
1132
1133 speed_cnt[device_id] /= SPEED_CACHE;
1134 speed_ms[device_id] /= SPEED_CACHE;
1135 }
1136
1137 double hashes_all_ms = 0;
1138
1139 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1140
1141 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1142 {
1143 hc_device_param_t *device_param = &data.devices_param[device_id];
1144
1145 if (device_param->skipped) continue;
1146
1147 hashes_dev_ms[device_id] = 0;
1148
1149 if (speed_ms[device_id])
1150 {
1151 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1152
1153 hashes_all_ms += hashes_dev_ms[device_id];
1154 }
1155 }
1156
1157 /**
1158 * exec time
1159 */
1160
1161 double exec_all_ms[DEVICES_MAX] = { 0 };
1162
1163 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1164 {
1165 hc_device_param_t *device_param = &data.devices_param[device_id];
1166
1167 if (device_param->skipped) continue;
1168
1169 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1170
1171 exec_all_ms[device_id] = exec_ms_avg;
1172 }
1173
1174 /**
1175 * timers
1176 */
1177
1178 double ms_running = 0;
1179
1180 hc_timer_get (data.timer_running, ms_running);
1181
1182 double ms_paused = data.ms_paused;
1183
1184 if (data.devices_status == STATUS_PAUSED)
1185 {
1186 double ms_paused_tmp = 0;
1187
1188 hc_timer_get (data.timer_paused, ms_paused_tmp);
1189
1190 ms_paused += ms_paused_tmp;
1191 }
1192
1193 #ifdef WIN
1194
1195 __time64_t sec_run = ms_running / 1000;
1196
1197 #else
1198
1199 time_t sec_run = ms_running / 1000;
1200
1201 #endif
1202
1203 if (sec_run)
1204 {
1205 char display_run[32] = { 0 };
1206
1207 struct tm tm_run;
1208
1209 struct tm *tmp = NULL;
1210
1211 #ifdef WIN
1212
1213 tmp = _gmtime64 (&sec_run);
1214
1215 #else
1216
1217 tmp = gmtime (&sec_run);
1218
1219 #endif
1220
1221 if (tmp != NULL)
1222 {
1223 memset (&tm_run, 0, sizeof (tm_run));
1224
1225 memcpy (&tm_run, tmp, sizeof (tm_run));
1226
1227 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1228
1229 char *start = ctime (&data.proc_start);
1230
1231 size_t start_len = strlen (start);
1232
1233 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1234 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1235
1236 log_info ("Time.Started...: %s (%s)", start, display_run);
1237 }
1238 }
1239 else
1240 {
1241 log_info ("Time.Started...: 0 secs");
1242 }
1243
1244 /**
1245 * counters
1246 */
1247
1248 u64 progress_total = data.words_cnt * data.salts_cnt;
1249
1250 u64 all_done = 0;
1251 u64 all_rejected = 0;
1252 u64 all_restored = 0;
1253
1254 u64 progress_noneed = 0;
1255
1256 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1257 {
1258 all_done += data.words_progress_done[salt_pos];
1259 all_rejected += data.words_progress_rejected[salt_pos];
1260 all_restored += data.words_progress_restored[salt_pos];
1261
1262 // Important for ETA only
1263
1264 if (data.salts_shown[salt_pos] == 1)
1265 {
1266 const u64 all = data.words_progress_done[salt_pos]
1267 + data.words_progress_rejected[salt_pos]
1268 + data.words_progress_restored[salt_pos];
1269
1270 const u64 left = data.words_cnt - all;
1271
1272 progress_noneed += left;
1273 }
1274 }
1275
1276 u64 progress_cur = all_restored + all_done + all_rejected;
1277 u64 progress_end = progress_total;
1278
1279 u64 progress_skip = 0;
1280
1281 if (data.skip)
1282 {
1283 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1284
1285 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1286 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1287 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1288 }
1289
1290 if (data.limit)
1291 {
1292 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1293
1294 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1295 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1296 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1297 }
1298
1299 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1300 u64 progress_end_relative_skip = progress_end - progress_skip;
1301
1302 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1303 {
1304 if (data.devices_status != STATUS_CRACKED)
1305 {
1306 #ifdef WIN
1307 __time64_t sec_etc = 0;
1308 #else
1309 time_t sec_etc = 0;
1310 #endif
1311
1312 if (hashes_all_ms)
1313 {
1314 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1315
1316 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1317
1318 sec_etc = ms_left / 1000;
1319 }
1320
1321 if (sec_etc == 0)
1322 {
1323 //log_info ("Time.Estimated.: 0 secs");
1324 }
1325 else if ((u64) sec_etc > ETC_MAX)
1326 {
1327 log_info ("Time.Estimated.: > 10 Years");
1328 }
1329 else
1330 {
1331 char display_etc[32] = { 0 };
1332
1333 struct tm tm_etc;
1334
1335 struct tm *tmp = NULL;
1336
1337 #ifdef WIN
1338
1339 tmp = _gmtime64 (&sec_etc);
1340
1341 #else
1342
1343 tmp = gmtime (&sec_etc);
1344
1345 #endif
1346
1347 if (tmp != NULL)
1348 {
1349 memset (&tm_etc, 0, sizeof (tm_etc));
1350
1351 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1352
1353 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1354
1355 time_t now;
1356
1357 time (&now);
1358
1359 now += sec_etc;
1360
1361 char *etc = ctime (&now);
1362
1363 size_t etc_len = strlen (etc);
1364
1365 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1366 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1367
1368 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1369 }
1370 }
1371 }
1372 }
1373
1374 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1375 {
1376 hc_device_param_t *device_param = &data.devices_param[device_id];
1377
1378 if (device_param->skipped) continue;
1379
1380 char display_dev_cur[16] = { 0 };
1381
1382 strncpy (display_dev_cur, "0.00", 4);
1383
1384 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1385
1386 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1387 }
1388
1389 char display_all_cur[16] = { 0 };
1390
1391 strncpy (display_all_cur, "0.00", 4);
1392
1393 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1394
1395 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1396
1397 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1398 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1399
1400 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1401
1402 // crack-per-time
1403
1404 if (data.digests_cnt > 100)
1405 {
1406 time_t now = time (NULL);
1407
1408 int cpt_cur_min = 0;
1409 int cpt_cur_hour = 0;
1410 int cpt_cur_day = 0;
1411
1412 for (int i = 0; i < CPT_BUF; i++)
1413 {
1414 const uint cracked = data.cpt_buf[i].cracked;
1415 const time_t timestamp = data.cpt_buf[i].timestamp;
1416
1417 if ((timestamp + 60) > now)
1418 {
1419 cpt_cur_min += cracked;
1420 }
1421
1422 if ((timestamp + 3600) > now)
1423 {
1424 cpt_cur_hour += cracked;
1425 }
1426
1427 if ((timestamp + 86400) > now)
1428 {
1429 cpt_cur_day += cracked;
1430 }
1431 }
1432
1433 double ms_real = ms_running - ms_paused;
1434
1435 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1436 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1437 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1438
1439 if ((data.cpt_start + 86400) < now)
1440 {
1441 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1442 cpt_cur_min,
1443 cpt_cur_hour,
1444 cpt_cur_day,
1445 cpt_avg_min,
1446 cpt_avg_hour,
1447 cpt_avg_day);
1448 }
1449 else if ((data.cpt_start + 3600) < now)
1450 {
1451 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1452 cpt_cur_min,
1453 cpt_cur_hour,
1454 cpt_avg_min,
1455 cpt_avg_hour,
1456 cpt_avg_day);
1457 }
1458 else if ((data.cpt_start + 60) < now)
1459 {
1460 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1461 cpt_cur_min,
1462 cpt_avg_min,
1463 cpt_avg_hour,
1464 cpt_avg_day);
1465 }
1466 else
1467 {
1468 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1469 cpt_avg_min,
1470 cpt_avg_hour,
1471 cpt_avg_day);
1472 }
1473 }
1474
1475 // Restore point
1476
1477 u64 restore_point = get_lowest_words_done ();
1478
1479 u64 restore_total = data.words_base;
1480
1481 float percent_restore = 0;
1482
1483 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1484
1485 if (progress_end_relative_skip)
1486 {
1487 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1488 {
1489 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1490 float percent_rejected = 0.0;
1491
1492 if (progress_cur)
1493 {
1494 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1495 }
1496
1497 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1498 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1499
1500 if (data.restore_disable == 0)
1501 {
1502 if (percent_finished != 1)
1503 {
1504 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1505 }
1506 }
1507 }
1508 }
1509 else
1510 {
1511 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1512 {
1513 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1514 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1515
1516 if (data.restore_disable == 0)
1517 {
1518 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1519 }
1520 }
1521 else
1522 {
1523 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1524 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1525
1526 // --restore not allowed if stdin is used -- really? why?
1527
1528 //if (data.restore_disable == 0)
1529 //{
1530 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1531 //}
1532 }
1533 }
1534
1535 #ifdef HAVE_HWMON
1536 if (data.gpu_temp_disable == 0)
1537 {
1538 hc_thread_mutex_lock (mux_adl);
1539
1540 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1541 {
1542 hc_device_param_t *device_param = &data.devices_param[device_id];
1543
1544 if (device_param->skipped) continue;
1545
1546 #define HM_STR_BUF_SIZE 255
1547
1548 char utilization[HM_STR_BUF_SIZE] = { 0 };
1549 char temperature[HM_STR_BUF_SIZE] = { 0 };
1550 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1551 char corespeed[HM_STR_BUF_SIZE] = { 0 };
1552 char memoryspeed[HM_STR_BUF_SIZE] = { 0 };
1553 char buslanes[HM_STR_BUF_SIZE] = { 0 };
1554
1555 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1556 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1557 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1558 hm_device_val_to_str ((char *) corespeed, HM_STR_BUF_SIZE, "Mhz", hm_get_corespeed_with_device_id (device_id));
1559 hm_device_val_to_str ((char *) memoryspeed, HM_STR_BUF_SIZE, "Mhz", hm_get_memoryspeed_with_device_id (device_id));
1560 hm_device_val_to_str ((char *) buslanes, HM_STR_BUF_SIZE, "", hm_get_buslanes_with_device_id (device_id));
1561
1562 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan, %s Core, %s Mem, %s Lanes", device_id + 1, utilization, temperature, fanspeed, corespeed, memoryspeed, buslanes);
1563 }
1564
1565 hc_thread_mutex_unlock (mux_adl);
1566 }
1567 #endif // HAVE_HWMON
1568 }
1569
1570 static void status_benchmark_automate ()
1571 {
1572 u64 speed_cnt[DEVICES_MAX] = { 0 };
1573 double speed_ms[DEVICES_MAX] = { 0 };
1574
1575 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1576 {
1577 hc_device_param_t *device_param = &data.devices_param[device_id];
1578
1579 if (device_param->skipped) continue;
1580
1581 speed_cnt[device_id] = device_param->speed_cnt[0];
1582 speed_ms[device_id] = device_param->speed_ms[0];
1583 }
1584
1585 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1586
1587 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1588 {
1589 hc_device_param_t *device_param = &data.devices_param[device_id];
1590
1591 if (device_param->skipped) continue;
1592
1593 hashes_dev_ms[device_id] = 0;
1594
1595 if (speed_ms[device_id])
1596 {
1597 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1598 }
1599 }
1600
1601 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1602 {
1603 hc_device_param_t *device_param = &data.devices_param[device_id];
1604
1605 if (device_param->skipped) continue;
1606
1607 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1608 }
1609 }
1610
1611 static void status_benchmark ()
1612 {
1613 if (data.devices_status == STATUS_INIT) return;
1614 if (data.devices_status == STATUS_STARTING) return;
1615 if (data.devices_status == STATUS_BYPASS) return;
1616
1617 if (data.machine_readable == 1)
1618 {
1619 status_benchmark_automate ();
1620
1621 return;
1622 }
1623
1624 u64 speed_cnt[DEVICES_MAX] = { 0 };
1625 double speed_ms[DEVICES_MAX] = { 0 };
1626
1627 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1628 {
1629 hc_device_param_t *device_param = &data.devices_param[device_id];
1630
1631 if (device_param->skipped) continue;
1632
1633 speed_cnt[device_id] = device_param->speed_cnt[0];
1634 speed_ms[device_id] = device_param->speed_ms[0];
1635 }
1636
1637 double hashes_all_ms = 0;
1638
1639 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1640
1641 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1642 {
1643 hc_device_param_t *device_param = &data.devices_param[device_id];
1644
1645 if (device_param->skipped) continue;
1646
1647 hashes_dev_ms[device_id] = 0;
1648
1649 if (speed_ms[device_id])
1650 {
1651 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1652
1653 hashes_all_ms += hashes_dev_ms[device_id];
1654 }
1655 }
1656
1657 /**
1658 * exec time
1659 */
1660
1661 double exec_all_ms[DEVICES_MAX] = { 0 };
1662
1663 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1664 {
1665 hc_device_param_t *device_param = &data.devices_param[device_id];
1666
1667 if (device_param->skipped) continue;
1668
1669 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1670
1671 exec_all_ms[device_id] = exec_ms_avg;
1672 }
1673
1674 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1675 {
1676 hc_device_param_t *device_param = &data.devices_param[device_id];
1677
1678 if (device_param->skipped) continue;
1679
1680 char display_dev_cur[16] = { 0 };
1681
1682 strncpy (display_dev_cur, "0.00", 4);
1683
1684 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1685
1686 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1687 }
1688
1689 char display_all_cur[16] = { 0 };
1690
1691 strncpy (display_all_cur, "0.00", 4);
1692
1693 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1694
1695 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1696 }
1697
1698 /**
1699 * hashcat -only- functions
1700 */
1701
1702 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1703 {
1704 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1705 {
1706 if (attack_kern == ATTACK_KERN_STRAIGHT)
1707 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1708 else if (attack_kern == ATTACK_KERN_COMBI)
1709 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1710 else if (attack_kern == ATTACK_KERN_BF)
1711 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1712 }
1713 else
1714 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1715 }
1716
1717 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)
1718 {
1719 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1720 {
1721 if (attack_kern == ATTACK_KERN_STRAIGHT)
1722 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1723 else if (attack_kern == ATTACK_KERN_COMBI)
1724 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1725 else if (attack_kern == ATTACK_KERN_BF)
1726 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1727 }
1728 else
1729 {
1730 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1731 }
1732 }
1733
1734 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1735 {
1736 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1737 {
1738 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1739 }
1740 else
1741 {
1742 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1743 }
1744 }
1745
1746 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)
1747 {
1748 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1749 {
1750 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1751 }
1752 else
1753 {
1754 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1755 }
1756 }
1757
1758 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1759 {
1760 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1761 }
1762
1763 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1764 {
1765 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1766 }
1767
1768 static uint convert_from_hex (char *line_buf, const uint line_len)
1769 {
1770 if (line_len & 1) return (line_len); // not in hex
1771
1772 if (data.hex_wordlist == 1)
1773 {
1774 uint i;
1775 uint j;
1776
1777 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1778 {
1779 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1780 }
1781
1782 memset (line_buf + i, 0, line_len - i);
1783
1784 return (i);
1785 }
1786 else if (line_len >= 6) // $HEX[] = 6
1787 {
1788 if (line_buf[0] != '$') return (line_len);
1789 if (line_buf[1] != 'H') return (line_len);
1790 if (line_buf[2] != 'E') return (line_len);
1791 if (line_buf[3] != 'X') return (line_len);
1792 if (line_buf[4] != '[') return (line_len);
1793 if (line_buf[line_len - 1] != ']') return (line_len);
1794
1795 uint i;
1796 uint j;
1797
1798 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1799 {
1800 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1801 }
1802
1803 memset (line_buf + i, 0, line_len - i);
1804
1805 return (i);
1806 }
1807
1808 return (line_len);
1809 }
1810
1811 static void clear_prompt ()
1812 {
1813 fputc ('\r', stdout);
1814
1815 for (size_t i = 0; i < strlen (PROMPT); i++)
1816 {
1817 fputc (' ', stdout);
1818 }
1819
1820 fputc ('\r', stdout);
1821
1822 fflush (stdout);
1823 }
1824
1825 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1826 {
1827 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);
1828 }
1829
1830 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1831 {
1832 char *outfile = data.outfile;
1833 uint quiet = data.quiet;
1834 FILE *pot_fp = data.pot_fp;
1835 uint loopback = data.loopback;
1836 uint debug_mode = data.debug_mode;
1837 char *debug_file = data.debug_file;
1838
1839 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1840 int debug_rule_len = 0; // -1 error
1841 uint debug_plain_len = 0;
1842
1843 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1844
1845 // hash
1846
1847 char out_buf[HCBUFSIZ] = { 0 };
1848
1849 const u32 salt_pos = plain->salt_pos;
1850 const u32 digest_pos = plain->digest_pos; // relative
1851 const u32 gidvid = plain->gidvid;
1852 const u32 il_pos = plain->il_pos;
1853
1854 ascii_digest (out_buf, salt_pos, digest_pos);
1855
1856 // plain
1857
1858 u64 crackpos = device_param->words_off;
1859
1860 uint plain_buf[16] = { 0 };
1861
1862 u8 *plain_ptr = (u8 *) plain_buf;
1863
1864 unsigned int plain_len = 0;
1865
1866 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1867 {
1868 pw_t pw;
1869
1870 gidd_to_pw_t (device_param, gidvid, &pw);
1871
1872 for (int i = 0; i < 16; i++)
1873 {
1874 plain_buf[i] = pw.i[i];
1875 }
1876
1877 plain_len = pw.pw_len;
1878
1879 const uint off = device_param->innerloop_pos + il_pos;
1880
1881 if (debug_mode > 0)
1882 {
1883 debug_rule_len = 0;
1884
1885 // save rule
1886 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1887 {
1888 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1889
1890 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1891 }
1892
1893 // save plain
1894 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1895 {
1896 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1897
1898 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1899
1900 debug_plain_len = plain_len;
1901 }
1902 }
1903
1904 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1905
1906 crackpos += gidvid;
1907 crackpos *= data.kernel_rules_cnt;
1908 crackpos += device_param->innerloop_pos + il_pos;
1909
1910 if (plain_len > data.pw_max) plain_len = data.pw_max;
1911 }
1912 else if (data.attack_mode == ATTACK_MODE_COMBI)
1913 {
1914 pw_t pw;
1915
1916 gidd_to_pw_t (device_param, gidvid, &pw);
1917
1918 for (int i = 0; i < 16; i++)
1919 {
1920 plain_buf[i] = pw.i[i];
1921 }
1922
1923 plain_len = pw.pw_len;
1924
1925 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1926 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1927
1928 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1929 {
1930 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1931 }
1932 else
1933 {
1934 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1935
1936 memcpy (plain_ptr, comb_buf, comb_len);
1937 }
1938
1939 plain_len += comb_len;
1940
1941 crackpos += gidvid;
1942 crackpos *= data.combs_cnt;
1943 crackpos += device_param->innerloop_pos + il_pos;
1944
1945 if (data.pw_max != PW_DICTMAX1)
1946 {
1947 if (plain_len > data.pw_max) plain_len = data.pw_max;
1948 }
1949 }
1950 else if (data.attack_mode == ATTACK_MODE_BF)
1951 {
1952 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1953 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1954
1955 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1956 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1957
1958 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1959 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1960
1961 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1962 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1963
1964 plain_len = data.css_cnt;
1965
1966 crackpos += gidvid;
1967 crackpos *= data.bfs_cnt;
1968 crackpos += device_param->innerloop_pos + il_pos;
1969 }
1970 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1971 {
1972 pw_t pw;
1973
1974 gidd_to_pw_t (device_param, gidvid, &pw);
1975
1976 for (int i = 0; i < 16; i++)
1977 {
1978 plain_buf[i] = pw.i[i];
1979 }
1980
1981 plain_len = pw.pw_len;
1982
1983 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
1984
1985 uint start = 0;
1986 uint stop = device_param->kernel_params_mp_buf32[4];
1987
1988 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
1989
1990 plain_len += start + stop;
1991
1992 crackpos += gidvid;
1993 crackpos *= data.combs_cnt;
1994 crackpos += device_param->innerloop_pos + il_pos;
1995
1996 if (data.pw_max != PW_DICTMAX1)
1997 {
1998 if (plain_len > data.pw_max) plain_len = data.pw_max;
1999 }
2000 }
2001 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2002 {
2003 pw_t pw;
2004
2005 gidd_to_pw_t (device_param, gidvid, &pw);
2006
2007 for (int i = 0; i < 16; i++)
2008 {
2009 plain_buf[i] = pw.i[i];
2010 }
2011
2012 plain_len = pw.pw_len;
2013
2014 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2015
2016 uint start = 0;
2017 uint stop = device_param->kernel_params_mp_buf32[4];
2018
2019 memmove (plain_ptr + stop, plain_ptr, plain_len);
2020
2021 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2022
2023 plain_len += start + stop;
2024
2025 crackpos += gidvid;
2026 crackpos *= data.combs_cnt;
2027 crackpos += device_param->innerloop_pos + il_pos;
2028
2029 if (data.pw_max != PW_DICTMAX1)
2030 {
2031 if (plain_len > data.pw_max) plain_len = data.pw_max;
2032 }
2033 }
2034
2035 if (data.attack_mode == ATTACK_MODE_BF)
2036 {
2037 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2038 {
2039 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2040 {
2041 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2042 {
2043 plain_len = plain_len - data.salts_buf[0].salt_len;
2044 }
2045 }
2046
2047 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2048 {
2049 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2050 {
2051 plain_ptr[j] = plain_ptr[i];
2052 }
2053
2054 plain_len = plain_len / 2;
2055 }
2056 }
2057 }
2058
2059 // if enabled, update also the potfile
2060
2061 if (pot_fp)
2062 {
2063 lock_file (pot_fp);
2064
2065 fprintf (pot_fp, "%s:", out_buf);
2066
2067 format_plain (pot_fp, plain_ptr, plain_len, 1);
2068
2069 fputc ('\n', pot_fp);
2070
2071 fflush (pot_fp);
2072
2073 unlock_file (pot_fp);
2074 }
2075
2076 // outfile
2077
2078 FILE *out_fp = NULL;
2079
2080 if (outfile != NULL)
2081 {
2082 if ((out_fp = fopen (outfile, "ab")) == NULL)
2083 {
2084 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2085
2086 out_fp = stdout;
2087 }
2088
2089 lock_file (out_fp);
2090 }
2091 else
2092 {
2093 out_fp = stdout;
2094
2095 if (quiet == 0) clear_prompt ();
2096 }
2097
2098 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2099
2100 if (outfile != NULL)
2101 {
2102 if (out_fp != stdout)
2103 {
2104 fclose (out_fp);
2105 }
2106 }
2107 else
2108 {
2109 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2110 {
2111 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2112 {
2113 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2114 if (quiet == 0) fflush (stdout);
2115 }
2116 }
2117 }
2118
2119 // loopback
2120
2121 if (loopback)
2122 {
2123 char *loopback_file = data.loopback_file;
2124
2125 FILE *fb_fp = NULL;
2126
2127 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2128 {
2129 lock_file (fb_fp);
2130
2131 format_plain (fb_fp, plain_ptr, plain_len, 1);
2132
2133 fputc ('\n', fb_fp);
2134
2135 fclose (fb_fp);
2136 }
2137 }
2138
2139 // (rule) debug mode
2140
2141 // the next check implies that:
2142 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2143 // - debug_mode > 0
2144
2145 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2146 {
2147 if (debug_rule_len < 0) debug_rule_len = 0;
2148
2149 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2150
2151 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2152
2153 if ((quiet == 0) && (debug_file == NULL))
2154 {
2155 fprintf (stdout, "%s", PROMPT);
2156
2157 fflush (stdout);
2158 }
2159 }
2160 }
2161
2162 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2163 {
2164 salt_t *salt_buf = &data.salts_buf[salt_pos];
2165
2166 u32 num_cracked;
2167
2168 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2169
2170 if (num_cracked)
2171 {
2172 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2173
2174 log_info_nn ("");
2175
2176 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2177
2178 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);
2179
2180 uint cpt_cracked = 0;
2181
2182 for (uint i = 0; i < num_cracked; i++)
2183 {
2184 const uint hash_pos = cracked[i].hash_pos;
2185
2186 if (data.digests_shown[hash_pos] == 1) continue;
2187
2188 hc_thread_mutex_lock (mux_display);
2189
2190 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2191 {
2192 data.digests_shown[hash_pos] = 1;
2193
2194 data.digests_done++;
2195
2196 cpt_cracked++;
2197
2198 salt_buf->digests_done++;
2199
2200 if (salt_buf->digests_done == salt_buf->digests_cnt)
2201 {
2202 data.salts_shown[salt_pos] = 1;
2203
2204 data.salts_done++;
2205 }
2206 }
2207
2208 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2209
2210 hc_thread_mutex_unlock (mux_display);
2211
2212 check_hash (device_param, &cracked[i]);
2213 }
2214
2215 myfree (cracked);
2216
2217 if (cpt_cracked > 0)
2218 {
2219 hc_thread_mutex_lock (mux_display);
2220
2221 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2222 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2223
2224 data.cpt_pos++;
2225
2226 data.cpt_total += cpt_cracked;
2227
2228 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2229
2230 hc_thread_mutex_unlock (mux_display);
2231 }
2232
2233 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2234 {
2235 // we need to reset cracked state on the device
2236 // otherwise host thinks again and again the hash was cracked
2237 // and returns invalid password each time
2238
2239 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2240
2241 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);
2242 }
2243
2244 num_cracked = 0;
2245
2246 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2247 }
2248 }
2249
2250 static void save_hash ()
2251 {
2252 char *hashfile = data.hashfile;
2253
2254 char new_hashfile[256] = { 0 };
2255 char old_hashfile[256] = { 0 };
2256
2257 snprintf (new_hashfile, 255, "%s.new", hashfile);
2258 snprintf (old_hashfile, 255, "%s.old", hashfile);
2259
2260 unlink (new_hashfile);
2261
2262 char separator = data.separator;
2263
2264 FILE *fp = fopen (new_hashfile, "wb");
2265
2266 if (fp == NULL)
2267 {
2268 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2269
2270 exit (-1);
2271 }
2272
2273 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2274 {
2275 if (data.salts_shown[salt_pos] == 1) continue;
2276
2277 salt_t *salt_buf = &data.salts_buf[salt_pos];
2278
2279 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2280 {
2281 uint idx = salt_buf->digests_offset + digest_pos;
2282
2283 if (data.digests_shown[idx] == 1) continue;
2284
2285 if (data.hash_mode != 2500)
2286 {
2287 char out_buf[HCBUFSIZ] = { 0 };
2288
2289 if (data.username == 1)
2290 {
2291 user_t *user = data.hash_info[idx]->user;
2292
2293 uint i;
2294
2295 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2296
2297 fputc (separator, fp);
2298 }
2299
2300 ascii_digest (out_buf, salt_pos, digest_pos);
2301
2302 fputs (out_buf, fp);
2303
2304 log_out (fp, "");
2305 }
2306 else
2307 {
2308 hccap_t hccap;
2309
2310 to_hccap_t (&hccap, salt_pos, digest_pos);
2311
2312 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2313 }
2314 }
2315 }
2316
2317 fflush (fp);
2318
2319 fclose (fp);
2320
2321 unlink (old_hashfile);
2322
2323 if (rename (hashfile, old_hashfile) != 0)
2324 {
2325 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2326
2327 exit (-1);
2328 }
2329
2330 unlink (hashfile);
2331
2332 if (rename (new_hashfile, hashfile) != 0)
2333 {
2334 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2335
2336 exit (-1);
2337 }
2338
2339 unlink (old_hashfile);
2340 }
2341
2342 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2343 {
2344 // function called only in case kernel_power_all > words_left
2345
2346 float kernel_power_div = (float) (total_left) / kernel_power_all;
2347
2348 kernel_power_div += kernel_power_div / 100;
2349
2350 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2351
2352 while (kernel_power_new < total_left)
2353 {
2354 kernel_power_div += kernel_power_div / 100;
2355
2356 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2357 }
2358
2359 if (data.quiet == 0)
2360 {
2361 clear_prompt ();
2362
2363 //log_info ("");
2364
2365 log_info ("INFO: approaching final keyspace, workload adjusted");
2366 log_info ("");
2367
2368 fprintf (stdout, "%s", PROMPT);
2369
2370 fflush (stdout);
2371 }
2372
2373 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2374
2375 return kernel_power_div;
2376 }
2377
2378 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2379 {
2380 uint num_elements = num;
2381
2382 device_param->kernel_params_buf32[30] = data.combs_mode;
2383 device_param->kernel_params_buf32[31] = num;
2384
2385 uint kernel_threads = device_param->kernel_threads;
2386
2387 while (num_elements % kernel_threads) num_elements++;
2388
2389 cl_kernel kernel = NULL;
2390
2391 switch (kern_run)
2392 {
2393 case KERN_RUN_1: kernel = device_param->kernel1; break;
2394 case KERN_RUN_12: kernel = device_param->kernel12; break;
2395 case KERN_RUN_2: kernel = device_param->kernel2; break;
2396 case KERN_RUN_23: kernel = device_param->kernel23; break;
2397 case KERN_RUN_3: kernel = device_param->kernel3; break;
2398 }
2399
2400 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2401 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2402 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2403 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2404 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2405 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2406 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2407 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2408 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2409 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2410 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2411
2412 cl_event event;
2413
2414 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2415 {
2416 const size_t global_work_size[3] = { num_elements, 32, 1 };
2417 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2418
2419 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2420 }
2421 else
2422 {
2423 if (kern_run == KERN_RUN_2)
2424 {
2425 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2426 {
2427 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2428 }
2429 }
2430
2431 while (num_elements % kernel_threads) num_elements++;
2432
2433 const size_t global_work_size[3] = { num_elements, 1, 1 };
2434 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2435
2436 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2437 }
2438
2439 hc_clFlush (data.ocl, device_param->command_queue);
2440
2441 hc_clWaitForEvents (data.ocl, 1, &event);
2442
2443 if (event_update)
2444 {
2445 cl_ulong time_start;
2446 cl_ulong time_end;
2447
2448 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2449 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2450
2451 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2452
2453 uint exec_pos = device_param->exec_pos;
2454
2455 device_param->exec_ms[exec_pos] = exec_time;
2456
2457 exec_pos++;
2458
2459 if (exec_pos == EXEC_CACHE)
2460 {
2461 exec_pos = 0;
2462 }
2463
2464 device_param->exec_pos = exec_pos;
2465 }
2466
2467 hc_clReleaseEvent (data.ocl, event);
2468
2469 hc_clFinish (data.ocl, device_param->command_queue);
2470 }
2471
2472 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2473 {
2474 uint num_elements = num;
2475
2476 switch (kern_run)
2477 {
2478 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2479 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2480 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2481 }
2482
2483 // causes problems with special threads like in bcrypt
2484 // const uint kernel_threads = device_param->kernel_threads;
2485
2486 uint kernel_threads = device_param->kernel_threads;
2487
2488 while (num_elements % kernel_threads) num_elements++;
2489
2490 cl_kernel kernel = NULL;
2491
2492 switch (kern_run)
2493 {
2494 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2495 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2496 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2497 }
2498
2499 switch (kern_run)
2500 {
2501 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2502 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2503 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2504 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2505 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2506 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2507 break;
2508 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2509 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2510 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2511 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2512 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2513 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2514 break;
2515 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2516 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2517 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2518 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2519 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2520 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2521 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2522 break;
2523 }
2524
2525 const size_t global_work_size[3] = { num_elements, 1, 1 };
2526 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2527
2528 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2529
2530 hc_clFlush (data.ocl, device_param->command_queue);
2531
2532 hc_clFinish (data.ocl, device_param->command_queue);
2533 }
2534
2535 static void run_kernel_tm (hc_device_param_t *device_param)
2536 {
2537 const uint num_elements = 1024; // fixed
2538
2539 uint kernel_threads = 32;
2540
2541 cl_kernel kernel = device_param->kernel_tm;
2542
2543 const size_t global_work_size[3] = { num_elements, 1, 1 };
2544 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2545
2546 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2547
2548 hc_clFlush (data.ocl, device_param->command_queue);
2549
2550 hc_clFinish (data.ocl, device_param->command_queue);
2551 }
2552
2553 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2554 {
2555 uint num_elements = num;
2556
2557 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2558 device_param->kernel_params_amp_buf32[6] = num_elements;
2559
2560 // causes problems with special threads like in bcrypt
2561 // const uint kernel_threads = device_param->kernel_threads;
2562
2563 uint kernel_threads = device_param->kernel_threads;
2564
2565 while (num_elements % kernel_threads) num_elements++;
2566
2567 cl_kernel kernel = device_param->kernel_amp;
2568
2569 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2570 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2571
2572 const size_t global_work_size[3] = { num_elements, 1, 1 };
2573 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2574
2575 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2576
2577 hc_clFlush (data.ocl, device_param->command_queue);
2578
2579 hc_clFinish (data.ocl, device_param->command_queue);
2580 }
2581
2582 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2583 {
2584 const u32 num16d = num / 16;
2585 const u32 num16m = num % 16;
2586
2587 if (num16d)
2588 {
2589 device_param->kernel_params_memset_buf32[1] = value;
2590 device_param->kernel_params_memset_buf32[2] = num16d;
2591
2592 uint kernel_threads = device_param->kernel_threads;
2593
2594 uint num_elements = num16d;
2595
2596 while (num_elements % kernel_threads) num_elements++;
2597
2598 cl_kernel kernel = device_param->kernel_memset;
2599
2600 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2601 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2602 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2603
2604 const size_t global_work_size[3] = { num_elements, 1, 1 };
2605 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2606
2607 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2608
2609 hc_clFlush (data.ocl, device_param->command_queue);
2610
2611 hc_clFinish (data.ocl, device_param->command_queue);
2612 }
2613
2614 if (num16m)
2615 {
2616 u32 tmp[4];
2617
2618 tmp[0] = value;
2619 tmp[1] = value;
2620 tmp[2] = value;
2621 tmp[3] = value;
2622
2623 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2624 }
2625 }
2626
2627 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2628 {
2629 run_kernel_memset (device_param, buf, 0, size);
2630
2631 /*
2632 int rc = -1;
2633
2634 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2635 {
2636 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2637
2638 const cl_uchar zero = 0;
2639
2640 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2641 }
2642
2643 if (rc != 0)
2644 {
2645 // NOTE: clEnqueueFillBuffer () always fails with -59
2646 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2647 // How's that possible, OpenCL 1.2 support is advertised??
2648 // We need to workaround...
2649
2650 #define FILLSZ 0x100000
2651
2652 char *tmp = (char *) mymalloc (FILLSZ);
2653
2654 for (size_t i = 0; i < size; i += FILLSZ)
2655 {
2656 const size_t left = size - i;
2657
2658 const size_t fillsz = MIN (FILLSZ, left);
2659
2660 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2661 }
2662
2663 myfree (tmp);
2664 }
2665 */
2666 }
2667
2668 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)
2669 {
2670 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2671 {
2672 if (attack_mode == ATTACK_MODE_BF)
2673 {
2674 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2675 {
2676 const uint size_tm = 32 * sizeof (bs_word_t);
2677
2678 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2679
2680 run_kernel_tm (device_param);
2681
2682 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);
2683 }
2684 }
2685
2686 if (highest_pw_len < 16)
2687 {
2688 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2689 }
2690 else if (highest_pw_len < 32)
2691 {
2692 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2693 }
2694 else
2695 {
2696 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2697 }
2698 }
2699 else
2700 {
2701 run_kernel_amp (device_param, pws_cnt);
2702
2703 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2704
2705 if (opts_type & OPTS_TYPE_HOOK12)
2706 {
2707 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2708 }
2709
2710 uint iter = salt_buf->salt_iter;
2711
2712 uint loop_step = device_param->kernel_loops;
2713
2714 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2715 {
2716 uint loop_left = iter - loop_pos;
2717
2718 loop_left = MIN (loop_left, loop_step);
2719
2720 device_param->kernel_params_buf32[25] = loop_pos;
2721 device_param->kernel_params_buf32[26] = loop_left;
2722
2723 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2724
2725 if (data.devices_status == STATUS_CRACKED) break;
2726 if (data.devices_status == STATUS_ABORTED) break;
2727 if (data.devices_status == STATUS_QUIT) break;
2728
2729 /**
2730 * speed
2731 */
2732
2733 const float iter_part = (float) (loop_pos + loop_left) / iter;
2734
2735 const u64 perf_sum_all = pws_cnt * iter_part;
2736
2737 double speed_ms;
2738
2739 hc_timer_get (device_param->timer_speed, speed_ms);
2740
2741 const u32 speed_pos = device_param->speed_pos;
2742
2743 device_param->speed_cnt[speed_pos] = perf_sum_all;
2744
2745 device_param->speed_ms[speed_pos] = speed_ms;
2746
2747 if (data.benchmark == 1)
2748 {
2749 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2750 }
2751 }
2752
2753 if (opts_type & OPTS_TYPE_HOOK23)
2754 {
2755 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2756
2757 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);
2758
2759 // do something with data
2760
2761 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);
2762 }
2763
2764 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2765 }
2766 }
2767
2768 static int run_rule_engine (const int rule_len, const char *rule_buf)
2769 {
2770 if (rule_len == 0)
2771 {
2772 return 0;
2773 }
2774 else if (rule_len == 1)
2775 {
2776 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2777 }
2778
2779 return 1;
2780 }
2781
2782 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2783 {
2784 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2785 {
2786 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);
2787 }
2788 else if (data.attack_kern == ATTACK_KERN_COMBI)
2789 {
2790 if (data.attack_mode == ATTACK_MODE_COMBI)
2791 {
2792 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2793 {
2794 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2795 {
2796 for (u32 i = 0; i < pws_cnt; i++)
2797 {
2798 const u32 pw_len = device_param->pws_buf[i].pw_len;
2799
2800 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2801
2802 ptr[pw_len] = 0x01;
2803 }
2804 }
2805 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2806 {
2807 for (u32 i = 0; i < pws_cnt; i++)
2808 {
2809 const u32 pw_len = device_param->pws_buf[i].pw_len;
2810
2811 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2812
2813 ptr[pw_len] = 0x80;
2814 }
2815 }
2816 }
2817 }
2818 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2819 {
2820 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2821 {
2822 for (u32 i = 0; i < pws_cnt; i++)
2823 {
2824 const u32 pw_len = device_param->pws_buf[i].pw_len;
2825
2826 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2827
2828 ptr[pw_len] = 0x01;
2829 }
2830 }
2831 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2832 {
2833 for (u32 i = 0; i < pws_cnt; i++)
2834 {
2835 const u32 pw_len = device_param->pws_buf[i].pw_len;
2836
2837 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2838
2839 ptr[pw_len] = 0x80;
2840 }
2841 }
2842 }
2843
2844 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);
2845 }
2846 else if (data.attack_kern == ATTACK_KERN_BF)
2847 {
2848 const u64 off = device_param->words_off;
2849
2850 device_param->kernel_params_mp_l_buf64[3] = off;
2851
2852 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2853 }
2854 }
2855
2856 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2857 {
2858 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2859
2860 device_param->kernel_params_buf32[25] = 0;
2861 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2862 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2863
2864 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2865 {
2866 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2867 }
2868 else
2869 {
2870 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2871 }
2872
2873 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2874
2875 return exec_ms_prev;
2876 }
2877
2878 static void autotune (hc_device_param_t *device_param)
2879 {
2880 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2881
2882 const u32 kernel_accel_min = device_param->kernel_accel_min;
2883 const u32 kernel_accel_max = device_param->kernel_accel_max;
2884
2885 const u32 kernel_loops_min = device_param->kernel_loops_min;
2886 const u32 kernel_loops_max = device_param->kernel_loops_max;
2887
2888 u32 kernel_accel = kernel_accel_min;
2889 u32 kernel_loops = kernel_loops_min;
2890
2891 // in this case the user specified a fixed -u and -n on the commandline
2892 // no way to tune anything
2893 // but we need to run a few caching rounds
2894
2895 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2896 {
2897 try_run (device_param, kernel_accel, kernel_loops);
2898 try_run (device_param, kernel_accel, kernel_loops);
2899 try_run (device_param, kernel_accel, kernel_loops);
2900 try_run (device_param, kernel_accel, kernel_loops);
2901
2902 device_param->kernel_accel = kernel_accel;
2903 device_param->kernel_loops = kernel_loops;
2904
2905 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2906
2907 device_param->kernel_power = kernel_power;
2908
2909 return;
2910 }
2911
2912 // from here it's clear we are allowed to autotune
2913 // so let's init some fake words
2914
2915 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2916
2917 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2918
2919 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2920 {
2921 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 7, kernel_power_max * sizeof (pw_t));
2922 }
2923
2924 /*
2925 for (u32 i = 0; i < kernel_power_max; i++)
2926 {
2927 device_param->pws_buf[i].i[0] = i;
2928 device_param->pws_buf[i].i[1] = 0x01234567;
2929 device_param->pws_buf[i].pw_len = 7;
2930 }
2931
2932 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);
2933
2934 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2935 {
2936 run_kernel_amp (device_param, kernel_power_max);
2937 }
2938 */
2939
2940 #define VERIFIER_CNT 1
2941
2942 // first find out highest kernel-loops that stays below target_ms
2943
2944 if (kernel_loops_min < kernel_loops_max)
2945 {
2946 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2947 {
2948 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2949
2950 for (int i = 0; i < VERIFIER_CNT; i++)
2951 {
2952 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2953
2954 exec_ms = MIN (exec_ms, exec_ms_v);
2955 }
2956
2957 if (exec_ms < target_ms) break;
2958 }
2959 }
2960
2961 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2962
2963 #define STEPS_CNT 10
2964
2965 if (kernel_accel_min < kernel_accel_max)
2966 {
2967 for (int i = 0; i < STEPS_CNT; i++)
2968 {
2969 const u32 kernel_accel_try = 1 << i;
2970
2971 if (kernel_accel_try < kernel_accel_min) continue;
2972 if (kernel_accel_try > kernel_accel_max) break;
2973
2974 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2975
2976 for (int i = 0; i < VERIFIER_CNT; i++)
2977 {
2978 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
2979
2980 exec_ms = MIN (exec_ms, exec_ms_v);
2981 }
2982
2983 if (exec_ms > target_ms) break;
2984
2985 kernel_accel = kernel_accel_try;
2986 }
2987 }
2988
2989 // at this point we want to know the actual runtime for the following reason:
2990 // we need a reference for the balancing loop following up, and this
2991 // the balancing loop can have an effect that the creates a new opportunity, for example:
2992 // if the target is 95 ms and the current runtime is 48ms the above loop
2993 // stopped the execution because the previous exec_ms was > 95ms
2994 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
2995 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
2996
2997 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
2998
2999 for (int i = 0; i < VERIFIER_CNT; i++)
3000 {
3001 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3002
3003 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3004 }
3005
3006 u32 diff = kernel_loops - kernel_accel;
3007
3008 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3009 {
3010 u32 kernel_accel_orig = kernel_accel;
3011 u32 kernel_loops_orig = kernel_loops;
3012
3013 for (u32 f = 1; f < 1024; f++)
3014 {
3015 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3016 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3017
3018 if (kernel_accel_try > kernel_accel_max) break;
3019 if (kernel_loops_try < kernel_loops_min) break;
3020
3021 u32 diff_new = kernel_loops_try - kernel_accel_try;
3022
3023 if (diff_new > diff) break;
3024
3025 diff_new = diff;
3026
3027 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3028
3029 for (int i = 0; i < VERIFIER_CNT; i++)
3030 {
3031 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3032
3033 exec_ms = MIN (exec_ms, exec_ms_v);
3034 }
3035
3036 if (exec_ms < exec_ms_pre_final)
3037 {
3038 exec_ms_pre_final = exec_ms;
3039
3040 kernel_accel = kernel_accel_try;
3041 kernel_loops = kernel_loops_try;
3042 }
3043 }
3044 }
3045
3046 const double exec_left = target_ms / exec_ms_pre_final;
3047
3048 const double accel_left = kernel_accel_max / kernel_accel;
3049
3050 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3051
3052 if (exec_accel_min >= 1.0)
3053 {
3054 // this is safe to not overflow kernel_accel_max because of accel_left
3055
3056 kernel_accel = (double) kernel_accel * exec_accel_min;
3057 }
3058
3059 // reset them fake words
3060
3061 /*
3062 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3063
3064 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);
3065 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);
3066 */
3067
3068 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3069
3070 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3071 {
3072 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3073 }
3074
3075 // reset timer
3076
3077 device_param->exec_pos = 0;
3078
3079 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3080
3081 // store
3082
3083 device_param->kernel_accel = kernel_accel;
3084 device_param->kernel_loops = kernel_loops;
3085
3086 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3087
3088 device_param->kernel_power = kernel_power;
3089
3090 #ifdef DEBUG
3091
3092 if (data.quiet == 0)
3093 {
3094 clear_prompt ();
3095
3096 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3097 "Device #%u: autotuned kernel-loops to %u\n",
3098 device_param->device_id + 1, kernel_accel,
3099 device_param->device_id + 1, kernel_loops);
3100
3101 fprintf (stdout, "%s", PROMPT);
3102
3103 fflush (stdout);
3104 }
3105
3106 #endif
3107 }
3108
3109 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3110 {
3111 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3112
3113 // init speed timer
3114
3115 uint speed_pos = device_param->speed_pos;
3116
3117 #ifdef _POSIX
3118 if (device_param->timer_speed.tv_sec == 0)
3119 {
3120 hc_timer_set (&device_param->timer_speed);
3121 }
3122 #endif
3123
3124 #ifdef _WIN
3125 if (device_param->timer_speed.QuadPart == 0)
3126 {
3127 hc_timer_set (&device_param->timer_speed);
3128 }
3129 #endif
3130
3131 // find higest password length, this is for optimization stuff
3132
3133 uint highest_pw_len = 0;
3134
3135 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3136 {
3137 }
3138 else if (data.attack_kern == ATTACK_KERN_COMBI)
3139 {
3140 }
3141 else if (data.attack_kern == ATTACK_KERN_BF)
3142 {
3143 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3144 + device_param->kernel_params_mp_l_buf32[5];
3145 }
3146
3147 // iteration type
3148
3149 uint innerloop_step = 0;
3150 uint innerloop_cnt = 0;
3151
3152 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3153 else innerloop_step = 1;
3154
3155 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3156 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3157 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3158
3159 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3160
3161 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3162 {
3163 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3164
3165 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3166
3167 if (data.devices_status == STATUS_CRACKED) break;
3168 if (data.devices_status == STATUS_ABORTED) break;
3169 if (data.devices_status == STATUS_QUIT) break;
3170 if (data.devices_status == STATUS_BYPASS) break;
3171
3172 salt_t *salt_buf = &data.salts_buf[salt_pos];
3173
3174 device_param->kernel_params_buf32[24] = salt_pos;
3175 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3176 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3177
3178 FILE *combs_fp = device_param->combs_fp;
3179
3180 if (data.attack_mode == ATTACK_MODE_COMBI)
3181 {
3182 rewind (combs_fp);
3183 }
3184
3185 // innerloops
3186
3187 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3188 {
3189 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3190
3191 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3192
3193 if (data.devices_status == STATUS_CRACKED) break;
3194 if (data.devices_status == STATUS_ABORTED) break;
3195 if (data.devices_status == STATUS_QUIT) break;
3196 if (data.devices_status == STATUS_BYPASS) break;
3197
3198 uint innerloop_left = innerloop_cnt - innerloop_pos;
3199
3200 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3201
3202 device_param->innerloop_pos = innerloop_pos;
3203 device_param->innerloop_left = innerloop_left;
3204
3205 device_param->kernel_params_buf32[27] = innerloop_left;
3206
3207 // i think we can get rid of this
3208 if (innerloop_left == 0)
3209 {
3210 puts ("bug, how should this happen????\n");
3211
3212 continue;
3213 }
3214
3215 if (data.salts_shown[salt_pos] == 1)
3216 {
3217 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3218
3219 continue;
3220 }
3221
3222 // initialize amplifiers
3223
3224 if (data.attack_mode == ATTACK_MODE_COMBI)
3225 {
3226 uint i = 0;
3227
3228 while (i < innerloop_left)
3229 {
3230 if (feof (combs_fp)) break;
3231
3232 int line_len = fgetl (combs_fp, line_buf);
3233
3234 if (line_len >= PW_MAX1) continue;
3235
3236 line_len = convert_from_hex (line_buf, line_len);
3237
3238 char *line_buf_new = line_buf;
3239
3240 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3241 {
3242 char rule_buf_out[BLOCK_SIZE] = { 0 };
3243
3244 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3245
3246 if (rule_len_out < 0)
3247 {
3248 data.words_progress_rejected[salt_pos] += pws_cnt;
3249
3250 continue;
3251 }
3252
3253 line_len = rule_len_out;
3254
3255 line_buf_new = rule_buf_out;
3256 }
3257
3258 line_len = MIN (line_len, PW_DICTMAX);
3259
3260 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3261
3262 memcpy (ptr, line_buf_new, line_len);
3263
3264 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3265
3266 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3267 {
3268 uppercase (ptr, line_len);
3269 }
3270
3271 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3272 {
3273 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3274 {
3275 ptr[line_len] = 0x80;
3276 }
3277
3278 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3279 {
3280 ptr[line_len] = 0x01;
3281 }
3282 }
3283
3284 device_param->combs_buf[i].pw_len = line_len;
3285
3286 i++;
3287 }
3288
3289 for (uint j = i; j < innerloop_left; j++)
3290 {
3291 device_param->combs_buf[j].i[0] = 0;
3292 device_param->combs_buf[j].i[1] = 0;
3293 device_param->combs_buf[j].i[2] = 0;
3294 device_param->combs_buf[j].i[3] = 0;
3295 device_param->combs_buf[j].i[4] = 0;
3296 device_param->combs_buf[j].i[5] = 0;
3297 device_param->combs_buf[j].i[6] = 0;
3298 device_param->combs_buf[j].i[7] = 0;
3299
3300 device_param->combs_buf[j].pw_len = 0;
3301 }
3302
3303 innerloop_left = i;
3304 }
3305 else if (data.attack_mode == ATTACK_MODE_BF)
3306 {
3307 u64 off = innerloop_pos;
3308
3309 device_param->kernel_params_mp_r_buf64[3] = off;
3310
3311 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3312 }
3313 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3314 {
3315 u64 off = innerloop_pos;
3316
3317 device_param->kernel_params_mp_buf64[3] = off;
3318
3319 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3320 }
3321 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3322 {
3323 u64 off = innerloop_pos;
3324
3325 device_param->kernel_params_mp_buf64[3] = off;
3326
3327 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3328 }
3329
3330 // copy amplifiers
3331
3332 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3333 {
3334 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);
3335 }
3336 else if (data.attack_mode == ATTACK_MODE_COMBI)
3337 {
3338 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);
3339 }
3340 else if (data.attack_mode == ATTACK_MODE_BF)
3341 {
3342 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);
3343 }
3344 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3345 {
3346 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);
3347 }
3348 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3349 {
3350 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);
3351 }
3352
3353 if (data.benchmark == 1)
3354 {
3355 hc_timer_set (&device_param->timer_speed);
3356 }
3357
3358 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3359
3360 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3361
3362 if (data.devices_status == STATUS_CRACKED) break;
3363 if (data.devices_status == STATUS_ABORTED) break;
3364 if (data.devices_status == STATUS_QUIT) break;
3365
3366 /**
3367 * result
3368 */
3369
3370 check_cracked (device_param, salt_pos);
3371
3372 /**
3373 * progress
3374 */
3375
3376 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3377
3378 hc_thread_mutex_lock (mux_counter);
3379
3380 data.words_progress_done[salt_pos] += perf_sum_all;
3381
3382 hc_thread_mutex_unlock (mux_counter);
3383
3384 /**
3385 * speed
3386 */
3387
3388 double speed_ms;
3389
3390 hc_timer_get (device_param->timer_speed, speed_ms);
3391
3392 hc_timer_set (&device_param->timer_speed);
3393
3394 // current speed
3395
3396 //hc_thread_mutex_lock (mux_display);
3397
3398 device_param->speed_cnt[speed_pos] = perf_sum_all;
3399
3400 device_param->speed_ms[speed_pos] = speed_ms;
3401
3402 //hc_thread_mutex_unlock (mux_display);
3403
3404 speed_pos++;
3405
3406 if (speed_pos == SPEED_CACHE)
3407 {
3408 speed_pos = 0;
3409 }
3410
3411 /**
3412 * benchmark
3413 */
3414
3415 if (data.benchmark == 1) break;
3416 }
3417 }
3418
3419 device_param->speed_pos = speed_pos;
3420
3421 myfree (line_buf);
3422 }
3423
3424 static void load_segment (wl_data_t *wl_data, FILE *fd)
3425 {
3426 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3427
3428 wl_data->pos = 0;
3429
3430 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3431
3432 wl_data->buf[wl_data->cnt] = 0;
3433
3434 if (wl_data->cnt == 0) return;
3435
3436 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3437
3438 while (!feof (fd))
3439 {
3440 if (wl_data->cnt == wl_data->avail)
3441 {
3442 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3443
3444 wl_data->avail += wl_data->incr;
3445 }
3446
3447 const int c = fgetc (fd);
3448
3449 if (c == EOF) break;
3450
3451 wl_data->buf[wl_data->cnt] = (char) c;
3452
3453 wl_data->cnt++;
3454
3455 if (c == '\n') break;
3456 }
3457
3458 // ensure stream ends with a newline
3459
3460 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3461 {
3462 wl_data->cnt++;
3463
3464 wl_data->buf[wl_data->cnt - 1] = '\n';
3465 }
3466
3467 return;
3468 }
3469
3470 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3471 {
3472 char *ptr = buf;
3473
3474 for (u32 i = 0; i < sz; i++, ptr++)
3475 {
3476 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3477
3478 if (i == 7)
3479 {
3480 *off = i;
3481 *len = i;
3482
3483 return;
3484 }
3485
3486 if (*ptr != '\n') continue;
3487
3488 *off = i + 1;
3489
3490 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3491
3492 *len = i;
3493
3494 return;
3495 }
3496
3497 *off = sz;
3498 *len = sz;
3499 }
3500
3501 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3502 {
3503 char *ptr = buf;
3504
3505 for (u32 i = 0; i < sz; i++, ptr++)
3506 {
3507 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3508
3509 if (*ptr != '\n') continue;
3510
3511 *off = i + 1;
3512
3513 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3514
3515 *len = i;
3516
3517 return;
3518 }
3519
3520 *off = sz;
3521 *len = sz;
3522 }
3523
3524 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3525 {
3526 char *ptr = buf;
3527
3528 for (u32 i = 0; i < sz; i++, ptr++)
3529 {
3530 if (*ptr != '\n') continue;
3531
3532 *off = i + 1;
3533
3534 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3535
3536 *len = i;
3537
3538 return;
3539 }
3540
3541 *off = sz;
3542 *len = sz;
3543 }
3544
3545 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3546 {
3547 while (wl_data->pos < wl_data->cnt)
3548 {
3549 uint off;
3550 uint len;
3551
3552 char *ptr = wl_data->buf + wl_data->pos;
3553
3554 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3555
3556 wl_data->pos += off;
3557
3558 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3559 {
3560 char rule_buf_out[BLOCK_SIZE] = { 0 };
3561
3562 int rule_len_out = -1;
3563
3564 if (len < BLOCK_SIZE)
3565 {
3566 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3567 }
3568
3569 if (rule_len_out < 0)
3570 {
3571 continue;
3572 }
3573
3574 if (rule_len_out > PW_MAX)
3575 {
3576 continue;
3577 }
3578 }
3579 else
3580 {
3581 if (len > PW_MAX)
3582 {
3583 continue;
3584 }
3585 }
3586
3587 *out_buf = ptr;
3588 *out_len = len;
3589
3590 return;
3591 }
3592
3593 if (feof (fd))
3594 {
3595 fprintf (stderr, "BUG feof()!!\n");
3596
3597 return;
3598 }
3599
3600 load_segment (wl_data, fd);
3601
3602 get_next_word (wl_data, fd, out_buf, out_len);
3603 }
3604
3605 #ifdef _POSIX
3606 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3607 #endif
3608
3609 #ifdef _WIN
3610 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3611 #endif
3612 {
3613 hc_signal (NULL);
3614
3615 dictstat_t d;
3616
3617 d.cnt = 0;
3618
3619 #ifdef _POSIX
3620 fstat (fileno (fd), &d.stat);
3621 #endif
3622
3623 #ifdef _WIN
3624 _fstat64 (fileno (fd), &d.stat);
3625 #endif
3626
3627 d.stat.st_mode = 0;
3628 d.stat.st_nlink = 0;
3629 d.stat.st_uid = 0;
3630 d.stat.st_gid = 0;
3631 d.stat.st_rdev = 0;
3632 d.stat.st_atime = 0;
3633
3634 #ifdef _POSIX
3635 d.stat.st_blksize = 0;
3636 d.stat.st_blocks = 0;
3637 #endif
3638
3639 if (d.stat.st_size == 0) return 0;
3640
3641 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3642
3643 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3644 {
3645 if (d_cache)
3646 {
3647 u64 cnt = d_cache->cnt;
3648
3649 u64 keyspace = cnt;
3650
3651 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3652 {
3653 keyspace *= data.kernel_rules_cnt;
3654 }
3655 else if (data.attack_kern == ATTACK_KERN_COMBI)
3656 {
3657 keyspace *= data.combs_cnt;
3658 }
3659
3660 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);
3661 if (data.quiet == 0) log_info ("");
3662
3663 hc_signal (sigHandler_default);
3664
3665 return (keyspace);
3666 }
3667 }
3668
3669 time_t now = 0;
3670 time_t prev = 0;
3671
3672 u64 comp = 0;
3673 u64 cnt = 0;
3674 u64 cnt2 = 0;
3675
3676 while (!feof (fd))
3677 {
3678 load_segment (wl_data, fd);
3679
3680 comp += wl_data->cnt;
3681
3682 u32 i = 0;
3683
3684 while (i < wl_data->cnt)
3685 {
3686 u32 len;
3687 u32 off;
3688
3689 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3690
3691 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3692 {
3693 char rule_buf_out[BLOCK_SIZE] = { 0 };
3694
3695 int rule_len_out = -1;
3696
3697 if (len < BLOCK_SIZE)
3698 {
3699 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3700 }
3701
3702 if (rule_len_out < 0)
3703 {
3704 len = PW_MAX1;
3705 }
3706 else
3707 {
3708 len = rule_len_out;
3709 }
3710 }
3711
3712 if (len < PW_MAX1)
3713 {
3714 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3715 {
3716 cnt += data.kernel_rules_cnt;
3717 }
3718 else if (data.attack_kern == ATTACK_KERN_COMBI)
3719 {
3720 cnt += data.combs_cnt;
3721 }
3722
3723 d.cnt++;
3724 }
3725
3726 i += off;
3727
3728 cnt2++;
3729 }
3730
3731 time (&now);
3732
3733 if ((now - prev) == 0) continue;
3734
3735 float percent = (float) comp / (float) d.stat.st_size;
3736
3737 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);
3738
3739 time (&prev);
3740 }
3741
3742 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);
3743 if (data.quiet == 0) log_info ("");
3744
3745 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3746
3747 hc_signal (sigHandler_default);
3748
3749 return (cnt);
3750 }
3751
3752 static void *thread_monitor (void *p)
3753 {
3754 uint runtime_check = 0;
3755 uint remove_check = 0;
3756 uint status_check = 0;
3757 uint restore_check = 0;
3758
3759 uint restore_left = data.restore_timer;
3760 uint remove_left = data.remove_timer;
3761 uint status_left = data.status_timer;
3762
3763 #ifdef HAVE_HWMON
3764 uint hwmon_check = 0;
3765
3766 int slowdown_warnings = 0;
3767
3768 // these variables are mainly used for fan control (AMD only)
3769
3770 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3771
3772 // temperature controller "loopback" values
3773
3774 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3775 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3776
3777 #ifdef HAVE_ADL
3778 int temp_threshold = 1; // degrees celcius
3779
3780 int fan_speed_min = 15; // in percentage
3781 int fan_speed_max = 100;
3782 #endif // HAVE_ADL
3783
3784 time_t last_temp_check_time;
3785 #endif // HAVE_HWMON
3786
3787 uint sleep_time = 1;
3788
3789 if (data.runtime)
3790 {
3791 runtime_check = 1;
3792 }
3793
3794 if (data.restore_timer)
3795 {
3796 restore_check = 1;
3797 }
3798
3799 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3800 {
3801 remove_check = 1;
3802 }
3803
3804 if (data.status == 1)
3805 {
3806 status_check = 1;
3807 }
3808
3809 #ifdef HAVE_HWMON
3810 if (data.gpu_temp_disable == 0)
3811 {
3812 time (&last_temp_check_time);
3813
3814 hwmon_check = 1;
3815 }
3816 #endif
3817
3818 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3819 {
3820 #ifdef HAVE_HWMON
3821 if (hwmon_check == 0)
3822 #endif
3823 return (p);
3824 }
3825
3826 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3827 {
3828 hc_sleep (sleep_time);
3829
3830 if (data.devices_status != STATUS_RUNNING) continue;
3831
3832 #ifdef HAVE_HWMON
3833
3834 if (1)
3835 {
3836 hc_thread_mutex_lock (mux_adl);
3837
3838 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3839 {
3840 hc_device_param_t *device_param = &data.devices_param[device_id];
3841
3842 if (device_param->skipped) continue;
3843
3844 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3845
3846 const int temperature = hm_get_temperature_with_device_id (device_id);
3847
3848 const int threshold = data.hm_device[device_id].gpu_temp_threshold_slowdown;
3849
3850 if (temperature >= threshold)
3851 {
3852 if (slowdown_warnings < 3)
3853 {
3854 if (data.quiet == 0) clear_prompt ();
3855
3856 log_info ("WARNING: Drivers temperature threshold (%dc) hit on GPU #%d, expect performance to drop...", threshold, device_id + 1);
3857
3858 if (slowdown_warnings == 2)
3859 {
3860 log_info ("");
3861 }
3862
3863 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3864 if (data.quiet == 0) fflush (stdout);
3865
3866 slowdown_warnings++;
3867 }
3868 }
3869 else
3870 {
3871 slowdown_warnings = 0;
3872 }
3873 }
3874
3875 hc_thread_mutex_unlock (mux_adl);
3876 }
3877
3878 if (hwmon_check == 1)
3879 {
3880 hc_thread_mutex_lock (mux_adl);
3881
3882 time_t temp_check_time;
3883
3884 time (&temp_check_time);
3885
3886 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3887
3888 if (Ta == 0) Ta = 1;
3889
3890 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3891 {
3892 hc_device_param_t *device_param = &data.devices_param[device_id];
3893
3894 if (device_param->skipped) continue;
3895
3896 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3897
3898 const int temperature = hm_get_temperature_with_device_id (device_id);
3899
3900 if (temperature > (int) data.gpu_temp_abort)
3901 {
3902 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3903
3904 if (data.devices_status != STATUS_QUIT) myabort ();
3905
3906 break;
3907 }
3908
3909 #ifdef HAVE_ADL
3910 const int gpu_temp_retain = data.gpu_temp_retain;
3911
3912 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3913 {
3914 if (data.hm_device[device_id].fan_supported == 1)
3915 {
3916 int temp_cur = temperature;
3917
3918 int temp_diff_new = gpu_temp_retain - temp_cur;
3919
3920 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3921
3922 // calculate Ta value (time difference in seconds between the last check and this check)
3923
3924 last_temp_check_time = temp_check_time;
3925
3926 float Kp = 1.8;
3927 float Ki = 0.005;
3928 float Kd = 6;
3929
3930 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3931
3932 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);
3933
3934 if (abs (fan_diff_required) >= temp_threshold)
3935 {
3936 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3937
3938 int fan_speed_level = fan_speed_cur;
3939
3940 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3941
3942 int fan_speed_new = fan_speed_level - fan_diff_required;
3943
3944 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3945 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3946
3947 if (fan_speed_new != fan_speed_cur)
3948 {
3949 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3950 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3951
3952 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3953 {
3954 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3955
3956 fan_speed_chgd[device_id] = 1;
3957 }
3958
3959 temp_diff_old[device_id] = temp_diff_new;
3960 }
3961 }
3962 }
3963 }
3964 #endif // HAVE_ADL
3965 }
3966
3967 hc_thread_mutex_unlock (mux_adl);
3968 }
3969 #endif // HAVE_HWMON
3970
3971 if (restore_check == 1)
3972 {
3973 restore_left--;
3974
3975 if (restore_left == 0)
3976 {
3977 if (data.restore_disable == 0) cycle_restore ();
3978
3979 restore_left = data.restore_timer;
3980 }
3981 }
3982
3983 if ((runtime_check == 1) && (data.runtime_start > 0))
3984 {
3985 time_t runtime_cur;
3986
3987 time (&runtime_cur);
3988
3989 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3990
3991 if (runtime_left <= 0)
3992 {
3993 if (data.benchmark == 0)
3994 {
3995 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3996 }
3997
3998 if (data.devices_status != STATUS_QUIT) myabort ();
3999 }
4000 }
4001
4002 if (remove_check == 1)
4003 {
4004 remove_left--;
4005
4006 if (remove_left == 0)
4007 {
4008 if (data.digests_saved != data.digests_done)
4009 {
4010 data.digests_saved = data.digests_done;
4011
4012 save_hash ();
4013 }
4014
4015 remove_left = data.remove_timer;
4016 }
4017 }
4018
4019 if (status_check == 1)
4020 {
4021 status_left--;
4022
4023 if (status_left == 0)
4024 {
4025 //hc_thread_mutex_lock (mux_display);
4026
4027 if (data.quiet == 0) clear_prompt ();
4028
4029 if (data.quiet == 0) log_info ("");
4030
4031 status_display ();
4032
4033 if (data.quiet == 0) log_info ("");
4034
4035 //hc_thread_mutex_unlock (mux_display);
4036
4037 status_left = data.status_timer;
4038 }
4039 }
4040 }
4041
4042 #ifdef HAVE_HWMON
4043 myfree (fan_speed_chgd);
4044
4045 myfree (temp_diff_old);
4046 myfree (temp_diff_sum);
4047 #endif
4048
4049 p = NULL;
4050
4051 return (p);
4052 }
4053
4054 static void *thread_outfile_remove (void *p)
4055 {
4056 // some hash-dependent constants
4057 char *outfile_dir = data.outfile_check_directory;
4058 uint dgst_size = data.dgst_size;
4059 uint isSalted = data.isSalted;
4060 uint esalt_size = data.esalt_size;
4061 uint hash_mode = data.hash_mode;
4062
4063 uint outfile_check_timer = data.outfile_check_timer;
4064
4065 char separator = data.separator;
4066
4067 // some hash-dependent functions
4068 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4069 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4070
4071 // buffers
4072 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4073
4074 hash_buf.digest = mymalloc (dgst_size);
4075
4076 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4077
4078 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4079
4080 uint digest_buf[64] = { 0 };
4081
4082 outfile_data_t *out_info = NULL;
4083
4084 char **out_files = NULL;
4085
4086 time_t folder_mtime = 0;
4087
4088 int out_cnt = 0;
4089
4090 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4091
4092 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4093 {
4094 hc_sleep (1);
4095
4096 if (data.devices_status != STATUS_RUNNING) continue;
4097
4098 check_left--;
4099
4100 if (check_left == 0)
4101 {
4102 struct stat outfile_check_stat;
4103
4104 if (stat (outfile_dir, &outfile_check_stat) == 0)
4105 {
4106 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4107
4108 if (is_dir == 1)
4109 {
4110 if (outfile_check_stat.st_mtime > folder_mtime)
4111 {
4112 char **out_files_new = scan_directory (outfile_dir);
4113
4114 int out_cnt_new = count_dictionaries (out_files_new);
4115
4116 outfile_data_t *out_info_new = NULL;
4117
4118 if (out_cnt_new > 0)
4119 {
4120 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4121
4122 for (int i = 0; i < out_cnt_new; i++)
4123 {
4124 out_info_new[i].file_name = out_files_new[i];
4125
4126 // check if there are files that we have seen/checked before (and not changed)
4127
4128 for (int j = 0; j < out_cnt; j++)
4129 {
4130 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4131 {
4132 struct stat outfile_stat;
4133
4134 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4135 {
4136 if (outfile_stat.st_ctime == out_info[j].ctime)
4137 {
4138 out_info_new[i].ctime = out_info[j].ctime;
4139 out_info_new[i].seek = out_info[j].seek;
4140 }
4141 }
4142 }
4143 }
4144 }
4145 }
4146
4147 local_free (out_info);
4148 local_free (out_files);
4149
4150 out_files = out_files_new;
4151 out_cnt = out_cnt_new;
4152 out_info = out_info_new;
4153
4154 folder_mtime = outfile_check_stat.st_mtime;
4155 }
4156
4157 for (int j = 0; j < out_cnt; j++)
4158 {
4159 FILE *fp = fopen (out_info[j].file_name, "rb");
4160
4161 if (fp != NULL)
4162 {
4163 //hc_thread_mutex_lock (mux_display);
4164
4165 #ifdef _POSIX
4166 struct stat outfile_stat;
4167
4168 fstat (fileno (fp), &outfile_stat);
4169 #endif
4170
4171 #ifdef _WIN
4172 struct stat64 outfile_stat;
4173
4174 _fstat64 (fileno (fp), &outfile_stat);
4175 #endif
4176
4177 if (outfile_stat.st_ctime > out_info[j].ctime)
4178 {
4179 out_info[j].ctime = outfile_stat.st_ctime;
4180 out_info[j].seek = 0;
4181 }
4182
4183 fseek (fp, out_info[j].seek, SEEK_SET);
4184
4185 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4186
4187 while (!feof (fp))
4188 {
4189 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4190
4191 if (ptr == NULL) break;
4192
4193 int line_len = strlen (line_buf);
4194
4195 if (line_len <= 0) continue;
4196
4197 int iter = MAX_CUT_TRIES;
4198
4199 for (uint i = line_len - 1; i && iter; i--, line_len--)
4200 {
4201 if (line_buf[i] != separator) continue;
4202
4203 int parser_status = PARSER_OK;
4204
4205 if ((hash_mode != 2500) && (hash_mode != 6800))
4206 {
4207 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4208 }
4209
4210 uint found = 0;
4211
4212 if (parser_status == PARSER_OK)
4213 {
4214 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4215 {
4216 if (data.salts_shown[salt_pos] == 1) continue;
4217
4218 salt_t *salt_buf = &data.salts_buf[salt_pos];
4219
4220 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4221 {
4222 uint idx = salt_buf->digests_offset + digest_pos;
4223
4224 if (data.digests_shown[idx] == 1) continue;
4225
4226 uint cracked = 0;
4227
4228 if (hash_mode == 6800)
4229 {
4230 if (i == salt_buf->salt_len)
4231 {
4232 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4233 }
4234 }
4235 else if (hash_mode == 2500)
4236 {
4237 // BSSID : MAC1 : MAC2 (:plain)
4238 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4239 {
4240 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4241
4242 if (!cracked) continue;
4243
4244 // now compare MAC1 and MAC2 too, since we have this additional info
4245 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4246 char *mac2_pos = mac1_pos + 12 + 1;
4247
4248 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4249 wpa_t *wpa = &wpas[salt_pos];
4250
4251 // compare hex string(s) vs binary MAC address(es)
4252
4253 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4254 {
4255 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4256 {
4257 cracked = 0;
4258
4259 break;
4260 }
4261 }
4262
4263 // early skip ;)
4264 if (!cracked) continue;
4265
4266 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4267 {
4268 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4269 {
4270 cracked = 0;
4271
4272 break;
4273 }
4274 }
4275 }
4276 }
4277 else
4278 {
4279 char *digests_buf_ptr = (char *) data.digests_buf;
4280
4281 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4282
4283 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4284 }
4285
4286 if (cracked == 1)
4287 {
4288 found = 1;
4289
4290 data.digests_shown[idx] = 1;
4291
4292 data.digests_done++;
4293
4294 salt_buf->digests_done++;
4295
4296 if (salt_buf->digests_done == salt_buf->digests_cnt)
4297 {
4298 data.salts_shown[salt_pos] = 1;
4299
4300 data.salts_done++;
4301
4302 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4303 }
4304 }
4305 }
4306
4307 if (data.devices_status == STATUS_CRACKED) break;
4308 }
4309 }
4310
4311 if (found) break;
4312
4313 if (data.devices_status == STATUS_CRACKED) break;
4314
4315 iter--;
4316 }
4317
4318 if (data.devices_status == STATUS_CRACKED) break;
4319 }
4320
4321 myfree (line_buf);
4322
4323 out_info[j].seek = ftell (fp);
4324
4325 //hc_thread_mutex_unlock (mux_display);
4326
4327 fclose (fp);
4328 }
4329 }
4330 }
4331 }
4332
4333 check_left = outfile_check_timer;
4334 }
4335 }
4336
4337 if (esalt_size) local_free (hash_buf.esalt);
4338
4339 if (isSalted) local_free (hash_buf.salt);
4340
4341 local_free (hash_buf.digest);
4342
4343 local_free (out_info);
4344
4345 local_free (out_files);
4346
4347 p = NULL;
4348
4349 return (p);
4350 }
4351
4352 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4353 {
4354 if (device_param->pws_cnt < device_param->kernel_power)
4355 {
4356 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4357
4358 u8 *ptr = (u8 *) pw->i;
4359
4360 memcpy (ptr, pw_buf, pw_len);
4361
4362 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4363
4364 pw->pw_len = pw_len;
4365
4366 device_param->pws_cnt++;
4367 }
4368 else
4369 {
4370 fprintf (stderr, "BUG pw_add()!!\n");
4371
4372 return;
4373 }
4374 }
4375
4376 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4377 {
4378 hc_thread_mutex_lock (mux_dispatcher);
4379
4380 const u64 words_cur = data.words_cur;
4381 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4382
4383 device_param->words_off = words_cur;
4384
4385 const u64 words_left = words_base - words_cur;
4386
4387 if (allow_div)
4388 {
4389 if (data.kernel_power_all > words_left)
4390 {
4391 if (data.kernel_power_div == 0)
4392 {
4393 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4394 }
4395 }
4396
4397 if (data.kernel_power_div)
4398 {
4399 if (device_param->kernel_power == device_param->kernel_power_user)
4400 {
4401 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4402
4403 if (kernel_power_new < device_param->kernel_power)
4404 {
4405 device_param->kernel_power = kernel_power_new;
4406 }
4407 }
4408 }
4409 }
4410
4411 const uint kernel_power = device_param->kernel_power;
4412
4413 uint work = MIN (words_left, kernel_power);
4414
4415 work = MIN (work, max);
4416
4417 data.words_cur += work;
4418
4419 hc_thread_mutex_unlock (mux_dispatcher);
4420
4421 return work;
4422 }
4423
4424 static void *thread_calc_stdin (void *p)
4425 {
4426 hc_device_param_t *device_param = (hc_device_param_t *) p;
4427
4428 if (device_param->skipped) return NULL;
4429
4430 autotune (device_param);
4431
4432 char *buf = (char *) mymalloc (HCBUFSIZ);
4433
4434 const uint attack_kern = data.attack_kern;
4435
4436 const uint kernel_power = device_param->kernel_power;
4437
4438 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4439 {
4440 hc_thread_mutex_lock (mux_dispatcher);
4441
4442 if (feof (stdin) != 0)
4443 {
4444 hc_thread_mutex_unlock (mux_dispatcher);
4445
4446 break;
4447 }
4448
4449 uint words_cur = 0;
4450
4451 while (words_cur < kernel_power)
4452 {
4453 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4454
4455 if (line_buf == NULL) break;
4456
4457 uint line_len = in_superchop (line_buf);
4458
4459 line_len = convert_from_hex (line_buf, line_len);
4460
4461 // post-process rule engine
4462
4463 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4464 {
4465 char rule_buf_out[BLOCK_SIZE] = { 0 };
4466
4467 int rule_len_out = -1;
4468
4469 if (line_len < BLOCK_SIZE)
4470 {
4471 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4472 }
4473
4474 if (rule_len_out < 0) continue;
4475
4476 line_buf = rule_buf_out;
4477 line_len = rule_len_out;
4478 }
4479
4480 if (line_len > PW_MAX)
4481 {
4482 continue;
4483 }
4484
4485 if (attack_kern == ATTACK_KERN_STRAIGHT)
4486 {
4487 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4488 {
4489 hc_thread_mutex_lock (mux_counter);
4490
4491 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4492 {
4493 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4494 }
4495
4496 hc_thread_mutex_unlock (mux_counter);
4497
4498 continue;
4499 }
4500 }
4501 else if (attack_kern == ATTACK_KERN_COMBI)
4502 {
4503 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4504 // since we still need to combine the plains
4505
4506 if (line_len > data.pw_max)
4507 {
4508 hc_thread_mutex_lock (mux_counter);
4509
4510 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4511 {
4512 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4513 }
4514
4515 hc_thread_mutex_unlock (mux_counter);
4516
4517 continue;
4518 }
4519 }
4520
4521 pw_add (device_param, (u8 *) line_buf, line_len);
4522
4523 words_cur++;
4524
4525 if (data.devices_status == STATUS_CRACKED) break;
4526 if (data.devices_status == STATUS_ABORTED) break;
4527 if (data.devices_status == STATUS_QUIT) break;
4528 if (data.devices_status == STATUS_BYPASS) break;
4529 }
4530
4531 hc_thread_mutex_unlock (mux_dispatcher);
4532
4533 if (data.devices_status == STATUS_CRACKED) break;
4534 if (data.devices_status == STATUS_ABORTED) break;
4535 if (data.devices_status == STATUS_QUIT) break;
4536 if (data.devices_status == STATUS_BYPASS) break;
4537
4538 // flush
4539
4540 const uint pws_cnt = device_param->pws_cnt;
4541
4542 if (pws_cnt)
4543 {
4544 run_copy (device_param, pws_cnt);
4545
4546 run_cracker (device_param, pws_cnt);
4547
4548 device_param->pws_cnt = 0;
4549
4550 /*
4551 still required?
4552 if (attack_kern == ATTACK_KERN_STRAIGHT)
4553 {
4554 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4555 }
4556 else if (attack_kern == ATTACK_KERN_COMBI)
4557 {
4558 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4559 }
4560 */
4561 }
4562 }
4563
4564 device_param->kernel_accel = 0;
4565 device_param->kernel_loops = 0;
4566
4567 myfree (buf);
4568
4569 return NULL;
4570 }
4571
4572 static void *thread_calc (void *p)
4573 {
4574 hc_device_param_t *device_param = (hc_device_param_t *) p;
4575
4576 if (device_param->skipped) return NULL;
4577
4578 autotune (device_param);
4579
4580 const uint attack_mode = data.attack_mode;
4581 const uint attack_kern = data.attack_kern;
4582
4583 if (attack_mode == ATTACK_MODE_BF)
4584 {
4585 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4586 {
4587 const uint work = get_work (device_param, -1, true);
4588
4589 if (work == 0) break;
4590
4591 const u64 words_off = device_param->words_off;
4592 const u64 words_fin = words_off + work;
4593
4594 const uint pws_cnt = work;
4595
4596 device_param->pws_cnt = pws_cnt;
4597
4598 if (pws_cnt)
4599 {
4600 run_copy (device_param, pws_cnt);
4601
4602 run_cracker (device_param, pws_cnt);
4603
4604 device_param->pws_cnt = 0;
4605
4606 /*
4607 still required?
4608 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4609 */
4610 }
4611
4612 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4613
4614 if (data.devices_status == STATUS_CRACKED) break;
4615 if (data.devices_status == STATUS_ABORTED) break;
4616 if (data.devices_status == STATUS_QUIT) break;
4617 if (data.devices_status == STATUS_BYPASS) break;
4618
4619 if (data.benchmark == 1) break;
4620
4621 device_param->words_done = words_fin;
4622 }
4623 }
4624 else
4625 {
4626 const uint segment_size = data.segment_size;
4627
4628 char *dictfile = data.dictfile;
4629
4630 if (attack_mode == ATTACK_MODE_COMBI)
4631 {
4632 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4633 {
4634 dictfile = data.dictfile2;
4635 }
4636 }
4637
4638 FILE *fd = fopen (dictfile, "rb");
4639
4640 if (fd == NULL)
4641 {
4642 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4643
4644 return NULL;
4645 }
4646
4647 if (attack_mode == ATTACK_MODE_COMBI)
4648 {
4649 const uint combs_mode = data.combs_mode;
4650
4651 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4652 {
4653 const char *dictfilec = data.dictfile2;
4654
4655 FILE *combs_fp = fopen (dictfilec, "rb");
4656
4657 if (combs_fp == NULL)
4658 {
4659 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4660
4661 fclose (fd);
4662
4663 return NULL;
4664 }
4665
4666 device_param->combs_fp = combs_fp;
4667 }
4668 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4669 {
4670 const char *dictfilec = data.dictfile;
4671
4672 FILE *combs_fp = fopen (dictfilec, "rb");
4673
4674 if (combs_fp == NULL)
4675 {
4676 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4677
4678 fclose (fd);
4679
4680 return NULL;
4681 }
4682
4683 device_param->combs_fp = combs_fp;
4684 }
4685 }
4686
4687 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4688
4689 wl_data->buf = (char *) mymalloc (segment_size);
4690 wl_data->avail = segment_size;
4691 wl_data->incr = segment_size;
4692 wl_data->cnt = 0;
4693 wl_data->pos = 0;
4694
4695 u64 words_cur = 0;
4696
4697 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4698 {
4699 u64 words_off = 0;
4700 u64 words_fin = 0;
4701
4702 bool allow_div = true;
4703
4704 u64 max = -1;
4705
4706 while (max)
4707 {
4708 const uint work = get_work (device_param, max, allow_div);
4709
4710 allow_div = false;
4711
4712 if (work == 0) break;
4713
4714 words_off = device_param->words_off;
4715 words_fin = words_off + work;
4716
4717 char *line_buf;
4718 uint line_len;
4719
4720 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4721
4722 max = 0;
4723
4724 for ( ; words_cur < words_fin; words_cur++)
4725 {
4726 get_next_word (wl_data, fd, &line_buf, &line_len);
4727
4728 line_len = convert_from_hex (line_buf, line_len);
4729
4730 // post-process rule engine
4731
4732 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4733 {
4734 char rule_buf_out[BLOCK_SIZE] = { 0 };
4735
4736 int rule_len_out = -1;
4737
4738 if (line_len < BLOCK_SIZE)
4739 {
4740 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4741 }
4742
4743 if (rule_len_out < 0) continue;
4744
4745 line_buf = rule_buf_out;
4746 line_len = rule_len_out;
4747 }
4748
4749 if (attack_kern == ATTACK_KERN_STRAIGHT)
4750 {
4751 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4752 {
4753 max++;
4754
4755 hc_thread_mutex_lock (mux_counter);
4756
4757 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4758 {
4759 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4760 }
4761
4762 hc_thread_mutex_unlock (mux_counter);
4763
4764 continue;
4765 }
4766 }
4767 else if (attack_kern == ATTACK_KERN_COMBI)
4768 {
4769 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4770 // since we still need to combine the plains
4771
4772 if (line_len > data.pw_max)
4773 {
4774 max++;
4775
4776 hc_thread_mutex_lock (mux_counter);
4777
4778 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4779 {
4780 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4781 }
4782
4783 hc_thread_mutex_unlock (mux_counter);
4784
4785 continue;
4786 }
4787 }
4788
4789 pw_add (device_param, (u8 *) line_buf, line_len);
4790
4791 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4792
4793 if (data.devices_status == STATUS_CRACKED) break;
4794 if (data.devices_status == STATUS_ABORTED) break;
4795 if (data.devices_status == STATUS_QUIT) break;
4796 if (data.devices_status == STATUS_BYPASS) break;
4797 }
4798
4799 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4800
4801 if (data.devices_status == STATUS_CRACKED) break;
4802 if (data.devices_status == STATUS_ABORTED) break;
4803 if (data.devices_status == STATUS_QUIT) break;
4804 if (data.devices_status == STATUS_BYPASS) break;
4805 }
4806
4807 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4808
4809 if (data.devices_status == STATUS_CRACKED) break;
4810 if (data.devices_status == STATUS_ABORTED) break;
4811 if (data.devices_status == STATUS_QUIT) break;
4812 if (data.devices_status == STATUS_BYPASS) break;
4813
4814 //
4815 // flush
4816 //
4817
4818 const uint pws_cnt = device_param->pws_cnt;
4819
4820 if (pws_cnt)
4821 {
4822 run_copy (device_param, pws_cnt);
4823
4824 run_cracker (device_param, pws_cnt);
4825
4826 device_param->pws_cnt = 0;
4827
4828 /*
4829 still required?
4830 if (attack_kern == ATTACK_KERN_STRAIGHT)
4831 {
4832 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4833 }
4834 else if (attack_kern == ATTACK_KERN_COMBI)
4835 {
4836 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4837 }
4838 */
4839 }
4840
4841 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4842
4843 if (data.devices_status == STATUS_CRACKED) break;
4844 if (data.devices_status == STATUS_ABORTED) break;
4845 if (data.devices_status == STATUS_QUIT) break;
4846 if (data.devices_status == STATUS_BYPASS) break;
4847
4848 if (words_fin == 0) break;
4849
4850 device_param->words_done = words_fin;
4851 }
4852
4853 if (attack_mode == ATTACK_MODE_COMBI)
4854 {
4855 fclose (device_param->combs_fp);
4856 }
4857
4858 free (wl_data->buf);
4859 free (wl_data);
4860
4861 fclose (fd);
4862 }
4863
4864 device_param->kernel_accel = 0;
4865 device_param->kernel_loops = 0;
4866
4867 return NULL;
4868 }
4869
4870 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4871 {
4872 if (!device_param)
4873 {
4874 log_error ("ERROR: %s : Invalid argument", __func__);
4875
4876 exit (-1);
4877 }
4878
4879 salt_t *salt_buf = &data.salts_buf[salt_pos];
4880
4881 device_param->kernel_params_buf32[24] = salt_pos;
4882 device_param->kernel_params_buf32[27] = 1;
4883 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4884 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4885 device_param->kernel_params_buf32[30] = 0;
4886 device_param->kernel_params_buf32[31] = 1;
4887
4888 char *dictfile_old = data.dictfile;
4889
4890 const char *weak_hash_check = "weak-hash-check";
4891
4892 data.dictfile = (char *) weak_hash_check;
4893
4894 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4895
4896 data.kernel_rules_buf[0].cmds[0] = 0;
4897
4898 /**
4899 * run the kernel
4900 */
4901
4902 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4903 {
4904 run_kernel (KERN_RUN_1, device_param, 1, false);
4905 }
4906 else
4907 {
4908 run_kernel (KERN_RUN_1, device_param, 1, false);
4909
4910 uint loop_step = 16;
4911
4912 const uint iter = salt_buf->salt_iter;
4913
4914 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4915 {
4916 uint loop_left = iter - loop_pos;
4917
4918 loop_left = MIN (loop_left, loop_step);
4919
4920 device_param->kernel_params_buf32[25] = loop_pos;
4921 device_param->kernel_params_buf32[26] = loop_left;
4922
4923 run_kernel (KERN_RUN_2, device_param, 1, false);
4924 }
4925
4926 run_kernel (KERN_RUN_3, device_param, 1, false);
4927 }
4928
4929 /**
4930 * result
4931 */
4932
4933 check_cracked (device_param, salt_pos);
4934
4935 /**
4936 * cleanup
4937 */
4938
4939 device_param->kernel_params_buf32[24] = 0;
4940 device_param->kernel_params_buf32[25] = 0;
4941 device_param->kernel_params_buf32[26] = 0;
4942 device_param->kernel_params_buf32[27] = 0;
4943 device_param->kernel_params_buf32[28] = 0;
4944 device_param->kernel_params_buf32[29] = 0;
4945 device_param->kernel_params_buf32[30] = 0;
4946 device_param->kernel_params_buf32[31] = 0;
4947
4948 data.dictfile = dictfile_old;
4949
4950 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4951 }
4952
4953 // hlfmt hashcat
4954
4955 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4956 {
4957 if (data.username == 0)
4958 {
4959 *hashbuf_pos = line_buf;
4960 *hashbuf_len = line_len;
4961 }
4962 else
4963 {
4964 char *pos = line_buf;
4965 int len = line_len;
4966
4967 for (int i = 0; i < line_len; i++, pos++, len--)
4968 {
4969 if (line_buf[i] == data.separator)
4970 {
4971 pos++;
4972
4973 len--;
4974
4975 break;
4976 }
4977 }
4978
4979 *hashbuf_pos = pos;
4980 *hashbuf_len = len;
4981 }
4982 }
4983
4984 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4985 {
4986 char *pos = NULL;
4987 int len = 0;
4988
4989 int sep_cnt = 0;
4990
4991 for (int i = 0; i < line_len; i++)
4992 {
4993 if (line_buf[i] == data.separator)
4994 {
4995 sep_cnt++;
4996
4997 continue;
4998 }
4999
5000 if (sep_cnt == 0)
5001 {
5002 if (pos == NULL) pos = line_buf + i;
5003
5004 len++;
5005 }
5006 }
5007
5008 *userbuf_pos = pos;
5009 *userbuf_len = len;
5010 }
5011
5012 // hlfmt pwdump
5013
5014 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5015 {
5016 int sep_cnt = 0;
5017
5018 int sep2_len = 0;
5019 int sep3_len = 0;
5020
5021 for (int i = 0; i < line_len; i++)
5022 {
5023 if (line_buf[i] == ':')
5024 {
5025 sep_cnt++;
5026
5027 continue;
5028 }
5029
5030 if (sep_cnt == 2) sep2_len++;
5031 if (sep_cnt == 3) sep3_len++;
5032 }
5033
5034 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5035
5036 return 0;
5037 }
5038
5039 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5040 {
5041 char *pos = NULL;
5042 int len = 0;
5043
5044 int sep_cnt = 0;
5045
5046 for (int i = 0; i < line_len; i++)
5047 {
5048 if (line_buf[i] == ':')
5049 {
5050 sep_cnt++;
5051
5052 continue;
5053 }
5054
5055 if (data.hash_mode == 1000)
5056 {
5057 if (sep_cnt == 3)
5058 {
5059 if (pos == NULL) pos = line_buf + i;
5060
5061 len++;
5062 }
5063 }
5064 else if (data.hash_mode == 3000)
5065 {
5066 if (sep_cnt == 2)
5067 {
5068 if (pos == NULL) pos = line_buf + i;
5069
5070 len++;
5071 }
5072 }
5073 }
5074
5075 *hashbuf_pos = pos;
5076 *hashbuf_len = len;
5077 }
5078
5079 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5080 {
5081 char *pos = NULL;
5082 int len = 0;
5083
5084 int sep_cnt = 0;
5085
5086 for (int i = 0; i < line_len; i++)
5087 {
5088 if (line_buf[i] == ':')
5089 {
5090 sep_cnt++;
5091
5092 continue;
5093 }
5094
5095 if (sep_cnt == 0)
5096 {
5097 if (pos == NULL) pos = line_buf + i;
5098
5099 len++;
5100 }
5101 }
5102
5103 *userbuf_pos = pos;
5104 *userbuf_len = len;
5105 }
5106
5107 // hlfmt passwd
5108
5109 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5110 {
5111 int sep_cnt = 0;
5112
5113 char sep5_first = 0;
5114 char sep6_first = 0;
5115
5116 for (int i = 0; i < line_len; i++)
5117 {
5118 if (line_buf[i] == ':')
5119 {
5120 sep_cnt++;
5121
5122 continue;
5123 }
5124
5125 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5126 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5127 }
5128
5129 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5130
5131 return 0;
5132 }
5133
5134 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5135 {
5136 char *pos = NULL;
5137 int len = 0;
5138
5139 int sep_cnt = 0;
5140
5141 for (int i = 0; i < line_len; i++)
5142 {
5143 if (line_buf[i] == ':')
5144 {
5145 sep_cnt++;
5146
5147 continue;
5148 }
5149
5150 if (sep_cnt == 1)
5151 {
5152 if (pos == NULL) pos = line_buf + i;
5153
5154 len++;
5155 }
5156 }
5157
5158 *hashbuf_pos = pos;
5159 *hashbuf_len = len;
5160 }
5161
5162 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5163 {
5164 char *pos = NULL;
5165 int len = 0;
5166
5167 int sep_cnt = 0;
5168
5169 for (int i = 0; i < line_len; i++)
5170 {
5171 if (line_buf[i] == ':')
5172 {
5173 sep_cnt++;
5174
5175 continue;
5176 }
5177
5178 if (sep_cnt == 0)
5179 {
5180 if (pos == NULL) pos = line_buf + i;
5181
5182 len++;
5183 }
5184 }
5185
5186 *userbuf_pos = pos;
5187 *userbuf_len = len;
5188 }
5189
5190 // hlfmt shadow
5191
5192 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5193 {
5194 int sep_cnt = 0;
5195
5196 for (int i = 0; i < line_len; i++)
5197 {
5198 if (line_buf[i] == ':') sep_cnt++;
5199 }
5200
5201 if (sep_cnt == 8) return 1;
5202
5203 return 0;
5204 }
5205
5206 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5207 {
5208 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5209 }
5210
5211 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5212 {
5213 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5214 }
5215
5216 // hlfmt main
5217
5218 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5219 {
5220 switch (hashfile_format)
5221 {
5222 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5223 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5224 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5225 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5226 }
5227 }
5228
5229 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5230 {
5231 switch (hashfile_format)
5232 {
5233 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5234 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5235 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5236 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5237 }
5238 }
5239
5240 char *strhlfmt (const uint hashfile_format)
5241 {
5242 switch (hashfile_format)
5243 {
5244 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5245 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5246 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5247 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5248 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5249 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5250 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5251 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5252 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5253 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5254 }
5255
5256 return ((char *) "Unknown");
5257 }
5258
5259 static uint hlfmt_detect (FILE *fp, uint max_check)
5260 {
5261 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5262
5263 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5264 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5265
5266 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5267
5268 uint num_check = 0;
5269
5270 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5271
5272 while (!feof (fp))
5273 {
5274 int line_len = fgetl (fp, line_buf);
5275
5276 if (line_len == 0) continue;
5277
5278 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5279 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5280 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5281
5282 if (num_check == max_check) break;
5283
5284 num_check++;
5285 }
5286
5287 myfree (line_buf);
5288
5289 uint hashlist_format = HLFMT_HASHCAT;
5290
5291 for (int i = 1; i < HLFMTS_CNT; i++)
5292 {
5293 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5294
5295 hashlist_format = i;
5296 }
5297
5298 free (formats_cnt);
5299
5300 return hashlist_format;
5301 }
5302
5303 /**
5304 * some further helper function
5305 */
5306
5307 // wrapper around mymalloc for ADL
5308
5309 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5310 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5311 {
5312 return mymalloc (iSize);
5313 }
5314 #endif
5315
5316 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)
5317 {
5318 u64 collisions = 0;
5319
5320 const uint dgst_pos0 = data.dgst_pos0;
5321 const uint dgst_pos1 = data.dgst_pos1;
5322 const uint dgst_pos2 = data.dgst_pos2;
5323 const uint dgst_pos3 = data.dgst_pos3;
5324
5325 memset (bitmap_a, 0, bitmap_size);
5326 memset (bitmap_b, 0, bitmap_size);
5327 memset (bitmap_c, 0, bitmap_size);
5328 memset (bitmap_d, 0, bitmap_size);
5329
5330 for (uint i = 0; i < digests_cnt; i++)
5331 {
5332 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5333
5334 uint *digest_ptr = (uint *) digests_buf_ptr;
5335
5336 digests_buf_ptr += dgst_size;
5337
5338 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5339 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5340 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5341 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5342
5343 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5344 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5345 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5346 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5347
5348 if (bitmap_a[idx0] & val0) collisions++;
5349 if (bitmap_b[idx1] & val1) collisions++;
5350 if (bitmap_c[idx2] & val2) collisions++;
5351 if (bitmap_d[idx3] & val3) collisions++;
5352
5353 bitmap_a[idx0] |= val0;
5354 bitmap_b[idx1] |= val1;
5355 bitmap_c[idx2] |= val2;
5356 bitmap_d[idx3] |= val3;
5357
5358 if (collisions >= collisions_max) return 0x7fffffff;
5359 }
5360
5361 return collisions;
5362 }
5363
5364 /**
5365 * main
5366 */
5367
5368 #ifdef _WIN
5369 void SetConsoleWindowSize (const int x)
5370 {
5371 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5372
5373 if (h == INVALID_HANDLE_VALUE) return;
5374
5375 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5376
5377 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5378
5379 SMALL_RECT *sr = &bufferInfo.srWindow;
5380
5381 sr->Right = MAX (sr->Right, x - 1);
5382
5383 COORD co;
5384
5385 co.X = sr->Right + 1;
5386 co.Y = sr->Bottom + 1;
5387
5388 if (!SetConsoleScreenBufferSize (h, co)) return;
5389
5390 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5391 }
5392 #endif
5393
5394 int main (int argc, char **argv)
5395 {
5396 #ifdef _WIN
5397 SetConsoleWindowSize (132);
5398 #endif
5399
5400 /**
5401 * To help users a bit
5402 */
5403
5404 char *compute = getenv ("COMPUTE");
5405
5406 if (compute)
5407 {
5408 static char display[100];
5409
5410 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5411
5412 putenv (display);
5413 }
5414 else
5415 {
5416 if (getenv ("DISPLAY") == NULL)
5417 putenv ((char *) "DISPLAY=:0");
5418 }
5419
5420 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5421 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5422
5423 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5424 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5425
5426 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5427 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5428
5429 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5430 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5431
5432 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5433 putenv ((char *) "POCL_KERNEL_CACHE=0");
5434
5435 umask (077);
5436
5437 /**
5438 * Real init
5439 */
5440
5441 memset (&data, 0, sizeof (hc_global_data_t));
5442
5443 time_t proc_start;
5444
5445 time (&proc_start);
5446
5447 data.proc_start = proc_start;
5448
5449 int myargc = argc;
5450 char **myargv = argv;
5451
5452 hc_thread_mutex_init (mux_dispatcher);
5453 hc_thread_mutex_init (mux_counter);
5454 hc_thread_mutex_init (mux_display);
5455 hc_thread_mutex_init (mux_adl);
5456
5457 /**
5458 * commandline parameters
5459 */
5460
5461 uint usage = USAGE;
5462 uint version = VERSION;
5463 uint quiet = QUIET;
5464 uint benchmark = BENCHMARK;
5465 uint show = SHOW;
5466 uint left = LEFT;
5467 uint username = USERNAME;
5468 uint remove = REMOVE;
5469 uint remove_timer = REMOVE_TIMER;
5470 u64 skip = SKIP;
5471 u64 limit = LIMIT;
5472 uint keyspace = KEYSPACE;
5473 uint potfile_disable = POTFILE_DISABLE;
5474 char *potfile_path = NULL;
5475 uint debug_mode = DEBUG_MODE;
5476 char *debug_file = NULL;
5477 char *induction_dir = NULL;
5478 char *outfile_check_dir = NULL;
5479 uint force = FORCE;
5480 uint runtime = RUNTIME;
5481 uint hash_mode = HASH_MODE;
5482 uint attack_mode = ATTACK_MODE;
5483 uint markov_disable = MARKOV_DISABLE;
5484 uint markov_classic = MARKOV_CLASSIC;
5485 uint markov_threshold = MARKOV_THRESHOLD;
5486 char *markov_hcstat = NULL;
5487 char *outfile = NULL;
5488 uint outfile_format = OUTFILE_FORMAT;
5489 uint outfile_autohex = OUTFILE_AUTOHEX;
5490 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5491 uint restore = RESTORE;
5492 uint restore_timer = RESTORE_TIMER;
5493 uint restore_disable = RESTORE_DISABLE;
5494 uint status = STATUS;
5495 uint status_timer = STATUS_TIMER;
5496 uint machine_readable = MACHINE_READABLE;
5497 uint loopback = LOOPBACK;
5498 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5499 char *session = NULL;
5500 uint hex_charset = HEX_CHARSET;
5501 uint hex_salt = HEX_SALT;
5502 uint hex_wordlist = HEX_WORDLIST;
5503 uint rp_gen = RP_GEN;
5504 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5505 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5506 uint rp_gen_seed = RP_GEN_SEED;
5507 char *rule_buf_l = (char *) RULE_BUF_L;
5508 char *rule_buf_r = (char *) RULE_BUF_R;
5509 uint increment = INCREMENT;
5510 uint increment_min = INCREMENT_MIN;
5511 uint increment_max = INCREMENT_MAX;
5512 char *cpu_affinity = NULL;
5513 OCL_PTR *ocl = NULL;
5514 char *opencl_devices = NULL;
5515 char *opencl_platforms = NULL;
5516 char *opencl_device_types = NULL;
5517 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5518 char *truecrypt_keyfiles = NULL;
5519 char *veracrypt_keyfiles = NULL;
5520 uint veracrypt_pim = 0;
5521 uint workload_profile = WORKLOAD_PROFILE;
5522 uint kernel_accel = KERNEL_ACCEL;
5523 uint kernel_loops = KERNEL_LOOPS;
5524 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5525 #ifdef HAVE_HWMON
5526 uint gpu_temp_abort = GPU_TEMP_ABORT;
5527 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5528 #ifdef HAVE_ADL
5529 uint powertune_enable = POWERTUNE_ENABLE;
5530 #endif
5531 #endif
5532 uint logfile_disable = LOGFILE_DISABLE;
5533 uint segment_size = SEGMENT_SIZE;
5534 uint scrypt_tmto = SCRYPT_TMTO;
5535 char separator = SEPARATOR;
5536 uint bitmap_min = BITMAP_MIN;
5537 uint bitmap_max = BITMAP_MAX;
5538 char *custom_charset_1 = NULL;
5539 char *custom_charset_2 = NULL;
5540 char *custom_charset_3 = NULL;
5541 char *custom_charset_4 = NULL;
5542
5543 #define IDX_HELP 'h'
5544 #define IDX_VERSION 'V'
5545 #define IDX_VERSION_LOWER 'v'
5546 #define IDX_QUIET 0xff02
5547 #define IDX_SHOW 0xff03
5548 #define IDX_LEFT 0xff04
5549 #define IDX_REMOVE 0xff05
5550 #define IDX_REMOVE_TIMER 0xff37
5551 #define IDX_SKIP 's'
5552 #define IDX_LIMIT 'l'
5553 #define IDX_KEYSPACE 0xff35
5554 #define IDX_POTFILE_DISABLE 0xff06
5555 #define IDX_POTFILE_PATH 0xffe0
5556 #define IDX_DEBUG_MODE 0xff43
5557 #define IDX_DEBUG_FILE 0xff44
5558 #define IDX_INDUCTION_DIR 0xff46
5559 #define IDX_OUTFILE_CHECK_DIR 0xff47
5560 #define IDX_USERNAME 0xff07
5561 #define IDX_FORCE 0xff08
5562 #define IDX_RUNTIME 0xff09
5563 #define IDX_BENCHMARK 'b'
5564 #define IDX_HASH_MODE 'm'
5565 #define IDX_ATTACK_MODE 'a'
5566 #define IDX_RP_FILE 'r'
5567 #define IDX_RP_GEN 'g'
5568 #define IDX_RP_GEN_FUNC_MIN 0xff10
5569 #define IDX_RP_GEN_FUNC_MAX 0xff11
5570 #define IDX_RP_GEN_SEED 0xff34
5571 #define IDX_RULE_BUF_L 'j'
5572 #define IDX_RULE_BUF_R 'k'
5573 #define IDX_INCREMENT 'i'
5574 #define IDX_INCREMENT_MIN 0xff12
5575 #define IDX_INCREMENT_MAX 0xff13
5576 #define IDX_OUTFILE 'o'
5577 #define IDX_OUTFILE_FORMAT 0xff14
5578 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5579 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5580 #define IDX_RESTORE 0xff15
5581 #define IDX_RESTORE_DISABLE 0xff27
5582 #define IDX_STATUS 0xff17
5583 #define IDX_STATUS_TIMER 0xff18
5584 #define IDX_MACHINE_READABLE 0xff50
5585 #define IDX_LOOPBACK 0xff38
5586 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5587 #define IDX_SESSION 0xff19
5588 #define IDX_HEX_CHARSET 0xff20
5589 #define IDX_HEX_SALT 0xff21
5590 #define IDX_HEX_WORDLIST 0xff40
5591 #define IDX_MARKOV_DISABLE 0xff22
5592 #define IDX_MARKOV_CLASSIC 0xff23
5593 #define IDX_MARKOV_THRESHOLD 't'
5594 #define IDX_MARKOV_HCSTAT 0xff24
5595 #define IDX_CPU_AFFINITY 0xff25
5596 #define IDX_OPENCL_DEVICES 'd'
5597 #define IDX_OPENCL_PLATFORMS 0xff72
5598 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5599 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5600 #define IDX_WORKLOAD_PROFILE 'w'
5601 #define IDX_KERNEL_ACCEL 'n'
5602 #define IDX_KERNEL_LOOPS 'u'
5603 #define IDX_GPU_TEMP_DISABLE 0xff29
5604 #define IDX_GPU_TEMP_ABORT 0xff30
5605 #define IDX_GPU_TEMP_RETAIN 0xff31
5606 #define IDX_POWERTUNE_ENABLE 0xff41
5607 #define IDX_LOGFILE_DISABLE 0xff51
5608 #define IDX_TRUECRYPT_KEYFILES 0xff52
5609 #define IDX_VERACRYPT_KEYFILES 0xff53
5610 #define IDX_VERACRYPT_PIM 0xff54
5611 #define IDX_SCRYPT_TMTO 0xff61
5612 #define IDX_SEGMENT_SIZE 'c'
5613 #define IDX_SEPARATOR 'p'
5614 #define IDX_BITMAP_MIN 0xff70
5615 #define IDX_BITMAP_MAX 0xff71
5616 #define IDX_CUSTOM_CHARSET_1 '1'
5617 #define IDX_CUSTOM_CHARSET_2 '2'
5618 #define IDX_CUSTOM_CHARSET_3 '3'
5619 #define IDX_CUSTOM_CHARSET_4 '4'
5620
5621 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5622
5623 struct option long_options[] =
5624 {
5625 {"help", no_argument, 0, IDX_HELP},
5626 {"version", no_argument, 0, IDX_VERSION},
5627 {"quiet", no_argument, 0, IDX_QUIET},
5628 {"show", no_argument, 0, IDX_SHOW},
5629 {"left", no_argument, 0, IDX_LEFT},
5630 {"username", no_argument, 0, IDX_USERNAME},
5631 {"remove", no_argument, 0, IDX_REMOVE},
5632 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5633 {"skip", required_argument, 0, IDX_SKIP},
5634 {"limit", required_argument, 0, IDX_LIMIT},
5635 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5636 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5637 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5638 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5639 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5640 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5641 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5642 {"force", no_argument, 0, IDX_FORCE},
5643 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5644 {"restore", no_argument, 0, IDX_RESTORE},
5645 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5646 {"status", no_argument, 0, IDX_STATUS},
5647 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5648 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5649 {"loopback", no_argument, 0, IDX_LOOPBACK},
5650 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5651 {"session", required_argument, 0, IDX_SESSION},
5652 {"runtime", required_argument, 0, IDX_RUNTIME},
5653 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5654 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5655 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5656 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5657 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5658 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5659 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5660 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5661 {"rules-file", required_argument, 0, IDX_RP_FILE},
5662 {"outfile", required_argument, 0, IDX_OUTFILE},
5663 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5664 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5665 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5666 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5667 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5668 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5669 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5670 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5671 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5672 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5673 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5674 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5675 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5676 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5677 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5678 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5679 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5680 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5681 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5682 #ifdef HAVE_HWMON
5683 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5684 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5685 #ifdef HAVE_ADL
5686 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5687 #endif
5688 #endif // HAVE_HWMON
5689 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5690 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5691 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5692 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5693 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5694 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5695 {"seperator", required_argument, 0, IDX_SEPARATOR},
5696 {"separator", required_argument, 0, IDX_SEPARATOR},
5697 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5698 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5699 {"increment", no_argument, 0, IDX_INCREMENT},
5700 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5701 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5702 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5703 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5704 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5705 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5706 {0, 0, 0, 0}
5707 };
5708
5709 uint rp_files_cnt = 0;
5710
5711 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5712
5713 int option_index = 0;
5714 int c = -1;
5715
5716 optind = 1;
5717 optopt = 0;
5718
5719 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5720 {
5721 switch (c)
5722 {
5723 case IDX_HELP: usage = 1; break;
5724 case IDX_VERSION:
5725 case IDX_VERSION_LOWER: version = 1; break;
5726 case IDX_RESTORE: restore = 1; break;
5727 case IDX_SESSION: session = optarg; break;
5728 case IDX_SHOW: show = 1; break;
5729 case IDX_LEFT: left = 1; break;
5730 case '?': return (-1);
5731 }
5732 }
5733
5734 if (optopt != 0)
5735 {
5736 log_error ("ERROR: Invalid argument specified");
5737
5738 return (-1);
5739 }
5740
5741 /**
5742 * exit functions
5743 */
5744
5745 if (version)
5746 {
5747 log_info ("%s", VERSION_TAG);
5748
5749 return (0);
5750 }
5751
5752 if (usage)
5753 {
5754 usage_big_print (PROGNAME);
5755
5756 return (0);
5757 }
5758
5759 /**
5760 * session needs to be set, always!
5761 */
5762
5763 if (session == NULL) session = (char *) PROGNAME;
5764
5765 /**
5766 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5767 */
5768
5769 char *exec_path = get_exec_path ();
5770
5771 #ifdef LINUX
5772
5773 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5774 char *resolved_exec_path = realpath (exec_path, NULL);
5775
5776 char *install_dir = get_install_dir (resolved_exec_path);
5777 char *profile_dir = NULL;
5778 char *session_dir = NULL;
5779 char *shared_dir = NULL;
5780
5781 if (strcmp (install_dir, resolved_install_folder) == 0)
5782 {
5783 struct passwd *pw = getpwuid (getuid ());
5784
5785 const char *homedir = pw->pw_dir;
5786
5787 profile_dir = get_profile_dir (homedir);
5788 session_dir = get_session_dir (profile_dir);
5789 shared_dir = strdup (SHARED_FOLDER);
5790
5791 mkdir (profile_dir, 0700);
5792 mkdir (session_dir, 0700);
5793 }
5794 else
5795 {
5796 profile_dir = install_dir;
5797 session_dir = install_dir;
5798 shared_dir = install_dir;
5799 }
5800
5801 myfree (resolved_install_folder);
5802 myfree (resolved_exec_path);
5803
5804 #else
5805
5806 char *install_dir = get_install_dir (exec_path);
5807 char *profile_dir = install_dir;
5808 char *session_dir = install_dir;
5809 char *shared_dir = install_dir;
5810
5811 #endif
5812
5813 data.install_dir = install_dir;
5814 data.profile_dir = profile_dir;
5815 data.session_dir = session_dir;
5816 data.shared_dir = shared_dir;
5817
5818 myfree (exec_path);
5819
5820 /**
5821 * kernel cache, we need to make sure folder exist
5822 */
5823
5824 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5825
5826 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5827
5828 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5829
5830 mkdir (kernels_folder, 0700);
5831
5832 myfree (kernels_folder);
5833
5834 /**
5835 * session
5836 */
5837
5838 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5839
5840 data.session = session;
5841
5842 char *eff_restore_file = (char *) mymalloc (session_size);
5843 char *new_restore_file = (char *) mymalloc (session_size);
5844
5845 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5846 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5847
5848 data.eff_restore_file = eff_restore_file;
5849 data.new_restore_file = new_restore_file;
5850
5851 if (((show == 1) || (left == 1)) && (restore == 1))
5852 {
5853 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5854 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5855
5856 return (-1);
5857 }
5858
5859 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5860 if ((show == 1) || (left == 1))
5861 {
5862 restore_disable = 1;
5863
5864 restore = 0;
5865 }
5866
5867 data.restore_disable = restore_disable;
5868
5869 restore_data_t *rd = init_restore (argc, argv);
5870
5871 data.rd = rd;
5872
5873 /**
5874 * restore file
5875 */
5876
5877 if (restore == 1)
5878 {
5879 read_restore (eff_restore_file, rd);
5880
5881 if (rd->version_bin < RESTORE_MIN)
5882 {
5883 log_error ("ERROR: Incompatible restore-file version");
5884
5885 return (-1);
5886 }
5887
5888 myargc = rd->argc;
5889 myargv = rd->argv;
5890
5891 #ifdef _POSIX
5892 rd->pid = getpid ();
5893 #elif _WIN
5894 rd->pid = GetCurrentProcessId ();
5895 #endif
5896 }
5897
5898 uint hash_mode_chgd = 0;
5899 uint runtime_chgd = 0;
5900 uint kernel_loops_chgd = 0;
5901 uint kernel_accel_chgd = 0;
5902 uint attack_mode_chgd = 0;
5903 uint outfile_format_chgd = 0;
5904 uint rp_gen_seed_chgd = 0;
5905 uint remove_timer_chgd = 0;
5906 uint increment_min_chgd = 0;
5907 uint increment_max_chgd = 0;
5908 uint workload_profile_chgd = 0;
5909 uint opencl_vector_width_chgd = 0;
5910
5911 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5912 uint gpu_temp_retain_chgd = 0;
5913 uint gpu_temp_abort_chgd = 0;
5914 #endif
5915
5916 optind = 1;
5917 optopt = 0;
5918 option_index = 0;
5919
5920 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5921 {
5922 switch (c)
5923 {
5924 //case IDX_HELP: usage = 1; break;
5925 //case IDX_VERSION: version = 1; break;
5926 //case IDX_RESTORE: restore = 1; break;
5927 case IDX_QUIET: quiet = 1; break;
5928 //case IDX_SHOW: show = 1; break;
5929 case IDX_SHOW: break;
5930 //case IDX_LEFT: left = 1; break;
5931 case IDX_LEFT: break;
5932 case IDX_USERNAME: username = 1; break;
5933 case IDX_REMOVE: remove = 1; break;
5934 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5935 remove_timer_chgd = 1; break;
5936 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5937 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5938 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5939 case IDX_DEBUG_FILE: debug_file = optarg; break;
5940 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5941 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5942 case IDX_FORCE: force = 1; break;
5943 case IDX_SKIP: skip = atoll (optarg); break;
5944 case IDX_LIMIT: limit = atoll (optarg); break;
5945 case IDX_KEYSPACE: keyspace = 1; break;
5946 case IDX_BENCHMARK: benchmark = 1; break;
5947 case IDX_RESTORE: break;
5948 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5949 case IDX_STATUS: status = 1; break;
5950 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5951 case IDX_MACHINE_READABLE: machine_readable = 1; break;
5952 case IDX_LOOPBACK: loopback = 1; break;
5953 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5954 //case IDX_SESSION: session = optarg; break;
5955 case IDX_SESSION: break;
5956 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5957 hash_mode_chgd = 1; break;
5958 case IDX_RUNTIME: runtime = atoi (optarg);
5959 runtime_chgd = 1; break;
5960 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5961 attack_mode_chgd = 1; break;
5962 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5963 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5964 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5965 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5966 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5967 rp_gen_seed_chgd = 1; break;
5968 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5969 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5970 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5971 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5972 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5973 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5974 case IDX_OUTFILE: outfile = optarg; break;
5975 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5976 outfile_format_chgd = 1; break;
5977 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
5978 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
5979 case IDX_HEX_CHARSET: hex_charset = 1; break;
5980 case IDX_HEX_SALT: hex_salt = 1; break;
5981 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5982 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5983 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5984 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5985 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
5986 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
5987 opencl_vector_width_chgd = 1; break;
5988 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5989 workload_profile_chgd = 1; break;
5990 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5991 kernel_accel_chgd = 1; break;
5992 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5993 kernel_loops_chgd = 1; break;
5994 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5995 #ifdef HAVE_HWMON
5996 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5997 #ifdef HAVE_ADL
5998 gpu_temp_abort_chgd = 1;
5999 #endif
6000 break;
6001 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
6002 #ifdef HAVE_ADL
6003 gpu_temp_retain_chgd = 1;
6004 #endif
6005 break;
6006 #ifdef HAVE_ADL
6007 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6008 #endif
6009 #endif // HAVE_HWMON
6010 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6011 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6012 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6013 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6014 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6015 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6016 case IDX_SEPARATOR: separator = optarg[0]; break;
6017 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6018 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6019 case IDX_INCREMENT: increment = 1; break;
6020 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6021 increment_min_chgd = 1; break;
6022 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6023 increment_max_chgd = 1; break;
6024 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6025 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6026 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6027 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6028
6029 default:
6030 log_error ("ERROR: Invalid argument specified");
6031 return (-1);
6032 }
6033 }
6034
6035 if (optopt != 0)
6036 {
6037 log_error ("ERROR: Invalid argument specified");
6038
6039 return (-1);
6040 }
6041
6042 /**
6043 * Inform user things getting started,
6044 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6045 * - we do not need to check algorithm_pos
6046 */
6047
6048 if (quiet == 0)
6049 {
6050 if (benchmark == 1)
6051 {
6052 if (machine_readable == 0)
6053 {
6054 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6055 log_info ("");
6056 }
6057 else
6058 {
6059 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6060 }
6061 }
6062 else if (restore == 1)
6063 {
6064 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6065 log_info ("");
6066 }
6067 else
6068 {
6069 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6070 log_info ("");
6071 }
6072 }
6073
6074 /**
6075 * sanity check
6076 */
6077
6078 if (attack_mode > 7)
6079 {
6080 log_error ("ERROR: Invalid attack-mode specified");
6081
6082 return (-1);
6083 }
6084
6085 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6086 {
6087 log_error ("ERROR: Invalid runtime specified");
6088
6089 return (-1);
6090 }
6091
6092 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6093 {
6094 log_error ("ERROR: Invalid hash-type specified");
6095
6096 return (-1);
6097 }
6098
6099 // renamed hash modes
6100
6101 if (hash_mode_chgd)
6102 {
6103 int n = -1;
6104
6105 switch (hash_mode)
6106 {
6107 case 123: n = 124;
6108 break;
6109 }
6110
6111 if (n >= 0)
6112 {
6113 log_error ("Old -m specified, use -m %d instead", n);
6114
6115 return (-1);
6116 }
6117 }
6118
6119 if (username == 1)
6120 {
6121 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6122 {
6123 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6124
6125 return (-1);
6126 }
6127 }
6128
6129 if (outfile_format > 16)
6130 {
6131 log_error ("ERROR: Invalid outfile-format specified");
6132
6133 return (-1);
6134 }
6135
6136 if (left == 1)
6137 {
6138 if (outfile_format_chgd == 1)
6139 {
6140 if (outfile_format > 1)
6141 {
6142 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6143
6144 return (-1);
6145 }
6146 }
6147 else
6148 {
6149 outfile_format = OUTFILE_FMT_HASH;
6150 }
6151 }
6152
6153 if (show == 1)
6154 {
6155 if (outfile_format_chgd == 1)
6156 {
6157 if ((outfile_format > 7) && (outfile_format < 16))
6158 {
6159 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6160
6161 return (-1);
6162 }
6163 }
6164 }
6165
6166 if (increment_min < INCREMENT_MIN)
6167 {
6168 log_error ("ERROR: Invalid increment-min specified");
6169
6170 return (-1);
6171 }
6172
6173 if (increment_max > INCREMENT_MAX)
6174 {
6175 log_error ("ERROR: Invalid increment-max specified");
6176
6177 return (-1);
6178 }
6179
6180 if (increment_min > increment_max)
6181 {
6182 log_error ("ERROR: Invalid increment-min specified");
6183
6184 return (-1);
6185 }
6186
6187 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6188 {
6189 log_error ("ERROR: increment is not allowed in attack-mode 0");
6190
6191 return (-1);
6192 }
6193
6194 if ((increment == 0) && (increment_min_chgd == 1))
6195 {
6196 log_error ("ERROR: increment-min is only supported together with increment switch");
6197
6198 return (-1);
6199 }
6200
6201 if ((increment == 0) && (increment_max_chgd == 1))
6202 {
6203 log_error ("ERROR: increment-max is only supported together with increment switch");
6204
6205 return (-1);
6206 }
6207
6208 if (rp_files_cnt && rp_gen)
6209 {
6210 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6211
6212 return (-1);
6213 }
6214
6215 if (rp_files_cnt || rp_gen)
6216 {
6217 if (attack_mode != ATTACK_MODE_STRAIGHT)
6218 {
6219 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6220
6221 return (-1);
6222 }
6223 }
6224
6225 if (rp_gen_func_min > rp_gen_func_max)
6226 {
6227 log_error ("ERROR: Invalid rp-gen-func-min specified");
6228
6229 return (-1);
6230 }
6231
6232 if (kernel_accel_chgd == 1)
6233 {
6234 if (force == 0)
6235 {
6236 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6237 log_info ("Please consider using the option -w instead");
6238 log_info ("You can use --force to override this but do not post error reports if you do so");
6239 log_info ("");
6240
6241 return (-1);
6242 }
6243
6244 if (kernel_accel < 1)
6245 {
6246 log_error ("ERROR: Invalid kernel-accel specified");
6247
6248 return (-1);
6249 }
6250
6251 if (kernel_accel > 1024)
6252 {
6253 log_error ("ERROR: Invalid kernel-accel specified");
6254
6255 return (-1);
6256 }
6257 }
6258
6259 if (kernel_loops_chgd == 1)
6260 {
6261 if (force == 0)
6262 {
6263 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6264 log_info ("Please consider using the option -w instead");
6265 log_info ("You can use --force to override this but do not post error reports if you do so");
6266 log_info ("");
6267
6268 return (-1);
6269 }
6270
6271 if (kernel_loops < 1)
6272 {
6273 log_error ("ERROR: Invalid kernel-loops specified");
6274
6275 return (-1);
6276 }
6277
6278 if (kernel_loops > 1024)
6279 {
6280 log_error ("ERROR: Invalid kernel-loops specified");
6281
6282 return (-1);
6283 }
6284 }
6285
6286 if ((workload_profile < 1) || (workload_profile > 4))
6287 {
6288 log_error ("ERROR: workload-profile %i not available", workload_profile);
6289
6290 return (-1);
6291 }
6292
6293 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6294 {
6295 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6296
6297 return (-1);
6298 }
6299
6300 if (show == 1 || left == 1)
6301 {
6302 attack_mode = ATTACK_MODE_NONE;
6303
6304 if (remove == 1)
6305 {
6306 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6307
6308 return (-1);
6309 }
6310
6311 if (potfile_disable == 1)
6312 {
6313 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6314
6315 return (-1);
6316 }
6317 }
6318
6319 uint attack_kern = ATTACK_KERN_NONE;
6320
6321 switch (attack_mode)
6322 {
6323 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6324 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6325 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6326 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6327 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6328 }
6329
6330 if (benchmark == 0)
6331 {
6332 if (keyspace == 1)
6333 {
6334 int num_additional_params = 1;
6335
6336 if (attack_kern == ATTACK_KERN_COMBI)
6337 {
6338 num_additional_params = 2;
6339 }
6340
6341 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6342
6343 if (keyspace_wordlist_specified == 0) optind--;
6344 }
6345
6346 if (attack_kern == ATTACK_KERN_NONE)
6347 {
6348 if ((optind + 1) != myargc)
6349 {
6350 usage_mini_print (myargv[0]);
6351
6352 return (-1);
6353 }
6354 }
6355 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6356 {
6357 if ((optind + 1) > myargc)
6358 {
6359 usage_mini_print (myargv[0]);
6360
6361 return (-1);
6362 }
6363 }
6364 else if (attack_kern == ATTACK_KERN_COMBI)
6365 {
6366 if ((optind + 3) != myargc)
6367 {
6368 usage_mini_print (myargv[0]);
6369
6370 return (-1);
6371 }
6372 }
6373 else if (attack_kern == ATTACK_KERN_BF)
6374 {
6375 if ((optind + 1) > myargc)
6376 {
6377 usage_mini_print (myargv[0]);
6378
6379 return (-1);
6380 }
6381 }
6382 else
6383 {
6384 usage_mini_print (myargv[0]);
6385
6386 return (-1);
6387 }
6388 }
6389 else
6390 {
6391 if (myargv[optind] != 0)
6392 {
6393 log_error ("ERROR: Invalid argument for benchmark mode specified");
6394
6395 return (-1);
6396 }
6397
6398 if (attack_mode_chgd == 1)
6399 {
6400 if (attack_mode != ATTACK_MODE_BF)
6401 {
6402 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6403
6404 return (-1);
6405 }
6406 }
6407 }
6408
6409 if (skip != 0 && limit != 0)
6410 {
6411 limit += skip;
6412 }
6413
6414 if (keyspace == 1)
6415 {
6416 if (show == 1)
6417 {
6418 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6419
6420 return (-1);
6421 }
6422 else if (left == 1)
6423 {
6424 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6425
6426 return (-1);
6427 }
6428
6429 potfile_disable = 1;
6430
6431 restore_disable = 1;
6432
6433 restore = 0;
6434
6435 weak_hash_threshold = 0;
6436
6437 quiet = 1;
6438 }
6439
6440 if (remove_timer_chgd == 1)
6441 {
6442 if (remove == 0)
6443 {
6444 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6445
6446 return (-1);
6447 }
6448
6449 if (remove_timer < 1)
6450 {
6451 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6452
6453 return (-1);
6454 }
6455 }
6456
6457 if (loopback == 1)
6458 {
6459 if (attack_mode == ATTACK_MODE_STRAIGHT)
6460 {
6461 if ((rp_files_cnt == 0) && (rp_gen == 0))
6462 {
6463 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6464
6465 return (-1);
6466 }
6467 }
6468 else
6469 {
6470 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6471
6472 return (-1);
6473 }
6474 }
6475
6476 if (debug_mode > 0)
6477 {
6478 if (attack_mode != ATTACK_MODE_STRAIGHT)
6479 {
6480 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6481
6482 return (-1);
6483 }
6484
6485 if ((rp_files_cnt == 0) && (rp_gen == 0))
6486 {
6487 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6488
6489 return (-1);
6490 }
6491 }
6492
6493 if (debug_mode > 4)
6494 {
6495 log_error ("ERROR: Invalid debug-mode specified");
6496
6497 return (-1);
6498 }
6499
6500 if (debug_file != NULL)
6501 {
6502 if (debug_mode < 1)
6503 {
6504 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6505
6506 return (-1);
6507 }
6508 }
6509
6510 if (induction_dir != NULL)
6511 {
6512 if (attack_mode == ATTACK_MODE_BF)
6513 {
6514 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6515
6516 return (-1);
6517 }
6518 }
6519
6520 if (attack_mode != ATTACK_MODE_STRAIGHT)
6521 {
6522 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6523 {
6524 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6525
6526 return (-1);
6527 }
6528
6529 weak_hash_threshold = 0;
6530 }
6531
6532 /**
6533 * induction directory
6534 */
6535
6536 char *induction_directory = NULL;
6537
6538 if (attack_mode != ATTACK_MODE_BF)
6539 {
6540 if (induction_dir == NULL)
6541 {
6542 induction_directory = (char *) mymalloc (session_size);
6543
6544 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6545
6546 // create induction folder if it does not already exist
6547
6548 if (keyspace == 0)
6549 {
6550 if (rmdir (induction_directory) == -1)
6551 {
6552 if (errno == ENOENT)
6553 {
6554 // good, we can ignore
6555 }
6556 else if (errno == ENOTEMPTY)
6557 {
6558 char *induction_directory_mv = (char *) mymalloc (session_size);
6559
6560 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6561
6562 if (rename (induction_directory, induction_directory_mv) != 0)
6563 {
6564 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6565
6566 return (-1);
6567 }
6568 }
6569 else
6570 {
6571 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6572
6573 return (-1);
6574 }
6575 }
6576
6577 if (mkdir (induction_directory, 0700) == -1)
6578 {
6579 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6580
6581 return (-1);
6582 }
6583 }
6584 }
6585 else
6586 {
6587 induction_directory = induction_dir;
6588 }
6589 }
6590
6591 data.induction_directory = induction_directory;
6592
6593 /**
6594 * loopback
6595 */
6596
6597 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6598
6599 char *loopback_file = (char *) mymalloc (loopback_size);
6600
6601 /**
6602 * tuning db
6603 */
6604
6605 char tuning_db_file[256] = { 0 };
6606
6607 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6608
6609 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6610
6611 /**
6612 * outfile-check directory
6613 */
6614
6615 char *outfile_check_directory = NULL;
6616
6617 if (outfile_check_dir == NULL)
6618 {
6619 outfile_check_directory = (char *) mymalloc (session_size);
6620
6621 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6622 }
6623 else
6624 {
6625 outfile_check_directory = outfile_check_dir;
6626 }
6627
6628 data.outfile_check_directory = outfile_check_directory;
6629
6630 if (keyspace == 0)
6631 {
6632 struct stat outfile_check_stat;
6633
6634 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6635 {
6636 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6637
6638 if (is_dir == 0)
6639 {
6640 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6641
6642 return (-1);
6643 }
6644 }
6645 else if (outfile_check_dir == NULL)
6646 {
6647 if (mkdir (outfile_check_directory, 0700) == -1)
6648 {
6649 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6650
6651 return (-1);
6652 }
6653 }
6654 }
6655
6656 /**
6657 * special other stuff
6658 */
6659
6660 if (hash_mode == 9710)
6661 {
6662 outfile_format = 5;
6663 outfile_format_chgd = 1;
6664 }
6665
6666 if (hash_mode == 9810)
6667 {
6668 outfile_format = 5;
6669 outfile_format_chgd = 1;
6670 }
6671
6672 if (hash_mode == 10410)
6673 {
6674 outfile_format = 5;
6675 outfile_format_chgd = 1;
6676 }
6677
6678 /**
6679 * store stuff
6680 */
6681
6682 data.hash_mode = hash_mode;
6683 data.restore = restore;
6684 data.restore_timer = restore_timer;
6685 data.restore_disable = restore_disable;
6686 data.status = status;
6687 data.status_timer = status_timer;
6688 data.machine_readable = machine_readable;
6689 data.loopback = loopback;
6690 data.runtime = runtime;
6691 data.remove = remove;
6692 data.remove_timer = remove_timer;
6693 data.debug_mode = debug_mode;
6694 data.debug_file = debug_file;
6695 data.username = username;
6696 data.quiet = quiet;
6697 data.outfile = outfile;
6698 data.outfile_format = outfile_format;
6699 data.outfile_autohex = outfile_autohex;
6700 data.hex_charset = hex_charset;
6701 data.hex_salt = hex_salt;
6702 data.hex_wordlist = hex_wordlist;
6703 data.separator = separator;
6704 data.rp_files = rp_files;
6705 data.rp_files_cnt = rp_files_cnt;
6706 data.rp_gen = rp_gen;
6707 data.rp_gen_seed = rp_gen_seed;
6708 data.force = force;
6709 data.benchmark = benchmark;
6710 data.skip = skip;
6711 data.limit = limit;
6712 #ifdef HAVE_HWMON
6713 #ifdef HAVE_ADL
6714 data.powertune_enable = powertune_enable;
6715 #endif
6716 #endif
6717 data.logfile_disable = logfile_disable;
6718 data.truecrypt_keyfiles = truecrypt_keyfiles;
6719 data.veracrypt_keyfiles = veracrypt_keyfiles;
6720 data.veracrypt_pim = veracrypt_pim;
6721 data.scrypt_tmto = scrypt_tmto;
6722 data.workload_profile = workload_profile;
6723
6724 /**
6725 * cpu affinity
6726 */
6727
6728 if (cpu_affinity)
6729 {
6730 set_cpu_affinity (cpu_affinity);
6731 }
6732
6733 if (rp_gen_seed_chgd == 0)
6734 {
6735 srand (proc_start);
6736 }
6737 else
6738 {
6739 srand (rp_gen_seed);
6740 }
6741
6742 /**
6743 * logfile init
6744 */
6745
6746 if (logfile_disable == 0)
6747 {
6748 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6749
6750 char *logfile = (char *) mymalloc (logfile_size);
6751
6752 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6753
6754 data.logfile = logfile;
6755
6756 char *topid = logfile_generate_topid ();
6757
6758 data.topid = topid;
6759 }
6760
6761 // logfile_append() checks for logfile_disable internally to make it easier from here
6762
6763 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6764 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6765 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6766 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6767 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6768 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6769 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6770 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6771 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6772 #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));
6773
6774 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6775 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6776 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6777 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6778 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6779 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6780 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6781 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6782
6783 logfile_top_msg ("START");
6784
6785 logfile_top_uint (attack_mode);
6786 logfile_top_uint (attack_kern);
6787 logfile_top_uint (benchmark);
6788 logfile_top_uint (bitmap_min);
6789 logfile_top_uint (bitmap_max);
6790 logfile_top_uint (debug_mode);
6791 logfile_top_uint (force);
6792 logfile_top_uint (kernel_accel);
6793 logfile_top_uint (kernel_loops);
6794 logfile_top_uint (gpu_temp_disable);
6795 #ifdef HAVE_HWMON
6796 logfile_top_uint (gpu_temp_abort);
6797 logfile_top_uint (gpu_temp_retain);
6798 #endif
6799 logfile_top_uint (hash_mode);
6800 logfile_top_uint (hex_charset);
6801 logfile_top_uint (hex_salt);
6802 logfile_top_uint (hex_wordlist);
6803 logfile_top_uint (increment);
6804 logfile_top_uint (increment_max);
6805 logfile_top_uint (increment_min);
6806 logfile_top_uint (keyspace);
6807 logfile_top_uint (left);
6808 logfile_top_uint (logfile_disable);
6809 logfile_top_uint (loopback);
6810 logfile_top_uint (markov_classic);
6811 logfile_top_uint (markov_disable);
6812 logfile_top_uint (markov_threshold);
6813 logfile_top_uint (outfile_autohex);
6814 logfile_top_uint (outfile_check_timer);
6815 logfile_top_uint (outfile_format);
6816 logfile_top_uint (potfile_disable);
6817 logfile_top_string (potfile_path);
6818 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6819 logfile_top_uint (powertune_enable);
6820 #endif
6821 logfile_top_uint (scrypt_tmto);
6822 logfile_top_uint (quiet);
6823 logfile_top_uint (remove);
6824 logfile_top_uint (remove_timer);
6825 logfile_top_uint (restore);
6826 logfile_top_uint (restore_disable);
6827 logfile_top_uint (restore_timer);
6828 logfile_top_uint (rp_gen);
6829 logfile_top_uint (rp_gen_func_max);
6830 logfile_top_uint (rp_gen_func_min);
6831 logfile_top_uint (rp_gen_seed);
6832 logfile_top_uint (runtime);
6833 logfile_top_uint (segment_size);
6834 logfile_top_uint (show);
6835 logfile_top_uint (status);
6836 logfile_top_uint (machine_readable);
6837 logfile_top_uint (status_timer);
6838 logfile_top_uint (usage);
6839 logfile_top_uint (username);
6840 logfile_top_uint (version);
6841 logfile_top_uint (weak_hash_threshold);
6842 logfile_top_uint (workload_profile);
6843 logfile_top_uint64 (limit);
6844 logfile_top_uint64 (skip);
6845 logfile_top_char (separator);
6846 logfile_top_string (cpu_affinity);
6847 logfile_top_string (custom_charset_1);
6848 logfile_top_string (custom_charset_2);
6849 logfile_top_string (custom_charset_3);
6850 logfile_top_string (custom_charset_4);
6851 logfile_top_string (debug_file);
6852 logfile_top_string (opencl_devices);
6853 logfile_top_string (opencl_platforms);
6854 logfile_top_string (opencl_device_types);
6855 logfile_top_uint (opencl_vector_width);
6856 logfile_top_string (induction_dir);
6857 logfile_top_string (markov_hcstat);
6858 logfile_top_string (outfile);
6859 logfile_top_string (outfile_check_dir);
6860 logfile_top_string (rule_buf_l);
6861 logfile_top_string (rule_buf_r);
6862 logfile_top_string (session);
6863 logfile_top_string (truecrypt_keyfiles);
6864 logfile_top_string (veracrypt_keyfiles);
6865 logfile_top_uint (veracrypt_pim);
6866
6867 /**
6868 * Init OpenCL library loader
6869 */
6870
6871 if (keyspace == 0)
6872 {
6873 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6874
6875 ocl_init (ocl);
6876
6877 data.ocl = ocl;
6878 }
6879
6880 /**
6881 * OpenCL platform selection
6882 */
6883
6884 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6885
6886 /**
6887 * OpenCL device selection
6888 */
6889
6890 u32 devices_filter = setup_devices_filter (opencl_devices);
6891
6892 /**
6893 * OpenCL device type selection
6894 */
6895
6896 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6897
6898 /**
6899 * benchmark
6900 */
6901
6902 if (benchmark == 1)
6903 {
6904 /**
6905 * disable useless stuff for benchmark
6906 */
6907
6908 status_timer = 0;
6909 restore_timer = 0;
6910 restore_disable = 1;
6911 potfile_disable = 1;
6912 weak_hash_threshold = 0;
6913 gpu_temp_disable = 1;
6914
6915 #ifdef HAVE_HWMON
6916 #ifdef HAVE_ADL
6917 powertune_enable = 1;
6918 #endif
6919 #endif
6920
6921 data.status_timer = status_timer;
6922 data.restore_timer = restore_timer;
6923 data.restore_disable = restore_disable;
6924
6925 /**
6926 * force attack mode to be bruteforce
6927 */
6928
6929 attack_mode = ATTACK_MODE_BF;
6930 attack_kern = ATTACK_KERN_BF;
6931
6932 if (workload_profile_chgd == 0)
6933 {
6934 workload_profile = 3;
6935
6936 data.workload_profile = workload_profile;
6937 }
6938 }
6939
6940 /**
6941 * config
6942 */
6943
6944 uint hash_type = 0;
6945 uint salt_type = 0;
6946 uint attack_exec = 0;
6947 uint opts_type = 0;
6948 uint kern_type = 0;
6949 uint dgst_size = 0;
6950 uint esalt_size = 0;
6951 uint opti_type = 0;
6952 uint dgst_pos0 = -1;
6953 uint dgst_pos1 = -1;
6954 uint dgst_pos2 = -1;
6955 uint dgst_pos3 = -1;
6956
6957 int (*parse_func) (char *, uint, hash_t *);
6958 int (*sort_by_digest) (const void *, const void *);
6959
6960 uint algorithm_pos = 0;
6961 uint algorithm_max = 1;
6962
6963 uint *algorithms = default_benchmark_algorithms;
6964
6965 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6966
6967 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6968 {
6969 /*
6970 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6971 * the following algos are skipped entirely
6972 */
6973
6974 if (algorithm_pos > 0)
6975 {
6976 local_free (rd);
6977
6978 rd = init_restore (argc, argv);
6979
6980 data.rd = rd;
6981 }
6982
6983 /**
6984 * update hash_mode in case of multihash benchmark
6985 */
6986
6987 if (benchmark == 1)
6988 {
6989 if (hash_mode_chgd == 0)
6990 {
6991 hash_mode = algorithms[algorithm_pos];
6992
6993 data.hash_mode = hash_mode;
6994 }
6995
6996 quiet = 1;
6997
6998 data.quiet = quiet;
6999 }
7000
7001 switch (hash_mode)
7002 {
7003 case 0: hash_type = HASH_TYPE_MD5;
7004 salt_type = SALT_TYPE_NONE;
7005 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7006 opts_type = OPTS_TYPE_PT_GENERATE_LE
7007 | OPTS_TYPE_PT_ADD80
7008 | OPTS_TYPE_PT_ADDBITS14;
7009 kern_type = KERN_TYPE_MD5;
7010 dgst_size = DGST_SIZE_4_4;
7011 parse_func = md5_parse_hash;
7012 sort_by_digest = sort_by_digest_4_4;
7013 opti_type = OPTI_TYPE_ZERO_BYTE
7014 | OPTI_TYPE_PRECOMPUTE_INIT
7015 | OPTI_TYPE_PRECOMPUTE_MERKLE
7016 | OPTI_TYPE_MEET_IN_MIDDLE
7017 | OPTI_TYPE_EARLY_SKIP
7018 | OPTI_TYPE_NOT_ITERATED
7019 | OPTI_TYPE_NOT_SALTED
7020 | OPTI_TYPE_RAW_HASH;
7021 dgst_pos0 = 0;
7022 dgst_pos1 = 3;
7023 dgst_pos2 = 2;
7024 dgst_pos3 = 1;
7025 break;
7026
7027 case 10: hash_type = HASH_TYPE_MD5;
7028 salt_type = SALT_TYPE_INTERN;
7029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7030 opts_type = OPTS_TYPE_PT_GENERATE_LE
7031 | OPTS_TYPE_ST_ADD80
7032 | OPTS_TYPE_ST_ADDBITS14;
7033 kern_type = KERN_TYPE_MD5_PWSLT;
7034 dgst_size = DGST_SIZE_4_4;
7035 parse_func = md5s_parse_hash;
7036 sort_by_digest = sort_by_digest_4_4;
7037 opti_type = OPTI_TYPE_ZERO_BYTE
7038 | OPTI_TYPE_PRECOMPUTE_INIT
7039 | OPTI_TYPE_PRECOMPUTE_MERKLE
7040 | OPTI_TYPE_MEET_IN_MIDDLE
7041 | OPTI_TYPE_EARLY_SKIP
7042 | OPTI_TYPE_NOT_ITERATED
7043 | OPTI_TYPE_APPENDED_SALT
7044 | OPTI_TYPE_RAW_HASH;
7045 dgst_pos0 = 0;
7046 dgst_pos1 = 3;
7047 dgst_pos2 = 2;
7048 dgst_pos3 = 1;
7049 break;
7050
7051 case 11: hash_type = HASH_TYPE_MD5;
7052 salt_type = SALT_TYPE_INTERN;
7053 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7054 opts_type = OPTS_TYPE_PT_GENERATE_LE
7055 | OPTS_TYPE_ST_ADD80
7056 | OPTS_TYPE_ST_ADDBITS14;
7057 kern_type = KERN_TYPE_MD5_PWSLT;
7058 dgst_size = DGST_SIZE_4_4;
7059 parse_func = joomla_parse_hash;
7060 sort_by_digest = sort_by_digest_4_4;
7061 opti_type = OPTI_TYPE_ZERO_BYTE
7062 | OPTI_TYPE_PRECOMPUTE_INIT
7063 | OPTI_TYPE_PRECOMPUTE_MERKLE
7064 | OPTI_TYPE_MEET_IN_MIDDLE
7065 | OPTI_TYPE_EARLY_SKIP
7066 | OPTI_TYPE_NOT_ITERATED
7067 | OPTI_TYPE_APPENDED_SALT
7068 | OPTI_TYPE_RAW_HASH;
7069 dgst_pos0 = 0;
7070 dgst_pos1 = 3;
7071 dgst_pos2 = 2;
7072 dgst_pos3 = 1;
7073 break;
7074
7075 case 12: hash_type = HASH_TYPE_MD5;
7076 salt_type = SALT_TYPE_INTERN;
7077 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7078 opts_type = OPTS_TYPE_PT_GENERATE_LE
7079 | OPTS_TYPE_ST_ADD80
7080 | OPTS_TYPE_ST_ADDBITS14;
7081 kern_type = KERN_TYPE_MD5_PWSLT;
7082 dgst_size = DGST_SIZE_4_4;
7083 parse_func = postgresql_parse_hash;
7084 sort_by_digest = sort_by_digest_4_4;
7085 opti_type = OPTI_TYPE_ZERO_BYTE
7086 | OPTI_TYPE_PRECOMPUTE_INIT
7087 | OPTI_TYPE_PRECOMPUTE_MERKLE
7088 | OPTI_TYPE_MEET_IN_MIDDLE
7089 | OPTI_TYPE_EARLY_SKIP
7090 | OPTI_TYPE_NOT_ITERATED
7091 | OPTI_TYPE_APPENDED_SALT
7092 | OPTI_TYPE_RAW_HASH;
7093 dgst_pos0 = 0;
7094 dgst_pos1 = 3;
7095 dgst_pos2 = 2;
7096 dgst_pos3 = 1;
7097 break;
7098
7099 case 20: hash_type = HASH_TYPE_MD5;
7100 salt_type = SALT_TYPE_INTERN;
7101 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7102 opts_type = OPTS_TYPE_PT_GENERATE_LE
7103 | OPTS_TYPE_PT_ADD80
7104 | OPTS_TYPE_PT_ADDBITS14;
7105 kern_type = KERN_TYPE_MD5_SLTPW;
7106 dgst_size = DGST_SIZE_4_4;
7107 parse_func = md5s_parse_hash;
7108 sort_by_digest = sort_by_digest_4_4;
7109 opti_type = OPTI_TYPE_ZERO_BYTE
7110 | OPTI_TYPE_PRECOMPUTE_INIT
7111 | OPTI_TYPE_PRECOMPUTE_MERKLE
7112 | OPTI_TYPE_EARLY_SKIP
7113 | OPTI_TYPE_NOT_ITERATED
7114 | OPTI_TYPE_PREPENDED_SALT
7115 | OPTI_TYPE_RAW_HASH;
7116 dgst_pos0 = 0;
7117 dgst_pos1 = 3;
7118 dgst_pos2 = 2;
7119 dgst_pos3 = 1;
7120 break;
7121
7122 case 21: hash_type = HASH_TYPE_MD5;
7123 salt_type = SALT_TYPE_INTERN;
7124 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7125 opts_type = OPTS_TYPE_PT_GENERATE_LE
7126 | OPTS_TYPE_PT_ADD80
7127 | OPTS_TYPE_PT_ADDBITS14;
7128 kern_type = KERN_TYPE_MD5_SLTPW;
7129 dgst_size = DGST_SIZE_4_4;
7130 parse_func = osc_parse_hash;
7131 sort_by_digest = sort_by_digest_4_4;
7132 opti_type = OPTI_TYPE_ZERO_BYTE
7133 | OPTI_TYPE_PRECOMPUTE_INIT
7134 | OPTI_TYPE_PRECOMPUTE_MERKLE
7135 | OPTI_TYPE_EARLY_SKIP
7136 | OPTI_TYPE_NOT_ITERATED
7137 | OPTI_TYPE_PREPENDED_SALT
7138 | OPTI_TYPE_RAW_HASH;
7139 dgst_pos0 = 0;
7140 dgst_pos1 = 3;
7141 dgst_pos2 = 2;
7142 dgst_pos3 = 1;
7143 break;
7144
7145 case 22: hash_type = HASH_TYPE_MD5;
7146 salt_type = SALT_TYPE_EMBEDDED;
7147 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7148 opts_type = OPTS_TYPE_PT_GENERATE_LE
7149 | OPTS_TYPE_PT_ADD80
7150 | OPTS_TYPE_PT_ADDBITS14;
7151 kern_type = KERN_TYPE_MD5_SLTPW;
7152 dgst_size = DGST_SIZE_4_4;
7153 parse_func = netscreen_parse_hash;
7154 sort_by_digest = sort_by_digest_4_4;
7155 opti_type = OPTI_TYPE_ZERO_BYTE
7156 | OPTI_TYPE_PRECOMPUTE_INIT
7157 | OPTI_TYPE_PRECOMPUTE_MERKLE
7158 | OPTI_TYPE_EARLY_SKIP
7159 | OPTI_TYPE_NOT_ITERATED
7160 | OPTI_TYPE_PREPENDED_SALT
7161 | OPTI_TYPE_RAW_HASH;
7162 dgst_pos0 = 0;
7163 dgst_pos1 = 3;
7164 dgst_pos2 = 2;
7165 dgst_pos3 = 1;
7166 break;
7167
7168 case 23: hash_type = HASH_TYPE_MD5;
7169 salt_type = SALT_TYPE_EMBEDDED;
7170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7171 opts_type = OPTS_TYPE_PT_GENERATE_LE
7172 | OPTS_TYPE_PT_ADD80
7173 | OPTS_TYPE_PT_ADDBITS14;
7174 kern_type = KERN_TYPE_MD5_SLTPW;
7175 dgst_size = DGST_SIZE_4_4;
7176 parse_func = skype_parse_hash;
7177 sort_by_digest = sort_by_digest_4_4;
7178 opti_type = OPTI_TYPE_ZERO_BYTE
7179 | OPTI_TYPE_PRECOMPUTE_INIT
7180 | OPTI_TYPE_PRECOMPUTE_MERKLE
7181 | OPTI_TYPE_EARLY_SKIP
7182 | OPTI_TYPE_NOT_ITERATED
7183 | OPTI_TYPE_PREPENDED_SALT
7184 | OPTI_TYPE_RAW_HASH;
7185 dgst_pos0 = 0;
7186 dgst_pos1 = 3;
7187 dgst_pos2 = 2;
7188 dgst_pos3 = 1;
7189 break;
7190
7191 case 30: hash_type = HASH_TYPE_MD5;
7192 salt_type = SALT_TYPE_INTERN;
7193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7194 opts_type = OPTS_TYPE_PT_GENERATE_LE
7195 | OPTS_TYPE_PT_UNICODE
7196 | OPTS_TYPE_ST_ADD80
7197 | OPTS_TYPE_ST_ADDBITS14;
7198 kern_type = KERN_TYPE_MD5_PWUSLT;
7199 dgst_size = DGST_SIZE_4_4;
7200 parse_func = md5s_parse_hash;
7201 sort_by_digest = sort_by_digest_4_4;
7202 opti_type = OPTI_TYPE_ZERO_BYTE
7203 | OPTI_TYPE_PRECOMPUTE_INIT
7204 | OPTI_TYPE_PRECOMPUTE_MERKLE
7205 | OPTI_TYPE_MEET_IN_MIDDLE
7206 | OPTI_TYPE_EARLY_SKIP
7207 | OPTI_TYPE_NOT_ITERATED
7208 | OPTI_TYPE_APPENDED_SALT
7209 | OPTI_TYPE_RAW_HASH;
7210 dgst_pos0 = 0;
7211 dgst_pos1 = 3;
7212 dgst_pos2 = 2;
7213 dgst_pos3 = 1;
7214 break;
7215
7216 case 40: hash_type = HASH_TYPE_MD5;
7217 salt_type = SALT_TYPE_INTERN;
7218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7219 opts_type = OPTS_TYPE_PT_GENERATE_LE
7220 | OPTS_TYPE_PT_ADD80
7221 | OPTS_TYPE_PT_ADDBITS14
7222 | OPTS_TYPE_PT_UNICODE;
7223 kern_type = KERN_TYPE_MD5_SLTPWU;
7224 dgst_size = DGST_SIZE_4_4;
7225 parse_func = md5s_parse_hash;
7226 sort_by_digest = sort_by_digest_4_4;
7227 opti_type = OPTI_TYPE_ZERO_BYTE
7228 | OPTI_TYPE_PRECOMPUTE_INIT
7229 | OPTI_TYPE_PRECOMPUTE_MERKLE
7230 | OPTI_TYPE_EARLY_SKIP
7231 | OPTI_TYPE_NOT_ITERATED
7232 | OPTI_TYPE_PREPENDED_SALT
7233 | OPTI_TYPE_RAW_HASH;
7234 dgst_pos0 = 0;
7235 dgst_pos1 = 3;
7236 dgst_pos2 = 2;
7237 dgst_pos3 = 1;
7238 break;
7239
7240 case 50: hash_type = HASH_TYPE_MD5;
7241 salt_type = SALT_TYPE_INTERN;
7242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7243 opts_type = OPTS_TYPE_PT_GENERATE_LE
7244 | OPTS_TYPE_ST_ADD80
7245 | OPTS_TYPE_ST_ADDBITS14;
7246 kern_type = KERN_TYPE_HMACMD5_PW;
7247 dgst_size = DGST_SIZE_4_4;
7248 parse_func = hmacmd5_parse_hash;
7249 sort_by_digest = sort_by_digest_4_4;
7250 opti_type = OPTI_TYPE_ZERO_BYTE
7251 | OPTI_TYPE_NOT_ITERATED;
7252 dgst_pos0 = 0;
7253 dgst_pos1 = 3;
7254 dgst_pos2 = 2;
7255 dgst_pos3 = 1;
7256 break;
7257
7258 case 60: hash_type = HASH_TYPE_MD5;
7259 salt_type = SALT_TYPE_INTERN;
7260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7261 opts_type = OPTS_TYPE_PT_GENERATE_LE
7262 | OPTS_TYPE_PT_ADD80
7263 | OPTS_TYPE_PT_ADDBITS14;
7264 kern_type = KERN_TYPE_HMACMD5_SLT;
7265 dgst_size = DGST_SIZE_4_4;
7266 parse_func = hmacmd5_parse_hash;
7267 sort_by_digest = sort_by_digest_4_4;
7268 opti_type = OPTI_TYPE_ZERO_BYTE
7269 | OPTI_TYPE_NOT_ITERATED;
7270 dgst_pos0 = 0;
7271 dgst_pos1 = 3;
7272 dgst_pos2 = 2;
7273 dgst_pos3 = 1;
7274 break;
7275
7276 case 100: hash_type = HASH_TYPE_SHA1;
7277 salt_type = SALT_TYPE_NONE;
7278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7279 opts_type = OPTS_TYPE_PT_GENERATE_BE
7280 | OPTS_TYPE_PT_ADD80
7281 | OPTS_TYPE_PT_ADDBITS15;
7282 kern_type = KERN_TYPE_SHA1;
7283 dgst_size = DGST_SIZE_4_5;
7284 parse_func = sha1_parse_hash;
7285 sort_by_digest = sort_by_digest_4_5;
7286 opti_type = OPTI_TYPE_ZERO_BYTE
7287 | OPTI_TYPE_PRECOMPUTE_INIT
7288 | OPTI_TYPE_PRECOMPUTE_MERKLE
7289 | OPTI_TYPE_EARLY_SKIP
7290 | OPTI_TYPE_NOT_ITERATED
7291 | OPTI_TYPE_NOT_SALTED
7292 | OPTI_TYPE_RAW_HASH;
7293 dgst_pos0 = 3;
7294 dgst_pos1 = 4;
7295 dgst_pos2 = 2;
7296 dgst_pos3 = 1;
7297 break;
7298
7299 case 101: hash_type = HASH_TYPE_SHA1;
7300 salt_type = SALT_TYPE_NONE;
7301 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7302 opts_type = OPTS_TYPE_PT_GENERATE_BE
7303 | OPTS_TYPE_PT_ADD80
7304 | OPTS_TYPE_PT_ADDBITS15;
7305 kern_type = KERN_TYPE_SHA1;
7306 dgst_size = DGST_SIZE_4_5;
7307 parse_func = sha1b64_parse_hash;
7308 sort_by_digest = sort_by_digest_4_5;
7309 opti_type = OPTI_TYPE_ZERO_BYTE
7310 | OPTI_TYPE_PRECOMPUTE_INIT
7311 | OPTI_TYPE_PRECOMPUTE_MERKLE
7312 | OPTI_TYPE_EARLY_SKIP
7313 | OPTI_TYPE_NOT_ITERATED
7314 | OPTI_TYPE_NOT_SALTED
7315 | OPTI_TYPE_RAW_HASH;
7316 dgst_pos0 = 3;
7317 dgst_pos1 = 4;
7318 dgst_pos2 = 2;
7319 dgst_pos3 = 1;
7320 break;
7321
7322 case 110: hash_type = HASH_TYPE_SHA1;
7323 salt_type = SALT_TYPE_INTERN;
7324 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7325 opts_type = OPTS_TYPE_PT_GENERATE_BE
7326 | OPTS_TYPE_ST_ADD80
7327 | OPTS_TYPE_ST_ADDBITS15;
7328 kern_type = KERN_TYPE_SHA1_PWSLT;
7329 dgst_size = DGST_SIZE_4_5;
7330 parse_func = sha1s_parse_hash;
7331 sort_by_digest = sort_by_digest_4_5;
7332 opti_type = OPTI_TYPE_ZERO_BYTE
7333 | OPTI_TYPE_PRECOMPUTE_INIT
7334 | OPTI_TYPE_PRECOMPUTE_MERKLE
7335 | OPTI_TYPE_EARLY_SKIP
7336 | OPTI_TYPE_NOT_ITERATED
7337 | OPTI_TYPE_APPENDED_SALT
7338 | OPTI_TYPE_RAW_HASH;
7339 dgst_pos0 = 3;
7340 dgst_pos1 = 4;
7341 dgst_pos2 = 2;
7342 dgst_pos3 = 1;
7343 break;
7344
7345 case 111: hash_type = HASH_TYPE_SHA1;
7346 salt_type = SALT_TYPE_EMBEDDED;
7347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7348 opts_type = OPTS_TYPE_PT_GENERATE_BE
7349 | OPTS_TYPE_ST_ADD80
7350 | OPTS_TYPE_ST_ADDBITS15;
7351 kern_type = KERN_TYPE_SHA1_PWSLT;
7352 dgst_size = DGST_SIZE_4_5;
7353 parse_func = sha1b64s_parse_hash;
7354 sort_by_digest = sort_by_digest_4_5;
7355 opti_type = OPTI_TYPE_ZERO_BYTE
7356 | OPTI_TYPE_PRECOMPUTE_INIT
7357 | OPTI_TYPE_PRECOMPUTE_MERKLE
7358 | OPTI_TYPE_EARLY_SKIP
7359 | OPTI_TYPE_NOT_ITERATED
7360 | OPTI_TYPE_APPENDED_SALT
7361 | OPTI_TYPE_RAW_HASH;
7362 dgst_pos0 = 3;
7363 dgst_pos1 = 4;
7364 dgst_pos2 = 2;
7365 dgst_pos3 = 1;
7366 break;
7367
7368 case 112: hash_type = HASH_TYPE_SHA1;
7369 salt_type = SALT_TYPE_INTERN;
7370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7371 opts_type = OPTS_TYPE_PT_GENERATE_BE
7372 | OPTS_TYPE_ST_ADD80
7373 | OPTS_TYPE_ST_ADDBITS15
7374 | OPTS_TYPE_ST_HEX;
7375 kern_type = KERN_TYPE_SHA1_PWSLT;
7376 dgst_size = DGST_SIZE_4_5;
7377 parse_func = oracles_parse_hash;
7378 sort_by_digest = sort_by_digest_4_5;
7379 opti_type = OPTI_TYPE_ZERO_BYTE
7380 | OPTI_TYPE_PRECOMPUTE_INIT
7381 | OPTI_TYPE_PRECOMPUTE_MERKLE
7382 | OPTI_TYPE_EARLY_SKIP
7383 | OPTI_TYPE_NOT_ITERATED
7384 | OPTI_TYPE_APPENDED_SALT
7385 | OPTI_TYPE_RAW_HASH;
7386 dgst_pos0 = 3;
7387 dgst_pos1 = 4;
7388 dgst_pos2 = 2;
7389 dgst_pos3 = 1;
7390 break;
7391
7392 case 120: hash_type = HASH_TYPE_SHA1;
7393 salt_type = SALT_TYPE_INTERN;
7394 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7395 opts_type = OPTS_TYPE_PT_GENERATE_BE
7396 | OPTS_TYPE_PT_ADD80
7397 | OPTS_TYPE_PT_ADDBITS15;
7398 kern_type = KERN_TYPE_SHA1_SLTPW;
7399 dgst_size = DGST_SIZE_4_5;
7400 parse_func = sha1s_parse_hash;
7401 sort_by_digest = sort_by_digest_4_5;
7402 opti_type = OPTI_TYPE_ZERO_BYTE
7403 | OPTI_TYPE_PRECOMPUTE_INIT
7404 | OPTI_TYPE_PRECOMPUTE_MERKLE
7405 | OPTI_TYPE_EARLY_SKIP
7406 | OPTI_TYPE_NOT_ITERATED
7407 | OPTI_TYPE_PREPENDED_SALT
7408 | OPTI_TYPE_RAW_HASH;
7409 dgst_pos0 = 3;
7410 dgst_pos1 = 4;
7411 dgst_pos2 = 2;
7412 dgst_pos3 = 1;
7413 break;
7414
7415 case 121: hash_type = HASH_TYPE_SHA1;
7416 salt_type = SALT_TYPE_INTERN;
7417 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7418 opts_type = OPTS_TYPE_PT_GENERATE_BE
7419 | OPTS_TYPE_PT_ADD80
7420 | OPTS_TYPE_PT_ADDBITS15
7421 | OPTS_TYPE_ST_LOWER;
7422 kern_type = KERN_TYPE_SHA1_SLTPW;
7423 dgst_size = DGST_SIZE_4_5;
7424 parse_func = smf_parse_hash;
7425 sort_by_digest = sort_by_digest_4_5;
7426 opti_type = OPTI_TYPE_ZERO_BYTE
7427 | OPTI_TYPE_PRECOMPUTE_INIT
7428 | OPTI_TYPE_PRECOMPUTE_MERKLE
7429 | OPTI_TYPE_EARLY_SKIP
7430 | OPTI_TYPE_NOT_ITERATED
7431 | OPTI_TYPE_PREPENDED_SALT
7432 | OPTI_TYPE_RAW_HASH;
7433 dgst_pos0 = 3;
7434 dgst_pos1 = 4;
7435 dgst_pos2 = 2;
7436 dgst_pos3 = 1;
7437 break;
7438
7439 case 122: hash_type = HASH_TYPE_SHA1;
7440 salt_type = SALT_TYPE_EMBEDDED;
7441 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7442 opts_type = OPTS_TYPE_PT_GENERATE_BE
7443 | OPTS_TYPE_PT_ADD80
7444 | OPTS_TYPE_PT_ADDBITS15
7445 | OPTS_TYPE_ST_HEX;
7446 kern_type = KERN_TYPE_SHA1_SLTPW;
7447 dgst_size = DGST_SIZE_4_5;
7448 parse_func = osx1_parse_hash;
7449 sort_by_digest = sort_by_digest_4_5;
7450 opti_type = OPTI_TYPE_ZERO_BYTE
7451 | OPTI_TYPE_PRECOMPUTE_INIT
7452 | OPTI_TYPE_PRECOMPUTE_MERKLE
7453 | OPTI_TYPE_EARLY_SKIP
7454 | OPTI_TYPE_NOT_ITERATED
7455 | OPTI_TYPE_PREPENDED_SALT
7456 | OPTI_TYPE_RAW_HASH;
7457 dgst_pos0 = 3;
7458 dgst_pos1 = 4;
7459 dgst_pos2 = 2;
7460 dgst_pos3 = 1;
7461 break;
7462
7463 case 124: hash_type = HASH_TYPE_SHA1;
7464 salt_type = SALT_TYPE_EMBEDDED;
7465 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7466 opts_type = OPTS_TYPE_PT_GENERATE_BE
7467 | OPTS_TYPE_PT_ADD80
7468 | OPTS_TYPE_PT_ADDBITS15;
7469 kern_type = KERN_TYPE_SHA1_SLTPW;
7470 dgst_size = DGST_SIZE_4_5;
7471 parse_func = djangosha1_parse_hash;
7472 sort_by_digest = sort_by_digest_4_5;
7473 opti_type = OPTI_TYPE_ZERO_BYTE
7474 | OPTI_TYPE_PRECOMPUTE_INIT
7475 | OPTI_TYPE_PRECOMPUTE_MERKLE
7476 | OPTI_TYPE_EARLY_SKIP
7477 | OPTI_TYPE_NOT_ITERATED
7478 | OPTI_TYPE_PREPENDED_SALT
7479 | OPTI_TYPE_RAW_HASH;
7480 dgst_pos0 = 3;
7481 dgst_pos1 = 4;
7482 dgst_pos2 = 2;
7483 dgst_pos3 = 1;
7484 break;
7485
7486 case 125: hash_type = HASH_TYPE_SHA1;
7487 salt_type = SALT_TYPE_EMBEDDED;
7488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7489 opts_type = OPTS_TYPE_PT_GENERATE_BE
7490 | OPTS_TYPE_PT_ADD80
7491 | OPTS_TYPE_PT_ADDBITS15
7492 | OPTS_TYPE_ST_HEX;
7493 kern_type = KERN_TYPE_SHA1_SLTPW;
7494 dgst_size = DGST_SIZE_4_5;
7495 parse_func = arubaos_parse_hash;
7496 sort_by_digest = sort_by_digest_4_5;
7497 opti_type = OPTI_TYPE_ZERO_BYTE
7498 | OPTI_TYPE_PRECOMPUTE_INIT
7499 | OPTI_TYPE_PRECOMPUTE_MERKLE
7500 | OPTI_TYPE_EARLY_SKIP
7501 | OPTI_TYPE_NOT_ITERATED
7502 | OPTI_TYPE_PREPENDED_SALT
7503 | OPTI_TYPE_RAW_HASH;
7504 dgst_pos0 = 3;
7505 dgst_pos1 = 4;
7506 dgst_pos2 = 2;
7507 dgst_pos3 = 1;
7508 break;
7509
7510 case 130: hash_type = HASH_TYPE_SHA1;
7511 salt_type = SALT_TYPE_INTERN;
7512 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7513 opts_type = OPTS_TYPE_PT_GENERATE_BE
7514 | OPTS_TYPE_PT_UNICODE
7515 | OPTS_TYPE_ST_ADD80
7516 | OPTS_TYPE_ST_ADDBITS15;
7517 kern_type = KERN_TYPE_SHA1_PWUSLT;
7518 dgst_size = DGST_SIZE_4_5;
7519 parse_func = sha1s_parse_hash;
7520 sort_by_digest = sort_by_digest_4_5;
7521 opti_type = OPTI_TYPE_ZERO_BYTE
7522 | OPTI_TYPE_PRECOMPUTE_INIT
7523 | OPTI_TYPE_PRECOMPUTE_MERKLE
7524 | OPTI_TYPE_EARLY_SKIP
7525 | OPTI_TYPE_NOT_ITERATED
7526 | OPTI_TYPE_APPENDED_SALT
7527 | OPTI_TYPE_RAW_HASH;
7528 dgst_pos0 = 3;
7529 dgst_pos1 = 4;
7530 dgst_pos2 = 2;
7531 dgst_pos3 = 1;
7532 break;
7533
7534 case 131: hash_type = HASH_TYPE_SHA1;
7535 salt_type = SALT_TYPE_EMBEDDED;
7536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7537 opts_type = OPTS_TYPE_PT_GENERATE_BE
7538 | OPTS_TYPE_PT_UNICODE
7539 | OPTS_TYPE_PT_UPPER
7540 | OPTS_TYPE_ST_ADD80
7541 | OPTS_TYPE_ST_ADDBITS15
7542 | OPTS_TYPE_ST_HEX;
7543 kern_type = KERN_TYPE_SHA1_PWUSLT;
7544 dgst_size = DGST_SIZE_4_5;
7545 parse_func = mssql2000_parse_hash;
7546 sort_by_digest = sort_by_digest_4_5;
7547 opti_type = OPTI_TYPE_ZERO_BYTE
7548 | OPTI_TYPE_PRECOMPUTE_INIT
7549 | OPTI_TYPE_PRECOMPUTE_MERKLE
7550 | OPTI_TYPE_EARLY_SKIP
7551 | OPTI_TYPE_NOT_ITERATED
7552 | OPTI_TYPE_APPENDED_SALT
7553 | OPTI_TYPE_RAW_HASH;
7554 dgst_pos0 = 3;
7555 dgst_pos1 = 4;
7556 dgst_pos2 = 2;
7557 dgst_pos3 = 1;
7558 break;
7559
7560 case 132: hash_type = HASH_TYPE_SHA1;
7561 salt_type = SALT_TYPE_EMBEDDED;
7562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7563 opts_type = OPTS_TYPE_PT_GENERATE_BE
7564 | OPTS_TYPE_PT_UNICODE
7565 | OPTS_TYPE_ST_ADD80
7566 | OPTS_TYPE_ST_ADDBITS15
7567 | OPTS_TYPE_ST_HEX;
7568 kern_type = KERN_TYPE_SHA1_PWUSLT;
7569 dgst_size = DGST_SIZE_4_5;
7570 parse_func = mssql2005_parse_hash;
7571 sort_by_digest = sort_by_digest_4_5;
7572 opti_type = OPTI_TYPE_ZERO_BYTE
7573 | OPTI_TYPE_PRECOMPUTE_INIT
7574 | OPTI_TYPE_PRECOMPUTE_MERKLE
7575 | OPTI_TYPE_EARLY_SKIP
7576 | OPTI_TYPE_NOT_ITERATED
7577 | OPTI_TYPE_APPENDED_SALT
7578 | OPTI_TYPE_RAW_HASH;
7579 dgst_pos0 = 3;
7580 dgst_pos1 = 4;
7581 dgst_pos2 = 2;
7582 dgst_pos3 = 1;
7583 break;
7584
7585 case 133: hash_type = HASH_TYPE_SHA1;
7586 salt_type = SALT_TYPE_EMBEDDED;
7587 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7588 opts_type = OPTS_TYPE_PT_GENERATE_BE
7589 | OPTS_TYPE_PT_UNICODE
7590 | OPTS_TYPE_ST_ADD80
7591 | OPTS_TYPE_ST_ADDBITS15;
7592 kern_type = KERN_TYPE_SHA1_PWUSLT;
7593 dgst_size = DGST_SIZE_4_5;
7594 parse_func = peoplesoft_parse_hash;
7595 sort_by_digest = sort_by_digest_4_5;
7596 opti_type = OPTI_TYPE_ZERO_BYTE
7597 | OPTI_TYPE_PRECOMPUTE_INIT
7598 | OPTI_TYPE_PRECOMPUTE_MERKLE
7599 | OPTI_TYPE_EARLY_SKIP
7600 | OPTI_TYPE_NOT_ITERATED
7601 | OPTI_TYPE_APPENDED_SALT
7602 | OPTI_TYPE_RAW_HASH;
7603 dgst_pos0 = 3;
7604 dgst_pos1 = 4;
7605 dgst_pos2 = 2;
7606 dgst_pos3 = 1;
7607 break;
7608
7609 case 140: hash_type = HASH_TYPE_SHA1;
7610 salt_type = SALT_TYPE_INTERN;
7611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7612 opts_type = OPTS_TYPE_PT_GENERATE_BE
7613 | OPTS_TYPE_PT_ADD80
7614 | OPTS_TYPE_PT_ADDBITS15
7615 | OPTS_TYPE_PT_UNICODE;
7616 kern_type = KERN_TYPE_SHA1_SLTPWU;
7617 dgst_size = DGST_SIZE_4_5;
7618 parse_func = sha1s_parse_hash;
7619 sort_by_digest = sort_by_digest_4_5;
7620 opti_type = OPTI_TYPE_ZERO_BYTE
7621 | OPTI_TYPE_PRECOMPUTE_INIT
7622 | OPTI_TYPE_PRECOMPUTE_MERKLE
7623 | OPTI_TYPE_EARLY_SKIP
7624 | OPTI_TYPE_NOT_ITERATED
7625 | OPTI_TYPE_PREPENDED_SALT
7626 | OPTI_TYPE_RAW_HASH;
7627 dgst_pos0 = 3;
7628 dgst_pos1 = 4;
7629 dgst_pos2 = 2;
7630 dgst_pos3 = 1;
7631 break;
7632
7633 case 141: hash_type = HASH_TYPE_SHA1;
7634 salt_type = SALT_TYPE_EMBEDDED;
7635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7636 opts_type = OPTS_TYPE_PT_GENERATE_BE
7637 | OPTS_TYPE_PT_ADD80
7638 | OPTS_TYPE_PT_ADDBITS15
7639 | OPTS_TYPE_PT_UNICODE
7640 | OPTS_TYPE_ST_BASE64;
7641 kern_type = KERN_TYPE_SHA1_SLTPWU;
7642 dgst_size = DGST_SIZE_4_5;
7643 parse_func = episerver_parse_hash;
7644 sort_by_digest = sort_by_digest_4_5;
7645 opti_type = OPTI_TYPE_ZERO_BYTE
7646 | OPTI_TYPE_PRECOMPUTE_INIT
7647 | OPTI_TYPE_PRECOMPUTE_MERKLE
7648 | OPTI_TYPE_EARLY_SKIP
7649 | OPTI_TYPE_NOT_ITERATED
7650 | OPTI_TYPE_PREPENDED_SALT
7651 | OPTI_TYPE_RAW_HASH;
7652 dgst_pos0 = 3;
7653 dgst_pos1 = 4;
7654 dgst_pos2 = 2;
7655 dgst_pos3 = 1;
7656 break;
7657
7658 case 150: hash_type = HASH_TYPE_SHA1;
7659 salt_type = SALT_TYPE_INTERN;
7660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7661 opts_type = OPTS_TYPE_PT_GENERATE_BE
7662 | OPTS_TYPE_ST_ADD80
7663 | OPTS_TYPE_ST_ADDBITS15;
7664 kern_type = KERN_TYPE_HMACSHA1_PW;
7665 dgst_size = DGST_SIZE_4_5;
7666 parse_func = hmacsha1_parse_hash;
7667 sort_by_digest = sort_by_digest_4_5;
7668 opti_type = OPTI_TYPE_ZERO_BYTE
7669 | OPTI_TYPE_NOT_ITERATED;
7670 dgst_pos0 = 3;
7671 dgst_pos1 = 4;
7672 dgst_pos2 = 2;
7673 dgst_pos3 = 1;
7674 break;
7675
7676 case 160: hash_type = HASH_TYPE_SHA1;
7677 salt_type = SALT_TYPE_INTERN;
7678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7679 opts_type = OPTS_TYPE_PT_GENERATE_BE
7680 | OPTS_TYPE_PT_ADD80
7681 | OPTS_TYPE_PT_ADDBITS15;
7682 kern_type = KERN_TYPE_HMACSHA1_SLT;
7683 dgst_size = DGST_SIZE_4_5;
7684 parse_func = hmacsha1_parse_hash;
7685 sort_by_digest = sort_by_digest_4_5;
7686 opti_type = OPTI_TYPE_ZERO_BYTE
7687 | OPTI_TYPE_NOT_ITERATED;
7688 dgst_pos0 = 3;
7689 dgst_pos1 = 4;
7690 dgst_pos2 = 2;
7691 dgst_pos3 = 1;
7692 break;
7693
7694 case 190: hash_type = HASH_TYPE_SHA1;
7695 salt_type = SALT_TYPE_NONE;
7696 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7697 opts_type = OPTS_TYPE_PT_GENERATE_BE
7698 | OPTS_TYPE_PT_ADD80
7699 | OPTS_TYPE_PT_ADDBITS15;
7700 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7701 dgst_size = DGST_SIZE_4_5;
7702 parse_func = sha1linkedin_parse_hash;
7703 sort_by_digest = sort_by_digest_4_5;
7704 opti_type = OPTI_TYPE_ZERO_BYTE
7705 | OPTI_TYPE_PRECOMPUTE_INIT
7706 | OPTI_TYPE_EARLY_SKIP
7707 | OPTI_TYPE_NOT_ITERATED
7708 | OPTI_TYPE_NOT_SALTED;
7709 dgst_pos0 = 0;
7710 dgst_pos1 = 4;
7711 dgst_pos2 = 3;
7712 dgst_pos3 = 2;
7713 break;
7714
7715 case 200: hash_type = HASH_TYPE_MYSQL;
7716 salt_type = SALT_TYPE_NONE;
7717 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7718 opts_type = 0;
7719 kern_type = KERN_TYPE_MYSQL;
7720 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7721 parse_func = mysql323_parse_hash;
7722 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7723 opti_type = OPTI_TYPE_ZERO_BYTE;
7724 dgst_pos0 = 0;
7725 dgst_pos1 = 1;
7726 dgst_pos2 = 2;
7727 dgst_pos3 = 3;
7728 break;
7729
7730 case 300: hash_type = HASH_TYPE_SHA1;
7731 salt_type = SALT_TYPE_NONE;
7732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7733 opts_type = OPTS_TYPE_PT_GENERATE_BE
7734 | OPTS_TYPE_PT_ADD80
7735 | OPTS_TYPE_PT_ADDBITS15;
7736 kern_type = KERN_TYPE_MYSQL41;
7737 dgst_size = DGST_SIZE_4_5;
7738 parse_func = sha1_parse_hash;
7739 sort_by_digest = sort_by_digest_4_5;
7740 opti_type = OPTI_TYPE_ZERO_BYTE
7741 | OPTI_TYPE_PRECOMPUTE_INIT
7742 | OPTI_TYPE_PRECOMPUTE_MERKLE
7743 | OPTI_TYPE_EARLY_SKIP
7744 | OPTI_TYPE_NOT_ITERATED
7745 | OPTI_TYPE_NOT_SALTED;
7746 dgst_pos0 = 3;
7747 dgst_pos1 = 4;
7748 dgst_pos2 = 2;
7749 dgst_pos3 = 1;
7750 break;
7751
7752 case 400: hash_type = HASH_TYPE_MD5;
7753 salt_type = SALT_TYPE_EMBEDDED;
7754 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7755 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7756 kern_type = KERN_TYPE_PHPASS;
7757 dgst_size = DGST_SIZE_4_4;
7758 parse_func = phpass_parse_hash;
7759 sort_by_digest = sort_by_digest_4_4;
7760 opti_type = OPTI_TYPE_ZERO_BYTE
7761 | OPTI_TYPE_SLOW_HASH_SIMD;
7762 dgst_pos0 = 0;
7763 dgst_pos1 = 1;
7764 dgst_pos2 = 2;
7765 dgst_pos3 = 3;
7766 break;
7767
7768 case 500: hash_type = HASH_TYPE_MD5;
7769 salt_type = SALT_TYPE_EMBEDDED;
7770 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7771 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7772 kern_type = KERN_TYPE_MD5CRYPT;
7773 dgst_size = DGST_SIZE_4_4;
7774 parse_func = md5crypt_parse_hash;
7775 sort_by_digest = sort_by_digest_4_4;
7776 opti_type = OPTI_TYPE_ZERO_BYTE;
7777 dgst_pos0 = 0;
7778 dgst_pos1 = 1;
7779 dgst_pos2 = 2;
7780 dgst_pos3 = 3;
7781 break;
7782
7783 case 501: hash_type = HASH_TYPE_MD5;
7784 salt_type = SALT_TYPE_EMBEDDED;
7785 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7786 opts_type = OPTS_TYPE_PT_GENERATE_LE
7787 | OPTS_TYPE_HASH_COPY;
7788 kern_type = KERN_TYPE_MD5CRYPT;
7789 dgst_size = DGST_SIZE_4_4;
7790 parse_func = juniper_parse_hash;
7791 sort_by_digest = sort_by_digest_4_4;
7792 opti_type = OPTI_TYPE_ZERO_BYTE;
7793 dgst_pos0 = 0;
7794 dgst_pos1 = 1;
7795 dgst_pos2 = 2;
7796 dgst_pos3 = 3;
7797 break;
7798
7799 case 900: hash_type = HASH_TYPE_MD4;
7800 salt_type = SALT_TYPE_NONE;
7801 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7802 opts_type = OPTS_TYPE_PT_GENERATE_LE
7803 | OPTS_TYPE_PT_ADD80
7804 | OPTS_TYPE_PT_ADDBITS14;
7805 kern_type = KERN_TYPE_MD4;
7806 dgst_size = DGST_SIZE_4_4;
7807 parse_func = md4_parse_hash;
7808 sort_by_digest = sort_by_digest_4_4;
7809 opti_type = OPTI_TYPE_ZERO_BYTE
7810 | OPTI_TYPE_PRECOMPUTE_INIT
7811 | OPTI_TYPE_PRECOMPUTE_MERKLE
7812 | OPTI_TYPE_MEET_IN_MIDDLE
7813 | OPTI_TYPE_EARLY_SKIP
7814 | OPTI_TYPE_NOT_ITERATED
7815 | OPTI_TYPE_NOT_SALTED
7816 | OPTI_TYPE_RAW_HASH;
7817 dgst_pos0 = 0;
7818 dgst_pos1 = 3;
7819 dgst_pos2 = 2;
7820 dgst_pos3 = 1;
7821 break;
7822
7823 case 1000: hash_type = HASH_TYPE_MD4;
7824 salt_type = SALT_TYPE_NONE;
7825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7826 opts_type = OPTS_TYPE_PT_GENERATE_LE
7827 | OPTS_TYPE_PT_ADD80
7828 | OPTS_TYPE_PT_ADDBITS14
7829 | OPTS_TYPE_PT_UNICODE;
7830 kern_type = KERN_TYPE_MD4_PWU;
7831 dgst_size = DGST_SIZE_4_4;
7832 parse_func = md4_parse_hash;
7833 sort_by_digest = sort_by_digest_4_4;
7834 opti_type = OPTI_TYPE_ZERO_BYTE
7835 | OPTI_TYPE_PRECOMPUTE_INIT
7836 | OPTI_TYPE_PRECOMPUTE_MERKLE
7837 | OPTI_TYPE_MEET_IN_MIDDLE
7838 | OPTI_TYPE_EARLY_SKIP
7839 | OPTI_TYPE_NOT_ITERATED
7840 | OPTI_TYPE_NOT_SALTED
7841 | OPTI_TYPE_RAW_HASH;
7842 dgst_pos0 = 0;
7843 dgst_pos1 = 3;
7844 dgst_pos2 = 2;
7845 dgst_pos3 = 1;
7846 break;
7847
7848 case 1100: hash_type = HASH_TYPE_MD4;
7849 salt_type = SALT_TYPE_INTERN;
7850 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7851 opts_type = OPTS_TYPE_PT_GENERATE_LE
7852 | OPTS_TYPE_PT_ADD80
7853 | OPTS_TYPE_PT_ADDBITS14
7854 | OPTS_TYPE_PT_UNICODE
7855 | OPTS_TYPE_ST_ADD80
7856 | OPTS_TYPE_ST_UNICODE
7857 | OPTS_TYPE_ST_LOWER;
7858 kern_type = KERN_TYPE_MD44_PWUSLT;
7859 dgst_size = DGST_SIZE_4_4;
7860 parse_func = dcc_parse_hash;
7861 sort_by_digest = sort_by_digest_4_4;
7862 opti_type = OPTI_TYPE_ZERO_BYTE
7863 | OPTI_TYPE_PRECOMPUTE_INIT
7864 | OPTI_TYPE_PRECOMPUTE_MERKLE
7865 | OPTI_TYPE_EARLY_SKIP
7866 | OPTI_TYPE_NOT_ITERATED;
7867 dgst_pos0 = 0;
7868 dgst_pos1 = 3;
7869 dgst_pos2 = 2;
7870 dgst_pos3 = 1;
7871 break;
7872
7873 case 1400: hash_type = HASH_TYPE_SHA256;
7874 salt_type = SALT_TYPE_NONE;
7875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7876 opts_type = OPTS_TYPE_PT_GENERATE_BE
7877 | OPTS_TYPE_PT_ADD80
7878 | OPTS_TYPE_PT_ADDBITS15;
7879 kern_type = KERN_TYPE_SHA256;
7880 dgst_size = DGST_SIZE_4_8;
7881 parse_func = sha256_parse_hash;
7882 sort_by_digest = sort_by_digest_4_8;
7883 opti_type = OPTI_TYPE_ZERO_BYTE
7884 | OPTI_TYPE_PRECOMPUTE_INIT
7885 | OPTI_TYPE_PRECOMPUTE_MERKLE
7886 | OPTI_TYPE_EARLY_SKIP
7887 | OPTI_TYPE_NOT_ITERATED
7888 | OPTI_TYPE_NOT_SALTED
7889 | OPTI_TYPE_RAW_HASH;
7890 dgst_pos0 = 3;
7891 dgst_pos1 = 7;
7892 dgst_pos2 = 2;
7893 dgst_pos3 = 6;
7894 break;
7895
7896 case 1410: hash_type = HASH_TYPE_SHA256;
7897 salt_type = SALT_TYPE_INTERN;
7898 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7899 opts_type = OPTS_TYPE_PT_GENERATE_BE
7900 | OPTS_TYPE_ST_ADD80
7901 | OPTS_TYPE_ST_ADDBITS15;
7902 kern_type = KERN_TYPE_SHA256_PWSLT;
7903 dgst_size = DGST_SIZE_4_8;
7904 parse_func = sha256s_parse_hash;
7905 sort_by_digest = sort_by_digest_4_8;
7906 opti_type = OPTI_TYPE_ZERO_BYTE
7907 | OPTI_TYPE_PRECOMPUTE_INIT
7908 | OPTI_TYPE_PRECOMPUTE_MERKLE
7909 | OPTI_TYPE_EARLY_SKIP
7910 | OPTI_TYPE_NOT_ITERATED
7911 | OPTI_TYPE_APPENDED_SALT
7912 | OPTI_TYPE_RAW_HASH;
7913 dgst_pos0 = 3;
7914 dgst_pos1 = 7;
7915 dgst_pos2 = 2;
7916 dgst_pos3 = 6;
7917 break;
7918
7919 case 1420: hash_type = HASH_TYPE_SHA256;
7920 salt_type = SALT_TYPE_INTERN;
7921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7922 opts_type = OPTS_TYPE_PT_GENERATE_BE
7923 | OPTS_TYPE_PT_ADD80
7924 | OPTS_TYPE_PT_ADDBITS15;
7925 kern_type = KERN_TYPE_SHA256_SLTPW;
7926 dgst_size = DGST_SIZE_4_8;
7927 parse_func = sha256s_parse_hash;
7928 sort_by_digest = sort_by_digest_4_8;
7929 opti_type = OPTI_TYPE_ZERO_BYTE
7930 | OPTI_TYPE_PRECOMPUTE_INIT
7931 | OPTI_TYPE_PRECOMPUTE_MERKLE
7932 | OPTI_TYPE_EARLY_SKIP
7933 | OPTI_TYPE_NOT_ITERATED
7934 | OPTI_TYPE_PREPENDED_SALT
7935 | OPTI_TYPE_RAW_HASH;
7936 dgst_pos0 = 3;
7937 dgst_pos1 = 7;
7938 dgst_pos2 = 2;
7939 dgst_pos3 = 6;
7940 break;
7941
7942 case 1421: hash_type = HASH_TYPE_SHA256;
7943 salt_type = SALT_TYPE_EMBEDDED;
7944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7945 opts_type = OPTS_TYPE_PT_GENERATE_BE
7946 | OPTS_TYPE_PT_ADD80
7947 | OPTS_TYPE_PT_ADDBITS15;
7948 kern_type = KERN_TYPE_SHA256_SLTPW;
7949 dgst_size = DGST_SIZE_4_8;
7950 parse_func = hmailserver_parse_hash;
7951 sort_by_digest = sort_by_digest_4_8;
7952 opti_type = OPTI_TYPE_ZERO_BYTE
7953 | OPTI_TYPE_PRECOMPUTE_INIT
7954 | OPTI_TYPE_PRECOMPUTE_MERKLE
7955 | OPTI_TYPE_EARLY_SKIP
7956 | OPTI_TYPE_NOT_ITERATED
7957 | OPTI_TYPE_PREPENDED_SALT
7958 | OPTI_TYPE_RAW_HASH;
7959 dgst_pos0 = 3;
7960 dgst_pos1 = 7;
7961 dgst_pos2 = 2;
7962 dgst_pos3 = 6;
7963 break;
7964
7965 case 1430: hash_type = HASH_TYPE_SHA256;
7966 salt_type = SALT_TYPE_INTERN;
7967 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7968 opts_type = OPTS_TYPE_PT_GENERATE_BE
7969 | OPTS_TYPE_PT_UNICODE
7970 | OPTS_TYPE_ST_ADD80
7971 | OPTS_TYPE_ST_ADDBITS15;
7972 kern_type = KERN_TYPE_SHA256_PWUSLT;
7973 dgst_size = DGST_SIZE_4_8;
7974 parse_func = sha256s_parse_hash;
7975 sort_by_digest = sort_by_digest_4_8;
7976 opti_type = OPTI_TYPE_ZERO_BYTE
7977 | OPTI_TYPE_PRECOMPUTE_INIT
7978 | OPTI_TYPE_PRECOMPUTE_MERKLE
7979 | OPTI_TYPE_EARLY_SKIP
7980 | OPTI_TYPE_NOT_ITERATED
7981 | OPTI_TYPE_APPENDED_SALT
7982 | OPTI_TYPE_RAW_HASH;
7983 dgst_pos0 = 3;
7984 dgst_pos1 = 7;
7985 dgst_pos2 = 2;
7986 dgst_pos3 = 6;
7987 break;
7988
7989 case 1440: hash_type = HASH_TYPE_SHA256;
7990 salt_type = SALT_TYPE_INTERN;
7991 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7992 opts_type = OPTS_TYPE_PT_GENERATE_BE
7993 | OPTS_TYPE_PT_ADD80
7994 | OPTS_TYPE_PT_ADDBITS15
7995 | OPTS_TYPE_PT_UNICODE;
7996 kern_type = KERN_TYPE_SHA256_SLTPWU;
7997 dgst_size = DGST_SIZE_4_8;
7998 parse_func = sha256s_parse_hash;
7999 sort_by_digest = sort_by_digest_4_8;
8000 opti_type = OPTI_TYPE_ZERO_BYTE
8001 | OPTI_TYPE_PRECOMPUTE_INIT
8002 | OPTI_TYPE_PRECOMPUTE_MERKLE
8003 | OPTI_TYPE_EARLY_SKIP
8004 | OPTI_TYPE_NOT_ITERATED
8005 | OPTI_TYPE_PREPENDED_SALT
8006 | OPTI_TYPE_RAW_HASH;
8007 dgst_pos0 = 3;
8008 dgst_pos1 = 7;
8009 dgst_pos2 = 2;
8010 dgst_pos3 = 6;
8011 break;
8012
8013 case 1441: hash_type = HASH_TYPE_SHA256;
8014 salt_type = SALT_TYPE_EMBEDDED;
8015 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8016 opts_type = OPTS_TYPE_PT_GENERATE_BE
8017 | OPTS_TYPE_PT_ADD80
8018 | OPTS_TYPE_PT_ADDBITS15
8019 | OPTS_TYPE_PT_UNICODE
8020 | OPTS_TYPE_ST_BASE64;
8021 kern_type = KERN_TYPE_SHA256_SLTPWU;
8022 dgst_size = DGST_SIZE_4_8;
8023 parse_func = episerver4_parse_hash;
8024 sort_by_digest = sort_by_digest_4_8;
8025 opti_type = OPTI_TYPE_ZERO_BYTE
8026 | OPTI_TYPE_PRECOMPUTE_INIT
8027 | OPTI_TYPE_PRECOMPUTE_MERKLE
8028 | OPTI_TYPE_EARLY_SKIP
8029 | OPTI_TYPE_NOT_ITERATED
8030 | OPTI_TYPE_PREPENDED_SALT
8031 | OPTI_TYPE_RAW_HASH;
8032 dgst_pos0 = 3;
8033 dgst_pos1 = 7;
8034 dgst_pos2 = 2;
8035 dgst_pos3 = 6;
8036 break;
8037
8038 case 1450: hash_type = HASH_TYPE_SHA256;
8039 salt_type = SALT_TYPE_INTERN;
8040 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8041 opts_type = OPTS_TYPE_PT_GENERATE_BE
8042 | OPTS_TYPE_ST_ADD80;
8043 kern_type = KERN_TYPE_HMACSHA256_PW;
8044 dgst_size = DGST_SIZE_4_8;
8045 parse_func = hmacsha256_parse_hash;
8046 sort_by_digest = sort_by_digest_4_8;
8047 opti_type = OPTI_TYPE_ZERO_BYTE
8048 | OPTI_TYPE_NOT_ITERATED;
8049 dgst_pos0 = 3;
8050 dgst_pos1 = 7;
8051 dgst_pos2 = 2;
8052 dgst_pos3 = 6;
8053 break;
8054
8055 case 1460: hash_type = HASH_TYPE_SHA256;
8056 salt_type = SALT_TYPE_INTERN;
8057 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8058 opts_type = OPTS_TYPE_PT_GENERATE_BE
8059 | OPTS_TYPE_PT_ADD80
8060 | OPTS_TYPE_PT_ADDBITS15;
8061 kern_type = KERN_TYPE_HMACSHA256_SLT;
8062 dgst_size = DGST_SIZE_4_8;
8063 parse_func = hmacsha256_parse_hash;
8064 sort_by_digest = sort_by_digest_4_8;
8065 opti_type = OPTI_TYPE_ZERO_BYTE
8066 | OPTI_TYPE_NOT_ITERATED;
8067 dgst_pos0 = 3;
8068 dgst_pos1 = 7;
8069 dgst_pos2 = 2;
8070 dgst_pos3 = 6;
8071 break;
8072
8073 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8074 salt_type = SALT_TYPE_EMBEDDED;
8075 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8076 opts_type = OPTS_TYPE_PT_GENERATE_LE
8077 | OPTS_TYPE_PT_BITSLICE;
8078 kern_type = KERN_TYPE_DESCRYPT;
8079 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8080 parse_func = descrypt_parse_hash;
8081 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8082 opti_type = OPTI_TYPE_ZERO_BYTE
8083 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8084 dgst_pos0 = 0;
8085 dgst_pos1 = 1;
8086 dgst_pos2 = 2;
8087 dgst_pos3 = 3;
8088 break;
8089
8090 case 1600: hash_type = HASH_TYPE_MD5;
8091 salt_type = SALT_TYPE_EMBEDDED;
8092 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8093 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8094 kern_type = KERN_TYPE_APR1CRYPT;
8095 dgst_size = DGST_SIZE_4_4;
8096 parse_func = md5apr1_parse_hash;
8097 sort_by_digest = sort_by_digest_4_4;
8098 opti_type = OPTI_TYPE_ZERO_BYTE;
8099 dgst_pos0 = 0;
8100 dgst_pos1 = 1;
8101 dgst_pos2 = 2;
8102 dgst_pos3 = 3;
8103 break;
8104
8105 case 1700: hash_type = HASH_TYPE_SHA512;
8106 salt_type = SALT_TYPE_NONE;
8107 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8108 opts_type = OPTS_TYPE_PT_GENERATE_BE
8109 | OPTS_TYPE_PT_ADD80
8110 | OPTS_TYPE_PT_ADDBITS15;
8111 kern_type = KERN_TYPE_SHA512;
8112 dgst_size = DGST_SIZE_8_8;
8113 parse_func = sha512_parse_hash;
8114 sort_by_digest = sort_by_digest_8_8;
8115 opti_type = OPTI_TYPE_ZERO_BYTE
8116 | OPTI_TYPE_PRECOMPUTE_INIT
8117 | OPTI_TYPE_PRECOMPUTE_MERKLE
8118 | OPTI_TYPE_EARLY_SKIP
8119 | OPTI_TYPE_NOT_ITERATED
8120 | OPTI_TYPE_NOT_SALTED
8121 | OPTI_TYPE_USES_BITS_64
8122 | OPTI_TYPE_RAW_HASH;
8123 dgst_pos0 = 14;
8124 dgst_pos1 = 15;
8125 dgst_pos2 = 6;
8126 dgst_pos3 = 7;
8127 break;
8128
8129 case 1710: hash_type = HASH_TYPE_SHA512;
8130 salt_type = SALT_TYPE_INTERN;
8131 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8132 opts_type = OPTS_TYPE_PT_GENERATE_BE
8133 | OPTS_TYPE_ST_ADD80
8134 | OPTS_TYPE_ST_ADDBITS15;
8135 kern_type = KERN_TYPE_SHA512_PWSLT;
8136 dgst_size = DGST_SIZE_8_8;
8137 parse_func = sha512s_parse_hash;
8138 sort_by_digest = sort_by_digest_8_8;
8139 opti_type = OPTI_TYPE_ZERO_BYTE
8140 | OPTI_TYPE_PRECOMPUTE_INIT
8141 | OPTI_TYPE_PRECOMPUTE_MERKLE
8142 | OPTI_TYPE_EARLY_SKIP
8143 | OPTI_TYPE_NOT_ITERATED
8144 | OPTI_TYPE_APPENDED_SALT
8145 | OPTI_TYPE_USES_BITS_64
8146 | OPTI_TYPE_RAW_HASH;
8147 dgst_pos0 = 14;
8148 dgst_pos1 = 15;
8149 dgst_pos2 = 6;
8150 dgst_pos3 = 7;
8151 break;
8152
8153 case 1711: hash_type = HASH_TYPE_SHA512;
8154 salt_type = SALT_TYPE_EMBEDDED;
8155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8156 opts_type = OPTS_TYPE_PT_GENERATE_BE
8157 | OPTS_TYPE_ST_ADD80
8158 | OPTS_TYPE_ST_ADDBITS15;
8159 kern_type = KERN_TYPE_SHA512_PWSLT;
8160 dgst_size = DGST_SIZE_8_8;
8161 parse_func = sha512b64s_parse_hash;
8162 sort_by_digest = sort_by_digest_8_8;
8163 opti_type = OPTI_TYPE_ZERO_BYTE
8164 | OPTI_TYPE_PRECOMPUTE_INIT
8165 | OPTI_TYPE_PRECOMPUTE_MERKLE
8166 | OPTI_TYPE_EARLY_SKIP
8167 | OPTI_TYPE_NOT_ITERATED
8168 | OPTI_TYPE_APPENDED_SALT
8169 | OPTI_TYPE_USES_BITS_64
8170 | OPTI_TYPE_RAW_HASH;
8171 dgst_pos0 = 14;
8172 dgst_pos1 = 15;
8173 dgst_pos2 = 6;
8174 dgst_pos3 = 7;
8175 break;
8176
8177 case 1720: hash_type = HASH_TYPE_SHA512;
8178 salt_type = SALT_TYPE_INTERN;
8179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8180 opts_type = OPTS_TYPE_PT_GENERATE_BE
8181 | OPTS_TYPE_PT_ADD80
8182 | OPTS_TYPE_PT_ADDBITS15;
8183 kern_type = KERN_TYPE_SHA512_SLTPW;
8184 dgst_size = DGST_SIZE_8_8;
8185 parse_func = sha512s_parse_hash;
8186 sort_by_digest = sort_by_digest_8_8;
8187 opti_type = OPTI_TYPE_ZERO_BYTE
8188 | OPTI_TYPE_PRECOMPUTE_INIT
8189 | OPTI_TYPE_PRECOMPUTE_MERKLE
8190 | OPTI_TYPE_EARLY_SKIP
8191 | OPTI_TYPE_NOT_ITERATED
8192 | OPTI_TYPE_PREPENDED_SALT
8193 | OPTI_TYPE_USES_BITS_64
8194 | OPTI_TYPE_RAW_HASH;
8195 dgst_pos0 = 14;
8196 dgst_pos1 = 15;
8197 dgst_pos2 = 6;
8198 dgst_pos3 = 7;
8199 break;
8200
8201 case 1722: hash_type = HASH_TYPE_SHA512;
8202 salt_type = SALT_TYPE_EMBEDDED;
8203 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8204 opts_type = OPTS_TYPE_PT_GENERATE_BE
8205 | OPTS_TYPE_PT_ADD80
8206 | OPTS_TYPE_PT_ADDBITS15
8207 | OPTS_TYPE_ST_HEX;
8208 kern_type = KERN_TYPE_SHA512_SLTPW;
8209 dgst_size = DGST_SIZE_8_8;
8210 parse_func = osx512_parse_hash;
8211 sort_by_digest = sort_by_digest_8_8;
8212 opti_type = OPTI_TYPE_ZERO_BYTE
8213 | OPTI_TYPE_PRECOMPUTE_INIT
8214 | OPTI_TYPE_PRECOMPUTE_MERKLE
8215 | OPTI_TYPE_EARLY_SKIP
8216 | OPTI_TYPE_NOT_ITERATED
8217 | OPTI_TYPE_PREPENDED_SALT
8218 | OPTI_TYPE_USES_BITS_64
8219 | OPTI_TYPE_RAW_HASH;
8220 dgst_pos0 = 14;
8221 dgst_pos1 = 15;
8222 dgst_pos2 = 6;
8223 dgst_pos3 = 7;
8224 break;
8225
8226 case 1730: hash_type = HASH_TYPE_SHA512;
8227 salt_type = SALT_TYPE_INTERN;
8228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8229 opts_type = OPTS_TYPE_PT_GENERATE_BE
8230 | OPTS_TYPE_PT_UNICODE
8231 | OPTS_TYPE_ST_ADD80
8232 | OPTS_TYPE_ST_ADDBITS15;
8233 kern_type = KERN_TYPE_SHA512_PWSLTU;
8234 dgst_size = DGST_SIZE_8_8;
8235 parse_func = sha512s_parse_hash;
8236 sort_by_digest = sort_by_digest_8_8;
8237 opti_type = OPTI_TYPE_ZERO_BYTE
8238 | OPTI_TYPE_PRECOMPUTE_INIT
8239 | OPTI_TYPE_PRECOMPUTE_MERKLE
8240 | OPTI_TYPE_EARLY_SKIP
8241 | OPTI_TYPE_NOT_ITERATED
8242 | OPTI_TYPE_APPENDED_SALT
8243 | OPTI_TYPE_USES_BITS_64
8244 | OPTI_TYPE_RAW_HASH;
8245 dgst_pos0 = 14;
8246 dgst_pos1 = 15;
8247 dgst_pos2 = 6;
8248 dgst_pos3 = 7;
8249 break;
8250
8251 case 1731: hash_type = HASH_TYPE_SHA512;
8252 salt_type = SALT_TYPE_EMBEDDED;
8253 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8254 opts_type = OPTS_TYPE_PT_GENERATE_BE
8255 | OPTS_TYPE_PT_UNICODE
8256 | OPTS_TYPE_ST_ADD80
8257 | OPTS_TYPE_ST_ADDBITS15
8258 | OPTS_TYPE_ST_HEX;
8259 kern_type = KERN_TYPE_SHA512_PWSLTU;
8260 dgst_size = DGST_SIZE_8_8;
8261 parse_func = mssql2012_parse_hash;
8262 sort_by_digest = sort_by_digest_8_8;
8263 opti_type = OPTI_TYPE_ZERO_BYTE
8264 | OPTI_TYPE_PRECOMPUTE_INIT
8265 | OPTI_TYPE_PRECOMPUTE_MERKLE
8266 | OPTI_TYPE_EARLY_SKIP
8267 | OPTI_TYPE_NOT_ITERATED
8268 | OPTI_TYPE_APPENDED_SALT
8269 | OPTI_TYPE_USES_BITS_64
8270 | OPTI_TYPE_RAW_HASH;
8271 dgst_pos0 = 14;
8272 dgst_pos1 = 15;
8273 dgst_pos2 = 6;
8274 dgst_pos3 = 7;
8275 break;
8276
8277 case 1740: hash_type = HASH_TYPE_SHA512;
8278 salt_type = SALT_TYPE_INTERN;
8279 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8280 opts_type = OPTS_TYPE_PT_GENERATE_BE
8281 | OPTS_TYPE_PT_ADD80
8282 | OPTS_TYPE_PT_ADDBITS15
8283 | OPTS_TYPE_PT_UNICODE;
8284 kern_type = KERN_TYPE_SHA512_SLTPWU;
8285 dgst_size = DGST_SIZE_8_8;
8286 parse_func = sha512s_parse_hash;
8287 sort_by_digest = sort_by_digest_8_8;
8288 opti_type = OPTI_TYPE_ZERO_BYTE
8289 | OPTI_TYPE_PRECOMPUTE_INIT
8290 | OPTI_TYPE_PRECOMPUTE_MERKLE
8291 | OPTI_TYPE_EARLY_SKIP
8292 | OPTI_TYPE_NOT_ITERATED
8293 | OPTI_TYPE_PREPENDED_SALT
8294 | OPTI_TYPE_USES_BITS_64
8295 | OPTI_TYPE_RAW_HASH;
8296 dgst_pos0 = 14;
8297 dgst_pos1 = 15;
8298 dgst_pos2 = 6;
8299 dgst_pos3 = 7;
8300 break;
8301
8302 case 1750: hash_type = HASH_TYPE_SHA512;
8303 salt_type = SALT_TYPE_INTERN;
8304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8305 opts_type = OPTS_TYPE_PT_GENERATE_BE
8306 | OPTS_TYPE_ST_ADD80;
8307 kern_type = KERN_TYPE_HMACSHA512_PW;
8308 dgst_size = DGST_SIZE_8_8;
8309 parse_func = hmacsha512_parse_hash;
8310 sort_by_digest = sort_by_digest_8_8;
8311 opti_type = OPTI_TYPE_ZERO_BYTE
8312 | OPTI_TYPE_USES_BITS_64
8313 | OPTI_TYPE_NOT_ITERATED;
8314 dgst_pos0 = 14;
8315 dgst_pos1 = 15;
8316 dgst_pos2 = 6;
8317 dgst_pos3 = 7;
8318 break;
8319
8320 case 1760: hash_type = HASH_TYPE_SHA512;
8321 salt_type = SALT_TYPE_INTERN;
8322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8323 opts_type = OPTS_TYPE_PT_GENERATE_BE
8324 | OPTS_TYPE_PT_ADD80
8325 | OPTS_TYPE_PT_ADDBITS15;
8326 kern_type = KERN_TYPE_HMACSHA512_SLT;
8327 dgst_size = DGST_SIZE_8_8;
8328 parse_func = hmacsha512_parse_hash;
8329 sort_by_digest = sort_by_digest_8_8;
8330 opti_type = OPTI_TYPE_ZERO_BYTE
8331 | OPTI_TYPE_USES_BITS_64
8332 | OPTI_TYPE_NOT_ITERATED;
8333 dgst_pos0 = 14;
8334 dgst_pos1 = 15;
8335 dgst_pos2 = 6;
8336 dgst_pos3 = 7;
8337 break;
8338
8339 case 1800: hash_type = HASH_TYPE_SHA512;
8340 salt_type = SALT_TYPE_EMBEDDED;
8341 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8342 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8343 kern_type = KERN_TYPE_SHA512CRYPT;
8344 dgst_size = DGST_SIZE_8_8;
8345 parse_func = sha512crypt_parse_hash;
8346 sort_by_digest = sort_by_digest_8_8;
8347 opti_type = OPTI_TYPE_ZERO_BYTE
8348 | OPTI_TYPE_USES_BITS_64;
8349 dgst_pos0 = 0;
8350 dgst_pos1 = 1;
8351 dgst_pos2 = 2;
8352 dgst_pos3 = 3;
8353 break;
8354
8355 case 2100: hash_type = HASH_TYPE_DCC2;
8356 salt_type = SALT_TYPE_EMBEDDED;
8357 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8358 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8359 | OPTS_TYPE_ST_LOWER
8360 | OPTS_TYPE_ST_UNICODE;
8361 kern_type = KERN_TYPE_DCC2;
8362 dgst_size = DGST_SIZE_4_4;
8363 parse_func = dcc2_parse_hash;
8364 sort_by_digest = sort_by_digest_4_4;
8365 opti_type = OPTI_TYPE_ZERO_BYTE
8366 | OPTI_TYPE_SLOW_HASH_SIMD;
8367 dgst_pos0 = 0;
8368 dgst_pos1 = 1;
8369 dgst_pos2 = 2;
8370 dgst_pos3 = 3;
8371 break;
8372
8373 case 2400: hash_type = HASH_TYPE_MD5;
8374 salt_type = SALT_TYPE_NONE;
8375 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8376 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8377 kern_type = KERN_TYPE_MD5PIX;
8378 dgst_size = DGST_SIZE_4_4;
8379 parse_func = md5pix_parse_hash;
8380 sort_by_digest = sort_by_digest_4_4;
8381 opti_type = OPTI_TYPE_ZERO_BYTE
8382 | OPTI_TYPE_PRECOMPUTE_INIT
8383 | OPTI_TYPE_PRECOMPUTE_MERKLE
8384 | OPTI_TYPE_EARLY_SKIP
8385 | OPTI_TYPE_NOT_ITERATED
8386 | OPTI_TYPE_NOT_SALTED;
8387 dgst_pos0 = 0;
8388 dgst_pos1 = 3;
8389 dgst_pos2 = 2;
8390 dgst_pos3 = 1;
8391 break;
8392
8393 case 2410: hash_type = HASH_TYPE_MD5;
8394 salt_type = SALT_TYPE_INTERN;
8395 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8396 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8397 kern_type = KERN_TYPE_MD5ASA;
8398 dgst_size = DGST_SIZE_4_4;
8399 parse_func = md5asa_parse_hash;
8400 sort_by_digest = sort_by_digest_4_4;
8401 opti_type = OPTI_TYPE_ZERO_BYTE
8402 | OPTI_TYPE_PRECOMPUTE_INIT
8403 | OPTI_TYPE_PRECOMPUTE_MERKLE
8404 | OPTI_TYPE_EARLY_SKIP
8405 | OPTI_TYPE_NOT_ITERATED;
8406 dgst_pos0 = 0;
8407 dgst_pos1 = 3;
8408 dgst_pos2 = 2;
8409 dgst_pos3 = 1;
8410 break;
8411
8412 case 2500: hash_type = HASH_TYPE_WPA;
8413 salt_type = SALT_TYPE_EMBEDDED;
8414 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8415 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8416 kern_type = KERN_TYPE_WPA;
8417 dgst_size = DGST_SIZE_4_4;
8418 parse_func = wpa_parse_hash;
8419 sort_by_digest = sort_by_digest_4_4;
8420 opti_type = OPTI_TYPE_ZERO_BYTE
8421 | OPTI_TYPE_SLOW_HASH_SIMD;
8422 dgst_pos0 = 0;
8423 dgst_pos1 = 1;
8424 dgst_pos2 = 2;
8425 dgst_pos3 = 3;
8426 break;
8427
8428 case 2600: hash_type = HASH_TYPE_MD5;
8429 salt_type = SALT_TYPE_VIRTUAL;
8430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8431 opts_type = OPTS_TYPE_PT_GENERATE_LE
8432 | OPTS_TYPE_PT_ADD80
8433 | OPTS_TYPE_PT_ADDBITS14
8434 | OPTS_TYPE_ST_ADD80;
8435 kern_type = KERN_TYPE_MD55_PWSLT1;
8436 dgst_size = DGST_SIZE_4_4;
8437 parse_func = md5md5_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 dgst_pos0 = 0;
8444 dgst_pos1 = 3;
8445 dgst_pos2 = 2;
8446 dgst_pos3 = 1;
8447 break;
8448
8449 case 2611: hash_type = HASH_TYPE_MD5;
8450 salt_type = SALT_TYPE_INTERN;
8451 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8452 opts_type = OPTS_TYPE_PT_GENERATE_LE
8453 | OPTS_TYPE_PT_ADD80
8454 | OPTS_TYPE_PT_ADDBITS14
8455 | OPTS_TYPE_ST_ADD80;
8456 kern_type = KERN_TYPE_MD55_PWSLT1;
8457 dgst_size = DGST_SIZE_4_4;
8458 parse_func = vb3_parse_hash;
8459 sort_by_digest = sort_by_digest_4_4;
8460 opti_type = OPTI_TYPE_ZERO_BYTE
8461 | OPTI_TYPE_PRECOMPUTE_INIT
8462 | OPTI_TYPE_PRECOMPUTE_MERKLE
8463 | OPTI_TYPE_EARLY_SKIP;
8464 dgst_pos0 = 0;
8465 dgst_pos1 = 3;
8466 dgst_pos2 = 2;
8467 dgst_pos3 = 1;
8468 break;
8469
8470 case 2612: hash_type = HASH_TYPE_MD5;
8471 salt_type = SALT_TYPE_EMBEDDED;
8472 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8473 opts_type = OPTS_TYPE_PT_GENERATE_LE
8474 | OPTS_TYPE_PT_ADD80
8475 | OPTS_TYPE_PT_ADDBITS14
8476 | OPTS_TYPE_ST_ADD80
8477 | OPTS_TYPE_ST_HEX;
8478 kern_type = KERN_TYPE_MD55_PWSLT1;
8479 dgst_size = DGST_SIZE_4_4;
8480 parse_func = phps_parse_hash;
8481 sort_by_digest = sort_by_digest_4_4;
8482 opti_type = OPTI_TYPE_ZERO_BYTE
8483 | OPTI_TYPE_PRECOMPUTE_INIT
8484 | OPTI_TYPE_PRECOMPUTE_MERKLE
8485 | OPTI_TYPE_EARLY_SKIP;
8486 dgst_pos0 = 0;
8487 dgst_pos1 = 3;
8488 dgst_pos2 = 2;
8489 dgst_pos3 = 1;
8490 break;
8491
8492 case 2711: hash_type = HASH_TYPE_MD5;
8493 salt_type = SALT_TYPE_INTERN;
8494 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8495 opts_type = OPTS_TYPE_PT_GENERATE_LE
8496 | OPTS_TYPE_PT_ADD80
8497 | OPTS_TYPE_PT_ADDBITS14
8498 | OPTS_TYPE_ST_ADD80;
8499 kern_type = KERN_TYPE_MD55_PWSLT2;
8500 dgst_size = DGST_SIZE_4_4;
8501 parse_func = vb30_parse_hash;
8502 sort_by_digest = sort_by_digest_4_4;
8503 opti_type = OPTI_TYPE_ZERO_BYTE
8504 | OPTI_TYPE_PRECOMPUTE_INIT
8505 | OPTI_TYPE_EARLY_SKIP;
8506 dgst_pos0 = 0;
8507 dgst_pos1 = 3;
8508 dgst_pos2 = 2;
8509 dgst_pos3 = 1;
8510 break;
8511
8512 case 2811: hash_type = HASH_TYPE_MD5;
8513 salt_type = SALT_TYPE_INTERN;
8514 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8515 opts_type = OPTS_TYPE_PT_GENERATE_LE
8516 | OPTS_TYPE_PT_ADD80
8517 | OPTS_TYPE_PT_ADDBITS14;
8518 kern_type = KERN_TYPE_MD55_SLTPW;
8519 dgst_size = DGST_SIZE_4_4;
8520 parse_func = ipb2_parse_hash;
8521 sort_by_digest = sort_by_digest_4_4;
8522 opti_type = OPTI_TYPE_ZERO_BYTE
8523 | OPTI_TYPE_PRECOMPUTE_INIT
8524 | OPTI_TYPE_EARLY_SKIP;
8525 dgst_pos0 = 0;
8526 dgst_pos1 = 3;
8527 dgst_pos2 = 2;
8528 dgst_pos3 = 1;
8529 break;
8530
8531 case 3000: hash_type = HASH_TYPE_LM;
8532 salt_type = SALT_TYPE_NONE;
8533 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8534 opts_type = OPTS_TYPE_PT_GENERATE_LE
8535 | OPTS_TYPE_PT_UPPER
8536 | OPTS_TYPE_PT_BITSLICE;
8537 kern_type = KERN_TYPE_LM;
8538 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8539 parse_func = lm_parse_hash;
8540 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8541 opti_type = OPTI_TYPE_ZERO_BYTE
8542 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8543 dgst_pos0 = 0;
8544 dgst_pos1 = 1;
8545 dgst_pos2 = 2;
8546 dgst_pos3 = 3;
8547 break;
8548
8549 case 3100: hash_type = HASH_TYPE_ORACLEH;
8550 salt_type = SALT_TYPE_INTERN;
8551 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8552 opts_type = OPTS_TYPE_PT_GENERATE_LE
8553 | OPTS_TYPE_PT_UPPER
8554 | OPTS_TYPE_ST_UPPER;
8555 kern_type = KERN_TYPE_ORACLEH;
8556 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8557 parse_func = oracleh_parse_hash;
8558 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8559 opti_type = OPTI_TYPE_ZERO_BYTE;
8560 dgst_pos0 = 0;
8561 dgst_pos1 = 1;
8562 dgst_pos2 = 2;
8563 dgst_pos3 = 3;
8564 break;
8565
8566 case 3200: hash_type = HASH_TYPE_BCRYPT;
8567 salt_type = SALT_TYPE_EMBEDDED;
8568 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8569 opts_type = OPTS_TYPE_PT_GENERATE_LE
8570 | OPTS_TYPE_ST_GENERATE_LE;
8571 kern_type = KERN_TYPE_BCRYPT;
8572 dgst_size = DGST_SIZE_4_6;
8573 parse_func = bcrypt_parse_hash;
8574 sort_by_digest = sort_by_digest_4_6;
8575 opti_type = OPTI_TYPE_ZERO_BYTE;
8576 dgst_pos0 = 0;
8577 dgst_pos1 = 1;
8578 dgst_pos2 = 2;
8579 dgst_pos3 = 3;
8580 break;
8581
8582 case 3710: hash_type = HASH_TYPE_MD5;
8583 salt_type = SALT_TYPE_INTERN;
8584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8585 opts_type = OPTS_TYPE_PT_GENERATE_LE
8586 | OPTS_TYPE_PT_ADD80
8587 | OPTS_TYPE_PT_ADDBITS14;
8588 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8589 dgst_size = DGST_SIZE_4_4;
8590 parse_func = md5s_parse_hash;
8591 sort_by_digest = sort_by_digest_4_4;
8592 opti_type = OPTI_TYPE_ZERO_BYTE
8593 | OPTI_TYPE_PRECOMPUTE_INIT
8594 | OPTI_TYPE_PRECOMPUTE_MERKLE
8595 | OPTI_TYPE_EARLY_SKIP;
8596 dgst_pos0 = 0;
8597 dgst_pos1 = 3;
8598 dgst_pos2 = 2;
8599 dgst_pos3 = 1;
8600 break;
8601
8602 case 3711: hash_type = HASH_TYPE_MD5;
8603 salt_type = SALT_TYPE_EMBEDDED;
8604 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8605 opts_type = OPTS_TYPE_PT_GENERATE_LE
8606 | OPTS_TYPE_PT_ADD80
8607 | OPTS_TYPE_PT_ADDBITS14;
8608 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8609 dgst_size = DGST_SIZE_4_4;
8610 parse_func = mediawiki_b_parse_hash;
8611 sort_by_digest = sort_by_digest_4_4;
8612 opti_type = OPTI_TYPE_ZERO_BYTE
8613 | OPTI_TYPE_PRECOMPUTE_INIT
8614 | OPTI_TYPE_PRECOMPUTE_MERKLE
8615 | OPTI_TYPE_EARLY_SKIP;
8616 dgst_pos0 = 0;
8617 dgst_pos1 = 3;
8618 dgst_pos2 = 2;
8619 dgst_pos3 = 1;
8620 break;
8621
8622 case 3800: hash_type = HASH_TYPE_MD5;
8623 salt_type = SALT_TYPE_INTERN;
8624 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8625 opts_type = OPTS_TYPE_PT_GENERATE_LE
8626 | OPTS_TYPE_ST_ADDBITS14;
8627 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8628 dgst_size = DGST_SIZE_4_4;
8629 parse_func = md5s_parse_hash;
8630 sort_by_digest = sort_by_digest_4_4;
8631 opti_type = OPTI_TYPE_ZERO_BYTE
8632 | OPTI_TYPE_PRECOMPUTE_INIT
8633 | OPTI_TYPE_PRECOMPUTE_MERKLE
8634 | OPTI_TYPE_EARLY_SKIP
8635 | OPTI_TYPE_NOT_ITERATED
8636 | OPTI_TYPE_RAW_HASH;
8637 dgst_pos0 = 0;
8638 dgst_pos1 = 3;
8639 dgst_pos2 = 2;
8640 dgst_pos3 = 1;
8641 break;
8642
8643 case 4300: hash_type = HASH_TYPE_MD5;
8644 salt_type = SALT_TYPE_VIRTUAL;
8645 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8646 opts_type = OPTS_TYPE_PT_GENERATE_LE
8647 | OPTS_TYPE_PT_ADD80
8648 | OPTS_TYPE_PT_ADDBITS14
8649 | OPTS_TYPE_ST_ADD80;
8650 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8651 dgst_size = DGST_SIZE_4_4;
8652 parse_func = md5md5_parse_hash;
8653 sort_by_digest = sort_by_digest_4_4;
8654 opti_type = OPTI_TYPE_ZERO_BYTE
8655 | OPTI_TYPE_PRECOMPUTE_INIT
8656 | OPTI_TYPE_PRECOMPUTE_MERKLE
8657 | OPTI_TYPE_EARLY_SKIP;
8658 dgst_pos0 = 0;
8659 dgst_pos1 = 3;
8660 dgst_pos2 = 2;
8661 dgst_pos3 = 1;
8662 break;
8663
8664
8665 case 4400: hash_type = HASH_TYPE_MD5;
8666 salt_type = SALT_TYPE_NONE;
8667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8668 opts_type = OPTS_TYPE_PT_GENERATE_BE
8669 | OPTS_TYPE_PT_ADD80
8670 | OPTS_TYPE_PT_ADDBITS15;
8671 kern_type = KERN_TYPE_MD5_SHA1;
8672 dgst_size = DGST_SIZE_4_4;
8673 parse_func = md5_parse_hash;
8674 sort_by_digest = sort_by_digest_4_4;
8675 opti_type = OPTI_TYPE_ZERO_BYTE
8676 | OPTI_TYPE_PRECOMPUTE_INIT
8677 | OPTI_TYPE_PRECOMPUTE_MERKLE
8678 | OPTI_TYPE_EARLY_SKIP
8679 | OPTI_TYPE_NOT_ITERATED
8680 | OPTI_TYPE_NOT_SALTED
8681 | OPTI_TYPE_RAW_HASH;
8682 dgst_pos0 = 0;
8683 dgst_pos1 = 3;
8684 dgst_pos2 = 2;
8685 dgst_pos3 = 1;
8686 break;
8687
8688 case 4500: hash_type = HASH_TYPE_SHA1;
8689 salt_type = SALT_TYPE_NONE;
8690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8691 opts_type = OPTS_TYPE_PT_GENERATE_BE
8692 | OPTS_TYPE_PT_ADD80
8693 | OPTS_TYPE_PT_ADDBITS15;
8694 kern_type = KERN_TYPE_SHA11;
8695 dgst_size = DGST_SIZE_4_5;
8696 parse_func = sha1_parse_hash;
8697 sort_by_digest = sort_by_digest_4_5;
8698 opti_type = OPTI_TYPE_ZERO_BYTE
8699 | OPTI_TYPE_PRECOMPUTE_INIT
8700 | OPTI_TYPE_PRECOMPUTE_MERKLE
8701 | OPTI_TYPE_EARLY_SKIP
8702 | OPTI_TYPE_NOT_SALTED;
8703 dgst_pos0 = 3;
8704 dgst_pos1 = 4;
8705 dgst_pos2 = 2;
8706 dgst_pos3 = 1;
8707 break;
8708
8709 case 4700: hash_type = HASH_TYPE_SHA1;
8710 salt_type = SALT_TYPE_NONE;
8711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8712 opts_type = OPTS_TYPE_PT_GENERATE_LE
8713 | OPTS_TYPE_PT_ADD80
8714 | OPTS_TYPE_PT_ADDBITS14;
8715 kern_type = KERN_TYPE_SHA1_MD5;
8716 dgst_size = DGST_SIZE_4_5;
8717 parse_func = sha1_parse_hash;
8718 sort_by_digest = sort_by_digest_4_5;
8719 opti_type = OPTI_TYPE_ZERO_BYTE
8720 | OPTI_TYPE_PRECOMPUTE_INIT
8721 | OPTI_TYPE_PRECOMPUTE_MERKLE
8722 | OPTI_TYPE_EARLY_SKIP
8723 | OPTI_TYPE_NOT_ITERATED
8724 | OPTI_TYPE_NOT_SALTED
8725 | OPTI_TYPE_RAW_HASH;
8726 dgst_pos0 = 3;
8727 dgst_pos1 = 4;
8728 dgst_pos2 = 2;
8729 dgst_pos3 = 1;
8730 break;
8731
8732 case 4800: hash_type = HASH_TYPE_MD5;
8733 salt_type = SALT_TYPE_EMBEDDED;
8734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8735 opts_type = OPTS_TYPE_PT_GENERATE_LE
8736 | OPTS_TYPE_PT_ADDBITS14;
8737 kern_type = KERN_TYPE_MD5_CHAP;
8738 dgst_size = DGST_SIZE_4_4;
8739 parse_func = chap_parse_hash;
8740 sort_by_digest = sort_by_digest_4_4;
8741 opti_type = OPTI_TYPE_ZERO_BYTE
8742 | OPTI_TYPE_PRECOMPUTE_INIT
8743 | OPTI_TYPE_PRECOMPUTE_MERKLE
8744 | OPTI_TYPE_MEET_IN_MIDDLE
8745 | OPTI_TYPE_EARLY_SKIP
8746 | OPTI_TYPE_NOT_ITERATED
8747 | OPTI_TYPE_RAW_HASH;
8748 dgst_pos0 = 0;
8749 dgst_pos1 = 3;
8750 dgst_pos2 = 2;
8751 dgst_pos3 = 1;
8752 break;
8753
8754 case 4900: hash_type = HASH_TYPE_SHA1;
8755 salt_type = SALT_TYPE_INTERN;
8756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8757 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8758 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8759 dgst_size = DGST_SIZE_4_5;
8760 parse_func = sha1s_parse_hash;
8761 sort_by_digest = sort_by_digest_4_5;
8762 opti_type = OPTI_TYPE_ZERO_BYTE
8763 | OPTI_TYPE_PRECOMPUTE_INIT
8764 | OPTI_TYPE_PRECOMPUTE_MERKLE
8765 | OPTI_TYPE_EARLY_SKIP;
8766 dgst_pos0 = 3;
8767 dgst_pos1 = 4;
8768 dgst_pos2 = 2;
8769 dgst_pos3 = 1;
8770 break;
8771
8772 case 5000: hash_type = HASH_TYPE_KECCAK;
8773 salt_type = SALT_TYPE_EMBEDDED;
8774 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8775 opts_type = OPTS_TYPE_PT_GENERATE_LE
8776 | OPTS_TYPE_PT_ADD01;
8777 kern_type = KERN_TYPE_KECCAK;
8778 dgst_size = DGST_SIZE_8_25;
8779 parse_func = keccak_parse_hash;
8780 sort_by_digest = sort_by_digest_8_25;
8781 opti_type = OPTI_TYPE_ZERO_BYTE
8782 | OPTI_TYPE_USES_BITS_64
8783 | OPTI_TYPE_RAW_HASH;
8784 dgst_pos0 = 2;
8785 dgst_pos1 = 3;
8786 dgst_pos2 = 4;
8787 dgst_pos3 = 5;
8788 break;
8789
8790 case 5100: hash_type = HASH_TYPE_MD5H;
8791 salt_type = SALT_TYPE_NONE;
8792 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8793 opts_type = OPTS_TYPE_PT_GENERATE_LE
8794 | OPTS_TYPE_PT_ADD80
8795 | OPTS_TYPE_PT_ADDBITS14;
8796 kern_type = KERN_TYPE_MD5H;
8797 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8798 parse_func = md5half_parse_hash;
8799 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8800 opti_type = OPTI_TYPE_ZERO_BYTE
8801 | OPTI_TYPE_RAW_HASH;
8802 dgst_pos0 = 0;
8803 dgst_pos1 = 1;
8804 dgst_pos2 = 2;
8805 dgst_pos3 = 3;
8806 break;
8807
8808 case 5200: hash_type = HASH_TYPE_SHA256;
8809 salt_type = SALT_TYPE_EMBEDDED;
8810 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8811 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8812 kern_type = KERN_TYPE_PSAFE3;
8813 dgst_size = DGST_SIZE_4_8;
8814 parse_func = psafe3_parse_hash;
8815 sort_by_digest = sort_by_digest_4_8;
8816 opti_type = OPTI_TYPE_ZERO_BYTE;
8817 dgst_pos0 = 0;
8818 dgst_pos1 = 1;
8819 dgst_pos2 = 2;
8820 dgst_pos3 = 3;
8821 break;
8822
8823 case 5300: hash_type = HASH_TYPE_MD5;
8824 salt_type = SALT_TYPE_EMBEDDED;
8825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8826 opts_type = OPTS_TYPE_PT_GENERATE_LE
8827 | OPTS_TYPE_ST_ADD80;
8828 kern_type = KERN_TYPE_IKEPSK_MD5;
8829 dgst_size = DGST_SIZE_4_4;
8830 parse_func = ikepsk_md5_parse_hash;
8831 sort_by_digest = sort_by_digest_4_4;
8832 opti_type = OPTI_TYPE_ZERO_BYTE;
8833 dgst_pos0 = 0;
8834 dgst_pos1 = 3;
8835 dgst_pos2 = 2;
8836 dgst_pos3 = 1;
8837 break;
8838
8839 case 5400: hash_type = HASH_TYPE_SHA1;
8840 salt_type = SALT_TYPE_EMBEDDED;
8841 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8842 opts_type = OPTS_TYPE_PT_GENERATE_BE
8843 | OPTS_TYPE_ST_ADD80;
8844 kern_type = KERN_TYPE_IKEPSK_SHA1;
8845 dgst_size = DGST_SIZE_4_5;
8846 parse_func = ikepsk_sha1_parse_hash;
8847 sort_by_digest = sort_by_digest_4_5;
8848 opti_type = OPTI_TYPE_ZERO_BYTE;
8849 dgst_pos0 = 3;
8850 dgst_pos1 = 4;
8851 dgst_pos2 = 2;
8852 dgst_pos3 = 1;
8853 break;
8854
8855 case 5500: hash_type = HASH_TYPE_NETNTLM;
8856 salt_type = SALT_TYPE_EMBEDDED;
8857 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8858 opts_type = OPTS_TYPE_PT_GENERATE_LE
8859 | OPTS_TYPE_PT_ADD80
8860 | OPTS_TYPE_PT_ADDBITS14
8861 | OPTS_TYPE_PT_UNICODE
8862 | OPTS_TYPE_ST_HEX;
8863 kern_type = KERN_TYPE_NETNTLMv1;
8864 dgst_size = DGST_SIZE_4_4;
8865 parse_func = netntlmv1_parse_hash;
8866 sort_by_digest = sort_by_digest_4_4;
8867 opti_type = OPTI_TYPE_ZERO_BYTE
8868 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8869 dgst_pos0 = 0;
8870 dgst_pos1 = 1;
8871 dgst_pos2 = 2;
8872 dgst_pos3 = 3;
8873 break;
8874
8875 case 5600: hash_type = HASH_TYPE_MD5;
8876 salt_type = SALT_TYPE_EMBEDDED;
8877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8878 opts_type = OPTS_TYPE_PT_GENERATE_LE
8879 | OPTS_TYPE_PT_ADD80
8880 | OPTS_TYPE_PT_ADDBITS14
8881 | OPTS_TYPE_PT_UNICODE;
8882 kern_type = KERN_TYPE_NETNTLMv2;
8883 dgst_size = DGST_SIZE_4_4;
8884 parse_func = netntlmv2_parse_hash;
8885 sort_by_digest = sort_by_digest_4_4;
8886 opti_type = OPTI_TYPE_ZERO_BYTE;
8887 dgst_pos0 = 0;
8888 dgst_pos1 = 3;
8889 dgst_pos2 = 2;
8890 dgst_pos3 = 1;
8891 break;
8892
8893 case 5700: hash_type = HASH_TYPE_SHA256;
8894 salt_type = SALT_TYPE_NONE;
8895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8896 opts_type = OPTS_TYPE_PT_GENERATE_BE
8897 | OPTS_TYPE_PT_ADD80
8898 | OPTS_TYPE_PT_ADDBITS15;
8899 kern_type = KERN_TYPE_SHA256;
8900 dgst_size = DGST_SIZE_4_8;
8901 parse_func = cisco4_parse_hash;
8902 sort_by_digest = sort_by_digest_4_8;
8903 opti_type = OPTI_TYPE_ZERO_BYTE
8904 | OPTI_TYPE_PRECOMPUTE_INIT
8905 | OPTI_TYPE_PRECOMPUTE_MERKLE
8906 | OPTI_TYPE_EARLY_SKIP
8907 | OPTI_TYPE_NOT_ITERATED
8908 | OPTI_TYPE_NOT_SALTED
8909 | OPTI_TYPE_RAW_HASH;
8910 dgst_pos0 = 3;
8911 dgst_pos1 = 7;
8912 dgst_pos2 = 2;
8913 dgst_pos3 = 6;
8914 break;
8915
8916 case 5800: hash_type = HASH_TYPE_SHA1;
8917 salt_type = SALT_TYPE_INTERN;
8918 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8919 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8920 | OPTS_TYPE_ST_ADD80;
8921 kern_type = KERN_TYPE_ANDROIDPIN;
8922 dgst_size = DGST_SIZE_4_5;
8923 parse_func = androidpin_parse_hash;
8924 sort_by_digest = sort_by_digest_4_5;
8925 opti_type = OPTI_TYPE_ZERO_BYTE;
8926 dgst_pos0 = 0;
8927 dgst_pos1 = 1;
8928 dgst_pos2 = 2;
8929 dgst_pos3 = 3;
8930 break;
8931
8932 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8933 salt_type = SALT_TYPE_NONE;
8934 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8935 opts_type = OPTS_TYPE_PT_GENERATE_LE
8936 | OPTS_TYPE_PT_ADD80;
8937 kern_type = KERN_TYPE_RIPEMD160;
8938 dgst_size = DGST_SIZE_4_5;
8939 parse_func = ripemd160_parse_hash;
8940 sort_by_digest = sort_by_digest_4_5;
8941 opti_type = OPTI_TYPE_ZERO_BYTE;
8942 dgst_pos0 = 0;
8943 dgst_pos1 = 1;
8944 dgst_pos2 = 2;
8945 dgst_pos3 = 3;
8946 break;
8947
8948 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8949 salt_type = SALT_TYPE_NONE;
8950 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8951 opts_type = OPTS_TYPE_PT_GENERATE_BE
8952 | OPTS_TYPE_PT_ADD80;
8953 kern_type = KERN_TYPE_WHIRLPOOL;
8954 dgst_size = DGST_SIZE_4_16;
8955 parse_func = whirlpool_parse_hash;
8956 sort_by_digest = sort_by_digest_4_16;
8957 opti_type = OPTI_TYPE_ZERO_BYTE;
8958 dgst_pos0 = 0;
8959 dgst_pos1 = 1;
8960 dgst_pos2 = 2;
8961 dgst_pos3 = 3;
8962 break;
8963
8964 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8965 salt_type = SALT_TYPE_EMBEDDED;
8966 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8967 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8968 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8969 dgst_size = DGST_SIZE_4_5;
8970 parse_func = truecrypt_parse_hash_2k;
8971 sort_by_digest = sort_by_digest_4_5;
8972 opti_type = OPTI_TYPE_ZERO_BYTE;
8973 dgst_pos0 = 0;
8974 dgst_pos1 = 1;
8975 dgst_pos2 = 2;
8976 dgst_pos3 = 3;
8977 break;
8978
8979 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8980 salt_type = SALT_TYPE_EMBEDDED;
8981 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8982 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8983 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8984 dgst_size = DGST_SIZE_4_5;
8985 parse_func = truecrypt_parse_hash_2k;
8986 sort_by_digest = sort_by_digest_4_5;
8987 opti_type = OPTI_TYPE_ZERO_BYTE;
8988 dgst_pos0 = 0;
8989 dgst_pos1 = 1;
8990 dgst_pos2 = 2;
8991 dgst_pos3 = 3;
8992 break;
8993
8994 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8995 salt_type = SALT_TYPE_EMBEDDED;
8996 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8997 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8998 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8999 dgst_size = DGST_SIZE_4_5;
9000 parse_func = truecrypt_parse_hash_2k;
9001 sort_by_digest = sort_by_digest_4_5;
9002 opti_type = OPTI_TYPE_ZERO_BYTE;
9003 dgst_pos0 = 0;
9004 dgst_pos1 = 1;
9005 dgst_pos2 = 2;
9006 dgst_pos3 = 3;
9007 break;
9008
9009 case 6221: hash_type = HASH_TYPE_SHA512;
9010 salt_type = SALT_TYPE_EMBEDDED;
9011 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9012 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9013 kern_type = KERN_TYPE_TCSHA512_XTS512;
9014 dgst_size = DGST_SIZE_8_8;
9015 parse_func = truecrypt_parse_hash_1k;
9016 sort_by_digest = sort_by_digest_8_8;
9017 opti_type = OPTI_TYPE_ZERO_BYTE
9018 | OPTI_TYPE_USES_BITS_64;
9019 dgst_pos0 = 0;
9020 dgst_pos1 = 1;
9021 dgst_pos2 = 2;
9022 dgst_pos3 = 3;
9023 break;
9024
9025 case 6222: hash_type = HASH_TYPE_SHA512;
9026 salt_type = SALT_TYPE_EMBEDDED;
9027 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9028 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9029 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9030 dgst_size = DGST_SIZE_8_8;
9031 parse_func = truecrypt_parse_hash_1k;
9032 sort_by_digest = sort_by_digest_8_8;
9033 opti_type = OPTI_TYPE_ZERO_BYTE
9034 | OPTI_TYPE_USES_BITS_64;
9035 dgst_pos0 = 0;
9036 dgst_pos1 = 1;
9037 dgst_pos2 = 2;
9038 dgst_pos3 = 3;
9039 break;
9040
9041 case 6223: hash_type = HASH_TYPE_SHA512;
9042 salt_type = SALT_TYPE_EMBEDDED;
9043 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9044 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9045 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9046 dgst_size = DGST_SIZE_8_8;
9047 parse_func = truecrypt_parse_hash_1k;
9048 sort_by_digest = sort_by_digest_8_8;
9049 opti_type = OPTI_TYPE_ZERO_BYTE
9050 | OPTI_TYPE_USES_BITS_64;
9051 dgst_pos0 = 0;
9052 dgst_pos1 = 1;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 3;
9055 break;
9056
9057 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9061 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9062 dgst_size = DGST_SIZE_4_8;
9063 parse_func = truecrypt_parse_hash_1k;
9064 sort_by_digest = sort_by_digest_4_8;
9065 opti_type = OPTI_TYPE_ZERO_BYTE;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 1;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 3;
9070 break;
9071
9072 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9073 salt_type = SALT_TYPE_EMBEDDED;
9074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9076 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9077 dgst_size = DGST_SIZE_4_8;
9078 parse_func = truecrypt_parse_hash_1k;
9079 sort_by_digest = sort_by_digest_4_8;
9080 opti_type = OPTI_TYPE_ZERO_BYTE;
9081 dgst_pos0 = 0;
9082 dgst_pos1 = 1;
9083 dgst_pos2 = 2;
9084 dgst_pos3 = 3;
9085 break;
9086
9087 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9088 salt_type = SALT_TYPE_EMBEDDED;
9089 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9090 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9091 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9092 dgst_size = DGST_SIZE_4_8;
9093 parse_func = truecrypt_parse_hash_1k;
9094 sort_by_digest = sort_by_digest_4_8;
9095 opti_type = OPTI_TYPE_ZERO_BYTE;
9096 dgst_pos0 = 0;
9097 dgst_pos1 = 1;
9098 dgst_pos2 = 2;
9099 dgst_pos3 = 3;
9100 break;
9101
9102 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9103 salt_type = SALT_TYPE_EMBEDDED;
9104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9105 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9106 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9107 dgst_size = DGST_SIZE_4_5;
9108 parse_func = truecrypt_parse_hash_1k;
9109 sort_by_digest = sort_by_digest_4_5;
9110 opti_type = OPTI_TYPE_ZERO_BYTE;
9111 dgst_pos0 = 0;
9112 dgst_pos1 = 1;
9113 dgst_pos2 = 2;
9114 dgst_pos3 = 3;
9115 break;
9116
9117 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9118 salt_type = SALT_TYPE_EMBEDDED;
9119 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9120 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9121 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9122 dgst_size = DGST_SIZE_4_5;
9123 parse_func = truecrypt_parse_hash_1k;
9124 sort_by_digest = sort_by_digest_4_5;
9125 opti_type = OPTI_TYPE_ZERO_BYTE;
9126 dgst_pos0 = 0;
9127 dgst_pos1 = 1;
9128 dgst_pos2 = 2;
9129 dgst_pos3 = 3;
9130 break;
9131
9132 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9133 salt_type = SALT_TYPE_EMBEDDED;
9134 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9135 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9136 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9137 dgst_size = DGST_SIZE_4_5;
9138 parse_func = truecrypt_parse_hash_1k;
9139 sort_by_digest = sort_by_digest_4_5;
9140 opti_type = OPTI_TYPE_ZERO_BYTE;
9141 dgst_pos0 = 0;
9142 dgst_pos1 = 1;
9143 dgst_pos2 = 2;
9144 dgst_pos3 = 3;
9145 break;
9146
9147 case 6300: hash_type = HASH_TYPE_MD5;
9148 salt_type = SALT_TYPE_EMBEDDED;
9149 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9150 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9151 kern_type = KERN_TYPE_MD5AIX;
9152 dgst_size = DGST_SIZE_4_4;
9153 parse_func = md5aix_parse_hash;
9154 sort_by_digest = sort_by_digest_4_4;
9155 opti_type = OPTI_TYPE_ZERO_BYTE;
9156 dgst_pos0 = 0;
9157 dgst_pos1 = 1;
9158 dgst_pos2 = 2;
9159 dgst_pos3 = 3;
9160 break;
9161
9162 case 6400: hash_type = HASH_TYPE_SHA256;
9163 salt_type = SALT_TYPE_EMBEDDED;
9164 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9165 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9166 kern_type = KERN_TYPE_SHA256AIX;
9167 dgst_size = DGST_SIZE_4_8;
9168 parse_func = sha256aix_parse_hash;
9169 sort_by_digest = sort_by_digest_4_8;
9170 opti_type = OPTI_TYPE_ZERO_BYTE;
9171 dgst_pos0 = 0;
9172 dgst_pos1 = 1;
9173 dgst_pos2 = 2;
9174 dgst_pos3 = 3;
9175 break;
9176
9177 case 6500: hash_type = HASH_TYPE_SHA512;
9178 salt_type = SALT_TYPE_EMBEDDED;
9179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9180 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9181 kern_type = KERN_TYPE_SHA512AIX;
9182 dgst_size = DGST_SIZE_8_8;
9183 parse_func = sha512aix_parse_hash;
9184 sort_by_digest = sort_by_digest_8_8;
9185 opti_type = OPTI_TYPE_ZERO_BYTE
9186 | OPTI_TYPE_USES_BITS_64;
9187 dgst_pos0 = 0;
9188 dgst_pos1 = 1;
9189 dgst_pos2 = 2;
9190 dgst_pos3 = 3;
9191 break;
9192
9193 case 6600: hash_type = HASH_TYPE_AES;
9194 salt_type = SALT_TYPE_EMBEDDED;
9195 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9196 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9197 kern_type = KERN_TYPE_AGILEKEY;
9198 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9199 parse_func = agilekey_parse_hash;
9200 sort_by_digest = sort_by_digest_4_5;
9201 opti_type = OPTI_TYPE_ZERO_BYTE;
9202 dgst_pos0 = 0;
9203 dgst_pos1 = 1;
9204 dgst_pos2 = 2;
9205 dgst_pos3 = 3;
9206 break;
9207
9208 case 6700: hash_type = HASH_TYPE_SHA1;
9209 salt_type = SALT_TYPE_EMBEDDED;
9210 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9211 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9212 kern_type = KERN_TYPE_SHA1AIX;
9213 dgst_size = DGST_SIZE_4_5;
9214 parse_func = sha1aix_parse_hash;
9215 sort_by_digest = sort_by_digest_4_5;
9216 opti_type = OPTI_TYPE_ZERO_BYTE;
9217 dgst_pos0 = 0;
9218 dgst_pos1 = 1;
9219 dgst_pos2 = 2;
9220 dgst_pos3 = 3;
9221 break;
9222
9223 case 6800: hash_type = HASH_TYPE_AES;
9224 salt_type = SALT_TYPE_EMBEDDED;
9225 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9226 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9227 kern_type = KERN_TYPE_LASTPASS;
9228 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9229 parse_func = lastpass_parse_hash;
9230 sort_by_digest = sort_by_digest_4_8;
9231 opti_type = OPTI_TYPE_ZERO_BYTE;
9232 dgst_pos0 = 0;
9233 dgst_pos1 = 1;
9234 dgst_pos2 = 2;
9235 dgst_pos3 = 3;
9236 break;
9237
9238 case 6900: hash_type = HASH_TYPE_GOST;
9239 salt_type = SALT_TYPE_NONE;
9240 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9241 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9242 kern_type = KERN_TYPE_GOST;
9243 dgst_size = DGST_SIZE_4_8;
9244 parse_func = gost_parse_hash;
9245 sort_by_digest = sort_by_digest_4_8;
9246 opti_type = OPTI_TYPE_ZERO_BYTE;
9247 dgst_pos0 = 0;
9248 dgst_pos1 = 1;
9249 dgst_pos2 = 2;
9250 dgst_pos3 = 3;
9251 break;
9252
9253 case 7100: hash_type = HASH_TYPE_SHA512;
9254 salt_type = SALT_TYPE_EMBEDDED;
9255 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9256 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9257 kern_type = KERN_TYPE_PBKDF2_SHA512;
9258 dgst_size = DGST_SIZE_8_16;
9259 parse_func = sha512osx_parse_hash;
9260 sort_by_digest = sort_by_digest_8_16;
9261 opti_type = OPTI_TYPE_ZERO_BYTE
9262 | OPTI_TYPE_USES_BITS_64
9263 | OPTI_TYPE_SLOW_HASH_SIMD;
9264 dgst_pos0 = 0;
9265 dgst_pos1 = 1;
9266 dgst_pos2 = 2;
9267 dgst_pos3 = 3;
9268 break;
9269
9270 case 7200: hash_type = HASH_TYPE_SHA512;
9271 salt_type = SALT_TYPE_EMBEDDED;
9272 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9273 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9274 kern_type = KERN_TYPE_PBKDF2_SHA512;
9275 dgst_size = DGST_SIZE_8_16;
9276 parse_func = sha512grub_parse_hash;
9277 sort_by_digest = sort_by_digest_8_16;
9278 opti_type = OPTI_TYPE_ZERO_BYTE
9279 | OPTI_TYPE_USES_BITS_64
9280 | OPTI_TYPE_SLOW_HASH_SIMD;
9281 dgst_pos0 = 0;
9282 dgst_pos1 = 1;
9283 dgst_pos2 = 2;
9284 dgst_pos3 = 3;
9285 break;
9286
9287 case 7300: hash_type = HASH_TYPE_SHA1;
9288 salt_type = SALT_TYPE_EMBEDDED;
9289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9290 opts_type = OPTS_TYPE_PT_GENERATE_BE
9291 | OPTS_TYPE_ST_ADD80
9292 | OPTS_TYPE_ST_ADDBITS15;
9293 kern_type = KERN_TYPE_RAKP;
9294 dgst_size = DGST_SIZE_4_5;
9295 parse_func = rakp_parse_hash;
9296 sort_by_digest = sort_by_digest_4_5;
9297 opti_type = OPTI_TYPE_ZERO_BYTE
9298 | OPTI_TYPE_NOT_ITERATED;
9299 dgst_pos0 = 3;
9300 dgst_pos1 = 4;
9301 dgst_pos2 = 2;
9302 dgst_pos3 = 1;
9303 break;
9304
9305 case 7400: hash_type = HASH_TYPE_SHA256;
9306 salt_type = SALT_TYPE_EMBEDDED;
9307 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9308 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9309 kern_type = KERN_TYPE_SHA256CRYPT;
9310 dgst_size = DGST_SIZE_4_8;
9311 parse_func = sha256crypt_parse_hash;
9312 sort_by_digest = sort_by_digest_4_8;
9313 opti_type = OPTI_TYPE_ZERO_BYTE;
9314 dgst_pos0 = 0;
9315 dgst_pos1 = 1;
9316 dgst_pos2 = 2;
9317 dgst_pos3 = 3;
9318 break;
9319
9320 case 7500: hash_type = HASH_TYPE_KRB5PA;
9321 salt_type = SALT_TYPE_EMBEDDED;
9322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9323 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9324 kern_type = KERN_TYPE_KRB5PA;
9325 dgst_size = DGST_SIZE_4_4;
9326 parse_func = krb5pa_parse_hash;
9327 sort_by_digest = sort_by_digest_4_4;
9328 opti_type = OPTI_TYPE_ZERO_BYTE
9329 | OPTI_TYPE_NOT_ITERATED;
9330 dgst_pos0 = 0;
9331 dgst_pos1 = 1;
9332 dgst_pos2 = 2;
9333 dgst_pos3 = 3;
9334 break;
9335
9336 case 7600: hash_type = HASH_TYPE_SHA1;
9337 salt_type = SALT_TYPE_INTERN;
9338 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9339 opts_type = OPTS_TYPE_PT_GENERATE_BE
9340 | OPTS_TYPE_PT_ADD80
9341 | OPTS_TYPE_PT_ADDBITS15;
9342 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9343 dgst_size = DGST_SIZE_4_5;
9344 parse_func = redmine_parse_hash;
9345 sort_by_digest = sort_by_digest_4_5;
9346 opti_type = OPTI_TYPE_ZERO_BYTE
9347 | OPTI_TYPE_PRECOMPUTE_INIT
9348 | OPTI_TYPE_EARLY_SKIP
9349 | OPTI_TYPE_NOT_ITERATED
9350 | OPTI_TYPE_PREPENDED_SALT;
9351 dgst_pos0 = 3;
9352 dgst_pos1 = 4;
9353 dgst_pos2 = 2;
9354 dgst_pos3 = 1;
9355 break;
9356
9357 case 7700: hash_type = HASH_TYPE_SAPB;
9358 salt_type = SALT_TYPE_EMBEDDED;
9359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9360 opts_type = OPTS_TYPE_PT_GENERATE_LE
9361 | OPTS_TYPE_PT_UPPER
9362 | OPTS_TYPE_ST_UPPER;
9363 kern_type = KERN_TYPE_SAPB;
9364 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9365 parse_func = sapb_parse_hash;
9366 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9367 opti_type = OPTI_TYPE_ZERO_BYTE
9368 | OPTI_TYPE_PRECOMPUTE_INIT
9369 | OPTI_TYPE_NOT_ITERATED;
9370 dgst_pos0 = 0;
9371 dgst_pos1 = 1;
9372 dgst_pos2 = 2;
9373 dgst_pos3 = 3;
9374 break;
9375
9376 case 7800: hash_type = HASH_TYPE_SAPG;
9377 salt_type = SALT_TYPE_EMBEDDED;
9378 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9379 opts_type = OPTS_TYPE_PT_GENERATE_BE
9380 | OPTS_TYPE_ST_ADD80
9381 | OPTS_TYPE_ST_UPPER;
9382 kern_type = KERN_TYPE_SAPG;
9383 dgst_size = DGST_SIZE_4_5;
9384 parse_func = sapg_parse_hash;
9385 sort_by_digest = sort_by_digest_4_5;
9386 opti_type = OPTI_TYPE_ZERO_BYTE
9387 | OPTI_TYPE_PRECOMPUTE_INIT
9388 | OPTI_TYPE_NOT_ITERATED;
9389 dgst_pos0 = 3;
9390 dgst_pos1 = 4;
9391 dgst_pos2 = 2;
9392 dgst_pos3 = 1;
9393 break;
9394
9395 case 7900: hash_type = HASH_TYPE_SHA512;
9396 salt_type = SALT_TYPE_EMBEDDED;
9397 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9398 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9399 kern_type = KERN_TYPE_DRUPAL7;
9400 dgst_size = DGST_SIZE_8_8;
9401 parse_func = drupal7_parse_hash;
9402 sort_by_digest = sort_by_digest_8_8;
9403 opti_type = OPTI_TYPE_ZERO_BYTE
9404 | OPTI_TYPE_USES_BITS_64;
9405 dgst_pos0 = 0;
9406 dgst_pos1 = 1;
9407 dgst_pos2 = 2;
9408 dgst_pos3 = 3;
9409 break;
9410
9411 case 8000: hash_type = HASH_TYPE_SHA256;
9412 salt_type = SALT_TYPE_EMBEDDED;
9413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9414 opts_type = OPTS_TYPE_PT_GENERATE_BE
9415 | OPTS_TYPE_PT_UNICODE
9416 | OPTS_TYPE_ST_ADD80
9417 | OPTS_TYPE_ST_HEX;
9418 kern_type = KERN_TYPE_SYBASEASE;
9419 dgst_size = DGST_SIZE_4_8;
9420 parse_func = sybasease_parse_hash;
9421 sort_by_digest = sort_by_digest_4_8;
9422 opti_type = OPTI_TYPE_ZERO_BYTE
9423 | OPTI_TYPE_PRECOMPUTE_INIT
9424 | OPTI_TYPE_EARLY_SKIP
9425 | OPTI_TYPE_NOT_ITERATED
9426 | OPTI_TYPE_RAW_HASH;
9427 dgst_pos0 = 3;
9428 dgst_pos1 = 7;
9429 dgst_pos2 = 2;
9430 dgst_pos3 = 6;
9431 break;
9432
9433 case 8100: hash_type = HASH_TYPE_SHA1;
9434 salt_type = SALT_TYPE_EMBEDDED;
9435 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9436 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9437 kern_type = KERN_TYPE_NETSCALER;
9438 dgst_size = DGST_SIZE_4_5;
9439 parse_func = netscaler_parse_hash;
9440 sort_by_digest = sort_by_digest_4_5;
9441 opti_type = OPTI_TYPE_ZERO_BYTE
9442 | OPTI_TYPE_PRECOMPUTE_INIT
9443 | OPTI_TYPE_PRECOMPUTE_MERKLE
9444 | OPTI_TYPE_EARLY_SKIP
9445 | OPTI_TYPE_NOT_ITERATED
9446 | OPTI_TYPE_PREPENDED_SALT
9447 | OPTI_TYPE_RAW_HASH;
9448 dgst_pos0 = 3;
9449 dgst_pos1 = 4;
9450 dgst_pos2 = 2;
9451 dgst_pos3 = 1;
9452 break;
9453
9454 case 8200: hash_type = HASH_TYPE_SHA256;
9455 salt_type = SALT_TYPE_EMBEDDED;
9456 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9457 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9458 kern_type = KERN_TYPE_CLOUDKEY;
9459 dgst_size = DGST_SIZE_4_8;
9460 parse_func = cloudkey_parse_hash;
9461 sort_by_digest = sort_by_digest_4_8;
9462 opti_type = OPTI_TYPE_ZERO_BYTE;
9463 dgst_pos0 = 0;
9464 dgst_pos1 = 1;
9465 dgst_pos2 = 2;
9466 dgst_pos3 = 3;
9467 break;
9468
9469 case 8300: hash_type = HASH_TYPE_SHA1;
9470 salt_type = SALT_TYPE_EMBEDDED;
9471 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9472 opts_type = OPTS_TYPE_PT_GENERATE_BE
9473 | OPTS_TYPE_ST_HEX
9474 | OPTS_TYPE_ST_ADD80;
9475 kern_type = KERN_TYPE_NSEC3;
9476 dgst_size = DGST_SIZE_4_5;
9477 parse_func = nsec3_parse_hash;
9478 sort_by_digest = sort_by_digest_4_5;
9479 opti_type = OPTI_TYPE_ZERO_BYTE;
9480 dgst_pos0 = 3;
9481 dgst_pos1 = 4;
9482 dgst_pos2 = 2;
9483 dgst_pos3 = 1;
9484 break;
9485
9486 case 8400: hash_type = HASH_TYPE_SHA1;
9487 salt_type = SALT_TYPE_INTERN;
9488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9489 opts_type = OPTS_TYPE_PT_GENERATE_BE
9490 | OPTS_TYPE_PT_ADD80
9491 | OPTS_TYPE_PT_ADDBITS15;
9492 kern_type = KERN_TYPE_WBB3;
9493 dgst_size = DGST_SIZE_4_5;
9494 parse_func = wbb3_parse_hash;
9495 sort_by_digest = sort_by_digest_4_5;
9496 opti_type = OPTI_TYPE_ZERO_BYTE
9497 | OPTI_TYPE_PRECOMPUTE_INIT
9498 | OPTI_TYPE_NOT_ITERATED;
9499 dgst_pos0 = 3;
9500 dgst_pos1 = 4;
9501 dgst_pos2 = 2;
9502 dgst_pos3 = 1;
9503 break;
9504
9505 case 8500: hash_type = HASH_TYPE_DESRACF;
9506 salt_type = SALT_TYPE_EMBEDDED;
9507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9508 opts_type = OPTS_TYPE_PT_GENERATE_LE
9509 | OPTS_TYPE_ST_UPPER;
9510 kern_type = KERN_TYPE_RACF;
9511 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9512 parse_func = racf_parse_hash;
9513 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9514 opti_type = OPTI_TYPE_ZERO_BYTE
9515 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9516 dgst_pos0 = 0;
9517 dgst_pos1 = 1;
9518 dgst_pos2 = 2;
9519 dgst_pos3 = 3;
9520 break;
9521
9522 case 8600: hash_type = HASH_TYPE_LOTUS5;
9523 salt_type = SALT_TYPE_NONE;
9524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9525 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9526 kern_type = KERN_TYPE_LOTUS5;
9527 dgst_size = DGST_SIZE_4_4;
9528 parse_func = lotus5_parse_hash;
9529 sort_by_digest = sort_by_digest_4_4;
9530 opti_type = OPTI_TYPE_EARLY_SKIP
9531 | OPTI_TYPE_NOT_ITERATED
9532 | OPTI_TYPE_NOT_SALTED
9533 | OPTI_TYPE_RAW_HASH;
9534 dgst_pos0 = 0;
9535 dgst_pos1 = 1;
9536 dgst_pos2 = 2;
9537 dgst_pos3 = 3;
9538 break;
9539
9540 case 8700: hash_type = HASH_TYPE_LOTUS6;
9541 salt_type = SALT_TYPE_EMBEDDED;
9542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9543 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9544 kern_type = KERN_TYPE_LOTUS6;
9545 dgst_size = DGST_SIZE_4_4;
9546 parse_func = lotus6_parse_hash;
9547 sort_by_digest = sort_by_digest_4_4;
9548 opti_type = OPTI_TYPE_EARLY_SKIP
9549 | OPTI_TYPE_NOT_ITERATED
9550 | OPTI_TYPE_RAW_HASH;
9551 dgst_pos0 = 0;
9552 dgst_pos1 = 1;
9553 dgst_pos2 = 2;
9554 dgst_pos3 = 3;
9555 break;
9556
9557 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9558 salt_type = SALT_TYPE_EMBEDDED;
9559 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9560 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9561 kern_type = KERN_TYPE_ANDROIDFDE;
9562 dgst_size = DGST_SIZE_4_4;
9563 parse_func = androidfde_parse_hash;
9564 sort_by_digest = sort_by_digest_4_4;
9565 opti_type = OPTI_TYPE_ZERO_BYTE;
9566 dgst_pos0 = 0;
9567 dgst_pos1 = 1;
9568 dgst_pos2 = 2;
9569 dgst_pos3 = 3;
9570 break;
9571
9572 case 8900: hash_type = HASH_TYPE_SCRYPT;
9573 salt_type = SALT_TYPE_EMBEDDED;
9574 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9575 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9576 kern_type = KERN_TYPE_SCRYPT;
9577 dgst_size = DGST_SIZE_4_8;
9578 parse_func = scrypt_parse_hash;
9579 sort_by_digest = sort_by_digest_4_8;
9580 opti_type = OPTI_TYPE_ZERO_BYTE;
9581 dgst_pos0 = 0;
9582 dgst_pos1 = 1;
9583 dgst_pos2 = 2;
9584 dgst_pos3 = 3;
9585 break;
9586
9587 case 9000: hash_type = HASH_TYPE_SHA1;
9588 salt_type = SALT_TYPE_EMBEDDED;
9589 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9590 opts_type = OPTS_TYPE_PT_GENERATE_LE
9591 | OPTS_TYPE_ST_GENERATE_LE;
9592 kern_type = KERN_TYPE_PSAFE2;
9593 dgst_size = DGST_SIZE_4_5;
9594 parse_func = psafe2_parse_hash;
9595 sort_by_digest = sort_by_digest_4_5;
9596 opti_type = OPTI_TYPE_ZERO_BYTE;
9597 dgst_pos0 = 0;
9598 dgst_pos1 = 1;
9599 dgst_pos2 = 2;
9600 dgst_pos3 = 3;
9601 break;
9602
9603 case 9100: hash_type = HASH_TYPE_LOTUS8;
9604 salt_type = SALT_TYPE_EMBEDDED;
9605 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9606 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9607 kern_type = KERN_TYPE_LOTUS8;
9608 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9609 parse_func = lotus8_parse_hash;
9610 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9611 opti_type = OPTI_TYPE_ZERO_BYTE;
9612 dgst_pos0 = 0;
9613 dgst_pos1 = 1;
9614 dgst_pos2 = 2;
9615 dgst_pos3 = 3;
9616 break;
9617
9618 case 9200: hash_type = HASH_TYPE_SHA256;
9619 salt_type = SALT_TYPE_EMBEDDED;
9620 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9621 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9622 kern_type = KERN_TYPE_PBKDF2_SHA256;
9623 dgst_size = DGST_SIZE_4_32;
9624 parse_func = cisco8_parse_hash;
9625 sort_by_digest = sort_by_digest_4_32;
9626 opti_type = OPTI_TYPE_ZERO_BYTE
9627 | OPTI_TYPE_SLOW_HASH_SIMD;
9628 dgst_pos0 = 0;
9629 dgst_pos1 = 1;
9630 dgst_pos2 = 2;
9631 dgst_pos3 = 3;
9632 break;
9633
9634 case 9300: hash_type = HASH_TYPE_SCRYPT;
9635 salt_type = SALT_TYPE_EMBEDDED;
9636 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9637 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9638 kern_type = KERN_TYPE_SCRYPT;
9639 dgst_size = DGST_SIZE_4_8;
9640 parse_func = cisco9_parse_hash;
9641 sort_by_digest = sort_by_digest_4_8;
9642 opti_type = OPTI_TYPE_ZERO_BYTE;
9643 dgst_pos0 = 0;
9644 dgst_pos1 = 1;
9645 dgst_pos2 = 2;
9646 dgst_pos3 = 3;
9647 break;
9648
9649 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9650 salt_type = SALT_TYPE_EMBEDDED;
9651 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9652 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9653 kern_type = KERN_TYPE_OFFICE2007;
9654 dgst_size = DGST_SIZE_4_4;
9655 parse_func = office2007_parse_hash;
9656 sort_by_digest = sort_by_digest_4_4;
9657 opti_type = OPTI_TYPE_ZERO_BYTE;
9658 dgst_pos0 = 0;
9659 dgst_pos1 = 1;
9660 dgst_pos2 = 2;
9661 dgst_pos3 = 3;
9662 break;
9663
9664 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9665 salt_type = SALT_TYPE_EMBEDDED;
9666 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9667 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9668 kern_type = KERN_TYPE_OFFICE2010;
9669 dgst_size = DGST_SIZE_4_4;
9670 parse_func = office2010_parse_hash;
9671 sort_by_digest = sort_by_digest_4_4;
9672 opti_type = OPTI_TYPE_ZERO_BYTE;
9673 dgst_pos0 = 0;
9674 dgst_pos1 = 1;
9675 dgst_pos2 = 2;
9676 dgst_pos3 = 3;
9677 break;
9678
9679 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9680 salt_type = SALT_TYPE_EMBEDDED;
9681 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9682 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9683 kern_type = KERN_TYPE_OFFICE2013;
9684 dgst_size = DGST_SIZE_4_4;
9685 parse_func = office2013_parse_hash;
9686 sort_by_digest = sort_by_digest_4_4;
9687 opti_type = OPTI_TYPE_ZERO_BYTE;
9688 dgst_pos0 = 0;
9689 dgst_pos1 = 1;
9690 dgst_pos2 = 2;
9691 dgst_pos3 = 3;
9692 break;
9693
9694 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9695 salt_type = SALT_TYPE_EMBEDDED;
9696 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9697 opts_type = OPTS_TYPE_PT_GENERATE_LE
9698 | OPTS_TYPE_PT_ADD80
9699 | OPTS_TYPE_PT_UNICODE;
9700 kern_type = KERN_TYPE_OLDOFFICE01;
9701 dgst_size = DGST_SIZE_4_4;
9702 parse_func = oldoffice01_parse_hash;
9703 sort_by_digest = sort_by_digest_4_4;
9704 opti_type = OPTI_TYPE_ZERO_BYTE
9705 | OPTI_TYPE_PRECOMPUTE_INIT
9706 | OPTI_TYPE_NOT_ITERATED;
9707 dgst_pos0 = 0;
9708 dgst_pos1 = 1;
9709 dgst_pos2 = 2;
9710 dgst_pos3 = 3;
9711 break;
9712
9713 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9714 salt_type = SALT_TYPE_EMBEDDED;
9715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9716 opts_type = OPTS_TYPE_PT_GENERATE_LE
9717 | OPTS_TYPE_PT_ADD80;
9718 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9719 dgst_size = DGST_SIZE_4_4;
9720 parse_func = oldoffice01cm1_parse_hash;
9721 sort_by_digest = sort_by_digest_4_4;
9722 opti_type = OPTI_TYPE_ZERO_BYTE
9723 | OPTI_TYPE_PRECOMPUTE_INIT
9724 | OPTI_TYPE_NOT_ITERATED;
9725 dgst_pos0 = 0;
9726 dgst_pos1 = 1;
9727 dgst_pos2 = 2;
9728 dgst_pos3 = 3;
9729 break;
9730
9731 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9732 salt_type = SALT_TYPE_EMBEDDED;
9733 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9734 opts_type = OPTS_TYPE_PT_GENERATE_LE
9735 | OPTS_TYPE_PT_ADD80
9736 | OPTS_TYPE_PT_UNICODE
9737 | OPTS_TYPE_PT_NEVERCRACK;
9738 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9739 dgst_size = DGST_SIZE_4_4;
9740 parse_func = oldoffice01cm2_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 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9752 salt_type = SALT_TYPE_EMBEDDED;
9753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9754 opts_type = OPTS_TYPE_PT_GENERATE_BE
9755 | OPTS_TYPE_PT_ADD80
9756 | OPTS_TYPE_PT_UNICODE;
9757 kern_type = KERN_TYPE_OLDOFFICE34;
9758 dgst_size = DGST_SIZE_4_4;
9759 parse_func = oldoffice34_parse_hash;
9760 sort_by_digest = sort_by_digest_4_4;
9761 opti_type = OPTI_TYPE_ZERO_BYTE
9762 | OPTI_TYPE_PRECOMPUTE_INIT
9763 | OPTI_TYPE_NOT_ITERATED;
9764 dgst_pos0 = 0;
9765 dgst_pos1 = 1;
9766 dgst_pos2 = 2;
9767 dgst_pos3 = 3;
9768 break;
9769
9770 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9771 salt_type = SALT_TYPE_EMBEDDED;
9772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9773 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9774 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9775 dgst_size = DGST_SIZE_4_4;
9776 parse_func = oldoffice34cm1_parse_hash;
9777 sort_by_digest = sort_by_digest_4_4;
9778 opti_type = OPTI_TYPE_ZERO_BYTE
9779 | OPTI_TYPE_PRECOMPUTE_INIT
9780 | OPTI_TYPE_NOT_ITERATED;
9781 dgst_pos0 = 0;
9782 dgst_pos1 = 1;
9783 dgst_pos2 = 2;
9784 dgst_pos3 = 3;
9785 break;
9786
9787 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9788 salt_type = SALT_TYPE_EMBEDDED;
9789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9790 opts_type = OPTS_TYPE_PT_GENERATE_BE
9791 | OPTS_TYPE_PT_ADD80
9792 | OPTS_TYPE_PT_UNICODE
9793 | OPTS_TYPE_PT_NEVERCRACK;
9794 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9795 dgst_size = DGST_SIZE_4_4;
9796 parse_func = oldoffice34cm2_parse_hash;
9797 sort_by_digest = sort_by_digest_4_4;
9798 opti_type = OPTI_TYPE_ZERO_BYTE
9799 | OPTI_TYPE_PRECOMPUTE_INIT
9800 | OPTI_TYPE_NOT_ITERATED;
9801 dgst_pos0 = 0;
9802 dgst_pos1 = 1;
9803 dgst_pos2 = 2;
9804 dgst_pos3 = 3;
9805 break;
9806
9807 case 9900: hash_type = HASH_TYPE_MD5;
9808 salt_type = SALT_TYPE_NONE;
9809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9810 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9811 kern_type = KERN_TYPE_RADMIN2;
9812 dgst_size = DGST_SIZE_4_4;
9813 parse_func = radmin2_parse_hash;
9814 sort_by_digest = sort_by_digest_4_4;
9815 opti_type = OPTI_TYPE_ZERO_BYTE
9816 | OPTI_TYPE_PRECOMPUTE_INIT
9817 | OPTI_TYPE_EARLY_SKIP
9818 | OPTI_TYPE_NOT_ITERATED
9819 | OPTI_TYPE_NOT_SALTED;
9820 dgst_pos0 = 0;
9821 dgst_pos1 = 3;
9822 dgst_pos2 = 2;
9823 dgst_pos3 = 1;
9824 break;
9825
9826 case 10000: hash_type = HASH_TYPE_SHA256;
9827 salt_type = SALT_TYPE_EMBEDDED;
9828 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9829 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9830 kern_type = KERN_TYPE_PBKDF2_SHA256;
9831 dgst_size = DGST_SIZE_4_32;
9832 parse_func = djangopbkdf2_parse_hash;
9833 sort_by_digest = sort_by_digest_4_32;
9834 opti_type = OPTI_TYPE_ZERO_BYTE
9835 | OPTI_TYPE_SLOW_HASH_SIMD;
9836 dgst_pos0 = 0;
9837 dgst_pos1 = 1;
9838 dgst_pos2 = 2;
9839 dgst_pos3 = 3;
9840 break;
9841
9842 case 10100: hash_type = HASH_TYPE_SIPHASH;
9843 salt_type = SALT_TYPE_EMBEDDED;
9844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9845 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9846 kern_type = KERN_TYPE_SIPHASH;
9847 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9848 parse_func = siphash_parse_hash;
9849 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9850 opti_type = OPTI_TYPE_ZERO_BYTE
9851 | OPTI_TYPE_NOT_ITERATED
9852 | OPTI_TYPE_RAW_HASH;
9853 dgst_pos0 = 0;
9854 dgst_pos1 = 1;
9855 dgst_pos2 = 2;
9856 dgst_pos3 = 3;
9857 break;
9858
9859 case 10200: hash_type = HASH_TYPE_MD5;
9860 salt_type = SALT_TYPE_EMBEDDED;
9861 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9862 opts_type = OPTS_TYPE_PT_GENERATE_LE
9863 | OPTS_TYPE_ST_ADD80
9864 | OPTS_TYPE_ST_ADDBITS14;
9865 kern_type = KERN_TYPE_HMACMD5_PW;
9866 dgst_size = DGST_SIZE_4_4;
9867 parse_func = crammd5_parse_hash;
9868 sort_by_digest = sort_by_digest_4_4;
9869 opti_type = OPTI_TYPE_ZERO_BYTE
9870 | OPTI_TYPE_NOT_ITERATED;
9871 dgst_pos0 = 0;
9872 dgst_pos1 = 3;
9873 dgst_pos2 = 2;
9874 dgst_pos3 = 1;
9875 break;
9876
9877 case 10300: hash_type = HASH_TYPE_SHA1;
9878 salt_type = SALT_TYPE_EMBEDDED;
9879 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9880 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9881 kern_type = KERN_TYPE_SAPH_SHA1;
9882 dgst_size = DGST_SIZE_4_5;
9883 parse_func = saph_sha1_parse_hash;
9884 sort_by_digest = sort_by_digest_4_5;
9885 opti_type = OPTI_TYPE_ZERO_BYTE;
9886 dgst_pos0 = 0;
9887 dgst_pos1 = 1;
9888 dgst_pos2 = 2;
9889 dgst_pos3 = 3;
9890 break;
9891
9892 case 10400: hash_type = HASH_TYPE_PDFU16;
9893 salt_type = SALT_TYPE_EMBEDDED;
9894 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9895 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9896 kern_type = KERN_TYPE_PDF11;
9897 dgst_size = DGST_SIZE_4_4;
9898 parse_func = pdf11_parse_hash;
9899 sort_by_digest = sort_by_digest_4_4;
9900 opti_type = OPTI_TYPE_ZERO_BYTE
9901 | OPTI_TYPE_NOT_ITERATED;
9902 dgst_pos0 = 0;
9903 dgst_pos1 = 1;
9904 dgst_pos2 = 2;
9905 dgst_pos3 = 3;
9906 break;
9907
9908 case 10410: hash_type = HASH_TYPE_PDFU16;
9909 salt_type = SALT_TYPE_EMBEDDED;
9910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9911 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9912 kern_type = KERN_TYPE_PDF11CM1;
9913 dgst_size = DGST_SIZE_4_4;
9914 parse_func = pdf11cm1_parse_hash;
9915 sort_by_digest = sort_by_digest_4_4;
9916 opti_type = OPTI_TYPE_ZERO_BYTE
9917 | OPTI_TYPE_NOT_ITERATED;
9918 dgst_pos0 = 0;
9919 dgst_pos1 = 1;
9920 dgst_pos2 = 2;
9921 dgst_pos3 = 3;
9922 break;
9923
9924 case 10420: hash_type = HASH_TYPE_PDFU16;
9925 salt_type = SALT_TYPE_EMBEDDED;
9926 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9927 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9928 kern_type = KERN_TYPE_PDF11CM2;
9929 dgst_size = DGST_SIZE_4_4;
9930 parse_func = pdf11cm2_parse_hash;
9931 sort_by_digest = sort_by_digest_4_4;
9932 opti_type = OPTI_TYPE_ZERO_BYTE
9933 | OPTI_TYPE_NOT_ITERATED;
9934 dgst_pos0 = 0;
9935 dgst_pos1 = 1;
9936 dgst_pos2 = 2;
9937 dgst_pos3 = 3;
9938 break;
9939
9940 case 10500: hash_type = HASH_TYPE_PDFU16;
9941 salt_type = SALT_TYPE_EMBEDDED;
9942 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9943 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9944 kern_type = KERN_TYPE_PDF14;
9945 dgst_size = DGST_SIZE_4_4;
9946 parse_func = pdf14_parse_hash;
9947 sort_by_digest = sort_by_digest_4_4;
9948 opti_type = OPTI_TYPE_ZERO_BYTE
9949 | OPTI_TYPE_NOT_ITERATED;
9950 dgst_pos0 = 0;
9951 dgst_pos1 = 1;
9952 dgst_pos2 = 2;
9953 dgst_pos3 = 3;
9954 break;
9955
9956 case 10600: hash_type = HASH_TYPE_SHA256;
9957 salt_type = SALT_TYPE_EMBEDDED;
9958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9959 opts_type = OPTS_TYPE_PT_GENERATE_BE
9960 | OPTS_TYPE_ST_ADD80
9961 | OPTS_TYPE_ST_ADDBITS15
9962 | OPTS_TYPE_HASH_COPY;
9963 kern_type = KERN_TYPE_SHA256_PWSLT;
9964 dgst_size = DGST_SIZE_4_8;
9965 parse_func = pdf17l3_parse_hash;
9966 sort_by_digest = sort_by_digest_4_8;
9967 opti_type = OPTI_TYPE_ZERO_BYTE
9968 | OPTI_TYPE_PRECOMPUTE_INIT
9969 | OPTI_TYPE_PRECOMPUTE_MERKLE
9970 | OPTI_TYPE_EARLY_SKIP
9971 | OPTI_TYPE_NOT_ITERATED
9972 | OPTI_TYPE_APPENDED_SALT
9973 | OPTI_TYPE_RAW_HASH;
9974 dgst_pos0 = 3;
9975 dgst_pos1 = 7;
9976 dgst_pos2 = 2;
9977 dgst_pos3 = 6;
9978 break;
9979
9980 case 10700: hash_type = HASH_TYPE_PDFU32;
9981 salt_type = SALT_TYPE_EMBEDDED;
9982 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9983 opts_type = OPTS_TYPE_PT_GENERATE_LE
9984 | OPTS_TYPE_HASH_COPY;
9985 kern_type = KERN_TYPE_PDF17L8;
9986 dgst_size = DGST_SIZE_4_8;
9987 parse_func = pdf17l8_parse_hash;
9988 sort_by_digest = sort_by_digest_4_8;
9989 opti_type = OPTI_TYPE_ZERO_BYTE
9990 | OPTI_TYPE_NOT_ITERATED;
9991 dgst_pos0 = 0;
9992 dgst_pos1 = 1;
9993 dgst_pos2 = 2;
9994 dgst_pos3 = 3;
9995 break;
9996
9997 case 10800: hash_type = HASH_TYPE_SHA384;
9998 salt_type = SALT_TYPE_NONE;
9999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10000 opts_type = OPTS_TYPE_PT_GENERATE_BE
10001 | OPTS_TYPE_PT_ADD80
10002 | OPTS_TYPE_PT_ADDBITS15;
10003 kern_type = KERN_TYPE_SHA384;
10004 dgst_size = DGST_SIZE_8_8;
10005 parse_func = sha384_parse_hash;
10006 sort_by_digest = sort_by_digest_8_8;
10007 opti_type = OPTI_TYPE_ZERO_BYTE
10008 | OPTI_TYPE_PRECOMPUTE_INIT
10009 | OPTI_TYPE_PRECOMPUTE_MERKLE
10010 | OPTI_TYPE_EARLY_SKIP
10011 | OPTI_TYPE_NOT_ITERATED
10012 | OPTI_TYPE_NOT_SALTED
10013 | OPTI_TYPE_USES_BITS_64
10014 | OPTI_TYPE_RAW_HASH;
10015 dgst_pos0 = 6;
10016 dgst_pos1 = 7;
10017 dgst_pos2 = 4;
10018 dgst_pos3 = 5;
10019 break;
10020
10021 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10022 salt_type = SALT_TYPE_EMBEDDED;
10023 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10024 opts_type = OPTS_TYPE_PT_GENERATE_LE
10025 | OPTS_TYPE_ST_BASE64
10026 | OPTS_TYPE_HASH_COPY;
10027 kern_type = KERN_TYPE_PBKDF2_SHA256;
10028 dgst_size = DGST_SIZE_4_32;
10029 parse_func = pbkdf2_sha256_parse_hash;
10030 sort_by_digest = sort_by_digest_4_32;
10031 opti_type = OPTI_TYPE_ZERO_BYTE
10032 | OPTI_TYPE_SLOW_HASH_SIMD;
10033 dgst_pos0 = 0;
10034 dgst_pos1 = 1;
10035 dgst_pos2 = 2;
10036 dgst_pos3 = 3;
10037 break;
10038
10039 case 11000: hash_type = HASH_TYPE_MD5;
10040 salt_type = SALT_TYPE_INTERN;
10041 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10042 opts_type = OPTS_TYPE_PT_GENERATE_LE
10043 | OPTS_TYPE_PT_ADD80;
10044 kern_type = KERN_TYPE_PRESTASHOP;
10045 dgst_size = DGST_SIZE_4_4;
10046 parse_func = prestashop_parse_hash;
10047 sort_by_digest = sort_by_digest_4_4;
10048 opti_type = OPTI_TYPE_ZERO_BYTE
10049 | OPTI_TYPE_PRECOMPUTE_INIT
10050 | OPTI_TYPE_NOT_ITERATED
10051 | OPTI_TYPE_PREPENDED_SALT;
10052 dgst_pos0 = 0;
10053 dgst_pos1 = 3;
10054 dgst_pos2 = 2;
10055 dgst_pos3 = 1;
10056 break;
10057
10058 case 11100: hash_type = HASH_TYPE_MD5;
10059 salt_type = SALT_TYPE_EMBEDDED;
10060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10061 opts_type = OPTS_TYPE_PT_GENERATE_LE
10062 | OPTS_TYPE_ST_ADD80;
10063 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10064 dgst_size = DGST_SIZE_4_4;
10065 parse_func = postgresql_auth_parse_hash;
10066 sort_by_digest = sort_by_digest_4_4;
10067 opti_type = OPTI_TYPE_ZERO_BYTE
10068 | OPTI_TYPE_PRECOMPUTE_INIT
10069 | OPTI_TYPE_PRECOMPUTE_MERKLE
10070 | OPTI_TYPE_EARLY_SKIP;
10071 dgst_pos0 = 0;
10072 dgst_pos1 = 3;
10073 dgst_pos2 = 2;
10074 dgst_pos3 = 1;
10075 break;
10076
10077 case 11200: hash_type = HASH_TYPE_SHA1;
10078 salt_type = SALT_TYPE_EMBEDDED;
10079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10080 opts_type = OPTS_TYPE_PT_GENERATE_BE
10081 | OPTS_TYPE_PT_ADD80
10082 | OPTS_TYPE_ST_HEX;
10083 kern_type = KERN_TYPE_MYSQL_AUTH;
10084 dgst_size = DGST_SIZE_4_5;
10085 parse_func = mysql_auth_parse_hash;
10086 sort_by_digest = sort_by_digest_4_5;
10087 opti_type = OPTI_TYPE_ZERO_BYTE
10088 | OPTI_TYPE_EARLY_SKIP;
10089 dgst_pos0 = 3;
10090 dgst_pos1 = 4;
10091 dgst_pos2 = 2;
10092 dgst_pos3 = 1;
10093 break;
10094
10095 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10096 salt_type = SALT_TYPE_EMBEDDED;
10097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10098 opts_type = OPTS_TYPE_PT_GENERATE_LE
10099 | OPTS_TYPE_ST_HEX
10100 | OPTS_TYPE_ST_ADD80;
10101 kern_type = KERN_TYPE_BITCOIN_WALLET;
10102 dgst_size = DGST_SIZE_4_4;
10103 parse_func = bitcoin_wallet_parse_hash;
10104 sort_by_digest = sort_by_digest_4_4;
10105 opti_type = OPTI_TYPE_ZERO_BYTE;
10106 dgst_pos0 = 0;
10107 dgst_pos1 = 1;
10108 dgst_pos2 = 2;
10109 dgst_pos3 = 3;
10110 break;
10111
10112 case 11400: hash_type = HASH_TYPE_MD5;
10113 salt_type = SALT_TYPE_EMBEDDED;
10114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10115 opts_type = OPTS_TYPE_PT_GENERATE_LE
10116 | OPTS_TYPE_PT_ADD80
10117 | OPTS_TYPE_HASH_COPY;
10118 kern_type = KERN_TYPE_SIP_AUTH;
10119 dgst_size = DGST_SIZE_4_4;
10120 parse_func = sip_auth_parse_hash;
10121 sort_by_digest = sort_by_digest_4_4;
10122 opti_type = OPTI_TYPE_ZERO_BYTE;
10123 dgst_pos0 = 0;
10124 dgst_pos1 = 3;
10125 dgst_pos2 = 2;
10126 dgst_pos3 = 1;
10127 break;
10128
10129 case 11500: hash_type = HASH_TYPE_CRC32;
10130 salt_type = SALT_TYPE_INTERN;
10131 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10132 opts_type = OPTS_TYPE_PT_GENERATE_LE
10133 | OPTS_TYPE_ST_GENERATE_LE
10134 | OPTS_TYPE_ST_HEX;
10135 kern_type = KERN_TYPE_CRC32;
10136 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10137 parse_func = crc32_parse_hash;
10138 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10139 opti_type = OPTI_TYPE_ZERO_BYTE;
10140 dgst_pos0 = 0;
10141 dgst_pos1 = 1;
10142 dgst_pos2 = 2;
10143 dgst_pos3 = 3;
10144 break;
10145
10146 case 11600: hash_type = HASH_TYPE_AES;
10147 salt_type = SALT_TYPE_EMBEDDED;
10148 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10149 opts_type = OPTS_TYPE_PT_GENERATE_LE
10150 | OPTS_TYPE_PT_NEVERCRACK;
10151 kern_type = KERN_TYPE_SEVEN_ZIP;
10152 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10153 parse_func = seven_zip_parse_hash;
10154 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10155 opti_type = OPTI_TYPE_ZERO_BYTE;
10156 dgst_pos0 = 0;
10157 dgst_pos1 = 1;
10158 dgst_pos2 = 2;
10159 dgst_pos3 = 3;
10160 break;
10161
10162 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10163 salt_type = SALT_TYPE_NONE;
10164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10165 opts_type = OPTS_TYPE_PT_GENERATE_LE
10166 | OPTS_TYPE_PT_ADD01;
10167 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10168 dgst_size = DGST_SIZE_4_8;
10169 parse_func = gost2012sbog_256_parse_hash;
10170 sort_by_digest = sort_by_digest_4_8;
10171 opti_type = OPTI_TYPE_ZERO_BYTE;
10172 dgst_pos0 = 0;
10173 dgst_pos1 = 1;
10174 dgst_pos2 = 2;
10175 dgst_pos3 = 3;
10176 break;
10177
10178 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10179 salt_type = SALT_TYPE_NONE;
10180 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10181 opts_type = OPTS_TYPE_PT_GENERATE_LE
10182 | OPTS_TYPE_PT_ADD01;
10183 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10184 dgst_size = DGST_SIZE_4_16;
10185 parse_func = gost2012sbog_512_parse_hash;
10186 sort_by_digest = sort_by_digest_4_16;
10187 opti_type = OPTI_TYPE_ZERO_BYTE;
10188 dgst_pos0 = 0;
10189 dgst_pos1 = 1;
10190 dgst_pos2 = 2;
10191 dgst_pos3 = 3;
10192 break;
10193
10194 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10195 salt_type = SALT_TYPE_EMBEDDED;
10196 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10197 opts_type = OPTS_TYPE_PT_GENERATE_LE
10198 | OPTS_TYPE_ST_BASE64
10199 | OPTS_TYPE_HASH_COPY;
10200 kern_type = KERN_TYPE_PBKDF2_MD5;
10201 dgst_size = DGST_SIZE_4_32;
10202 parse_func = pbkdf2_md5_parse_hash;
10203 sort_by_digest = sort_by_digest_4_32;
10204 opti_type = OPTI_TYPE_ZERO_BYTE
10205 | OPTI_TYPE_SLOW_HASH_SIMD;
10206 dgst_pos0 = 0;
10207 dgst_pos1 = 1;
10208 dgst_pos2 = 2;
10209 dgst_pos3 = 3;
10210 break;
10211
10212 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10213 salt_type = SALT_TYPE_EMBEDDED;
10214 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10215 opts_type = OPTS_TYPE_PT_GENERATE_LE
10216 | OPTS_TYPE_ST_BASE64
10217 | OPTS_TYPE_HASH_COPY;
10218 kern_type = KERN_TYPE_PBKDF2_SHA1;
10219 dgst_size = DGST_SIZE_4_32;
10220 parse_func = pbkdf2_sha1_parse_hash;
10221 sort_by_digest = sort_by_digest_4_32;
10222 opti_type = OPTI_TYPE_ZERO_BYTE
10223 | OPTI_TYPE_SLOW_HASH_SIMD;
10224 dgst_pos0 = 0;
10225 dgst_pos1 = 1;
10226 dgst_pos2 = 2;
10227 dgst_pos3 = 3;
10228 break;
10229
10230 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10231 salt_type = SALT_TYPE_EMBEDDED;
10232 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10233 opts_type = OPTS_TYPE_PT_GENERATE_LE
10234 | OPTS_TYPE_ST_BASE64
10235 | OPTS_TYPE_HASH_COPY;
10236 kern_type = KERN_TYPE_PBKDF2_SHA512;
10237 dgst_size = DGST_SIZE_8_16;
10238 parse_func = pbkdf2_sha512_parse_hash;
10239 sort_by_digest = sort_by_digest_8_16;
10240 opti_type = OPTI_TYPE_ZERO_BYTE
10241 | OPTI_TYPE_USES_BITS_64
10242 | OPTI_TYPE_SLOW_HASH_SIMD;
10243 dgst_pos0 = 0;
10244 dgst_pos1 = 1;
10245 dgst_pos2 = 2;
10246 dgst_pos3 = 3;
10247 break;
10248
10249 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10250 salt_type = SALT_TYPE_EMBEDDED;
10251 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10252 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10253 kern_type = KERN_TYPE_ECRYPTFS;
10254 dgst_size = DGST_SIZE_8_8;
10255 parse_func = ecryptfs_parse_hash;
10256 sort_by_digest = sort_by_digest_8_8;
10257 opti_type = OPTI_TYPE_ZERO_BYTE
10258 | OPTI_TYPE_USES_BITS_64;
10259 dgst_pos0 = 0;
10260 dgst_pos1 = 1;
10261 dgst_pos2 = 2;
10262 dgst_pos3 = 3;
10263 break;
10264
10265 case 12300: hash_type = HASH_TYPE_ORACLET;
10266 salt_type = SALT_TYPE_EMBEDDED;
10267 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10268 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10269 kern_type = KERN_TYPE_ORACLET;
10270 dgst_size = DGST_SIZE_8_16;
10271 parse_func = oraclet_parse_hash;
10272 sort_by_digest = sort_by_digest_8_16;
10273 opti_type = OPTI_TYPE_ZERO_BYTE
10274 | OPTI_TYPE_USES_BITS_64;
10275 dgst_pos0 = 0;
10276 dgst_pos1 = 1;
10277 dgst_pos2 = 2;
10278 dgst_pos3 = 3;
10279 break;
10280
10281 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10282 salt_type = SALT_TYPE_EMBEDDED;
10283 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10284 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10285 kern_type = KERN_TYPE_BSDICRYPT;
10286 dgst_size = DGST_SIZE_4_4;
10287 parse_func = bsdicrypt_parse_hash;
10288 sort_by_digest = sort_by_digest_4_4;
10289 opti_type = OPTI_TYPE_ZERO_BYTE
10290 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10291 dgst_pos0 = 0;
10292 dgst_pos1 = 1;
10293 dgst_pos2 = 2;
10294 dgst_pos3 = 3;
10295 break;
10296
10297 case 12500: hash_type = HASH_TYPE_RAR3HP;
10298 salt_type = SALT_TYPE_EMBEDDED;
10299 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10300 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10301 kern_type = KERN_TYPE_RAR3;
10302 dgst_size = DGST_SIZE_4_4;
10303 parse_func = rar3hp_parse_hash;
10304 sort_by_digest = sort_by_digest_4_4;
10305 opti_type = OPTI_TYPE_ZERO_BYTE;
10306 dgst_pos0 = 0;
10307 dgst_pos1 = 1;
10308 dgst_pos2 = 2;
10309 dgst_pos3 = 3;
10310 break;
10311
10312 case 12600: hash_type = HASH_TYPE_SHA256;
10313 salt_type = SALT_TYPE_INTERN;
10314 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10315 opts_type = OPTS_TYPE_PT_GENERATE_BE
10316 | OPTS_TYPE_PT_ADD80;
10317 kern_type = KERN_TYPE_CF10;
10318 dgst_size = DGST_SIZE_4_8;
10319 parse_func = cf10_parse_hash;
10320 sort_by_digest = sort_by_digest_4_8;
10321 opti_type = OPTI_TYPE_ZERO_BYTE
10322 | OPTI_TYPE_PRECOMPUTE_INIT
10323 | OPTI_TYPE_EARLY_SKIP
10324 | OPTI_TYPE_NOT_ITERATED;
10325 dgst_pos0 = 3;
10326 dgst_pos1 = 7;
10327 dgst_pos2 = 2;
10328 dgst_pos3 = 6;
10329 break;
10330
10331 case 12700: hash_type = HASH_TYPE_AES;
10332 salt_type = SALT_TYPE_EMBEDDED;
10333 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10334 opts_type = OPTS_TYPE_PT_GENERATE_LE
10335 | OPTS_TYPE_HASH_COPY;
10336 kern_type = KERN_TYPE_MYWALLET;
10337 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10338 parse_func = mywallet_parse_hash;
10339 sort_by_digest = sort_by_digest_4_5;
10340 opti_type = OPTI_TYPE_ZERO_BYTE;
10341 dgst_pos0 = 0;
10342 dgst_pos1 = 1;
10343 dgst_pos2 = 2;
10344 dgst_pos3 = 3;
10345 break;
10346
10347 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10348 salt_type = SALT_TYPE_EMBEDDED;
10349 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10350 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10351 kern_type = KERN_TYPE_MS_DRSR;
10352 dgst_size = DGST_SIZE_4_8;
10353 parse_func = ms_drsr_parse_hash;
10354 sort_by_digest = sort_by_digest_4_8;
10355 opti_type = OPTI_TYPE_ZERO_BYTE;
10356 dgst_pos0 = 0;
10357 dgst_pos1 = 1;
10358 dgst_pos2 = 2;
10359 dgst_pos3 = 3;
10360 break;
10361
10362 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10363 salt_type = SALT_TYPE_EMBEDDED;
10364 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10365 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10366 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10367 dgst_size = DGST_SIZE_4_8;
10368 parse_func = androidfde_samsung_parse_hash;
10369 sort_by_digest = sort_by_digest_4_8;
10370 opti_type = OPTI_TYPE_ZERO_BYTE;
10371 dgst_pos0 = 0;
10372 dgst_pos1 = 1;
10373 dgst_pos2 = 2;
10374 dgst_pos3 = 3;
10375 break;
10376
10377 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10378 salt_type = SALT_TYPE_EMBEDDED;
10379 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10380 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10381 kern_type = KERN_TYPE_RAR5;
10382 dgst_size = DGST_SIZE_4_4;
10383 parse_func = rar5_parse_hash;
10384 sort_by_digest = sort_by_digest_4_4;
10385 opti_type = OPTI_TYPE_ZERO_BYTE;
10386 dgst_pos0 = 0;
10387 dgst_pos1 = 1;
10388 dgst_pos2 = 2;
10389 dgst_pos3 = 3;
10390 break;
10391
10392 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10393 salt_type = SALT_TYPE_EMBEDDED;
10394 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10395 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10396 kern_type = KERN_TYPE_KRB5TGS;
10397 dgst_size = DGST_SIZE_4_4;
10398 parse_func = krb5tgs_parse_hash;
10399 sort_by_digest = sort_by_digest_4_4;
10400 opti_type = OPTI_TYPE_ZERO_BYTE
10401 | OPTI_TYPE_NOT_ITERATED;
10402 dgst_pos0 = 0;
10403 dgst_pos1 = 1;
10404 dgst_pos2 = 2;
10405 dgst_pos3 = 3;
10406 break;
10407
10408 case 13200: hash_type = HASH_TYPE_AES;
10409 salt_type = SALT_TYPE_EMBEDDED;
10410 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10411 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10412 kern_type = KERN_TYPE_AXCRYPT;
10413 dgst_size = DGST_SIZE_4_4;
10414 parse_func = axcrypt_parse_hash;
10415 sort_by_digest = sort_by_digest_4_4;
10416 opti_type = OPTI_TYPE_ZERO_BYTE;
10417 dgst_pos0 = 0;
10418 dgst_pos1 = 1;
10419 dgst_pos2 = 2;
10420 dgst_pos3 = 3;
10421 break;
10422
10423 case 13300: hash_type = HASH_TYPE_SHA1;
10424 salt_type = SALT_TYPE_NONE;
10425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10426 opts_type = OPTS_TYPE_PT_GENERATE_BE
10427 | OPTS_TYPE_PT_ADD80
10428 | OPTS_TYPE_PT_ADDBITS15;
10429 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10430 dgst_size = DGST_SIZE_4_5;
10431 parse_func = sha1axcrypt_parse_hash;
10432 sort_by_digest = sort_by_digest_4_5;
10433 opti_type = OPTI_TYPE_ZERO_BYTE
10434 | OPTI_TYPE_PRECOMPUTE_INIT
10435 | OPTI_TYPE_EARLY_SKIP
10436 | OPTI_TYPE_NOT_ITERATED
10437 | OPTI_TYPE_NOT_SALTED;
10438 dgst_pos0 = 0;
10439 dgst_pos1 = 4;
10440 dgst_pos2 = 3;
10441 dgst_pos3 = 2;
10442 break;
10443
10444 case 13400: hash_type = HASH_TYPE_AES;
10445 salt_type = SALT_TYPE_EMBEDDED;
10446 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10447 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10448 kern_type = KERN_TYPE_KEEPASS;
10449 dgst_size = DGST_SIZE_4_4;
10450 parse_func = keepass_parse_hash;
10451 sort_by_digest = sort_by_digest_4_4;
10452 opti_type = OPTI_TYPE_ZERO_BYTE;
10453 dgst_pos0 = 0;
10454 dgst_pos1 = 1;
10455 dgst_pos2 = 2;
10456 dgst_pos3 = 3;
10457 break;
10458
10459 case 13500: hash_type = HASH_TYPE_SHA1;
10460 salt_type = SALT_TYPE_EMBEDDED;
10461 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10462 opts_type = OPTS_TYPE_PT_GENERATE_BE
10463 | OPTS_TYPE_PT_UNICODE
10464 | OPTS_TYPE_PT_ADD80;
10465 kern_type = KERN_TYPE_PSTOKEN;
10466 dgst_size = DGST_SIZE_4_5;
10467 parse_func = pstoken_parse_hash;
10468 sort_by_digest = sort_by_digest_4_5;
10469 opti_type = OPTI_TYPE_ZERO_BYTE
10470 | OPTI_TYPE_PRECOMPUTE_INIT
10471 | OPTI_TYPE_EARLY_SKIP
10472 | OPTI_TYPE_NOT_ITERATED
10473 | OPTI_TYPE_PREPENDED_SALT
10474 | OPTI_TYPE_RAW_HASH;
10475 dgst_pos0 = 3;
10476 dgst_pos1 = 4;
10477 dgst_pos2 = 2;
10478 dgst_pos3 = 1;
10479 break;
10480
10481 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10482 salt_type = SALT_TYPE_EMBEDDED;
10483 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10484 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10485 kern_type = KERN_TYPE_ZIP2;
10486 dgst_size = DGST_SIZE_4_4;
10487 parse_func = zip2_parse_hash;
10488 sort_by_digest = sort_by_digest_4_4;
10489 opti_type = OPTI_TYPE_ZERO_BYTE;
10490 dgst_pos0 = 0;
10491 dgst_pos1 = 1;
10492 dgst_pos2 = 2;
10493 dgst_pos3 = 3;
10494 break;
10495
10496 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10497 salt_type = SALT_TYPE_EMBEDDED;
10498 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10499 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10500 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10501 dgst_size = DGST_SIZE_4_5;
10502 parse_func = veracrypt_parse_hash_655331;
10503 sort_by_digest = sort_by_digest_4_5;
10504 opti_type = OPTI_TYPE_ZERO_BYTE;
10505 dgst_pos0 = 0;
10506 dgst_pos1 = 1;
10507 dgst_pos2 = 2;
10508 dgst_pos3 = 3;
10509 break;
10510
10511 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10512 salt_type = SALT_TYPE_EMBEDDED;
10513 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10514 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10515 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10516 dgst_size = DGST_SIZE_4_5;
10517 parse_func = veracrypt_parse_hash_655331;
10518 sort_by_digest = sort_by_digest_4_5;
10519 opti_type = OPTI_TYPE_ZERO_BYTE;
10520 dgst_pos0 = 0;
10521 dgst_pos1 = 1;
10522 dgst_pos2 = 2;
10523 dgst_pos3 = 3;
10524 break;
10525
10526 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10527 salt_type = SALT_TYPE_EMBEDDED;
10528 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10529 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10530 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10531 dgst_size = DGST_SIZE_4_5;
10532 parse_func = veracrypt_parse_hash_655331;
10533 sort_by_digest = sort_by_digest_4_5;
10534 opti_type = OPTI_TYPE_ZERO_BYTE;
10535 dgst_pos0 = 0;
10536 dgst_pos1 = 1;
10537 dgst_pos2 = 2;
10538 dgst_pos3 = 3;
10539 break;
10540
10541 case 13721: hash_type = HASH_TYPE_SHA512;
10542 salt_type = SALT_TYPE_EMBEDDED;
10543 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10544 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10545 kern_type = KERN_TYPE_TCSHA512_XTS512;
10546 dgst_size = DGST_SIZE_8_8;
10547 parse_func = veracrypt_parse_hash_500000;
10548 sort_by_digest = sort_by_digest_8_8;
10549 opti_type = OPTI_TYPE_ZERO_BYTE
10550 | OPTI_TYPE_USES_BITS_64;
10551 dgst_pos0 = 0;
10552 dgst_pos1 = 1;
10553 dgst_pos2 = 2;
10554 dgst_pos3 = 3;
10555 break;
10556
10557 case 13722: hash_type = HASH_TYPE_SHA512;
10558 salt_type = SALT_TYPE_EMBEDDED;
10559 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10560 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10561 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10562 dgst_size = DGST_SIZE_8_8;
10563 parse_func = veracrypt_parse_hash_500000;
10564 sort_by_digest = sort_by_digest_8_8;
10565 opti_type = OPTI_TYPE_ZERO_BYTE
10566 | OPTI_TYPE_USES_BITS_64;
10567 dgst_pos0 = 0;
10568 dgst_pos1 = 1;
10569 dgst_pos2 = 2;
10570 dgst_pos3 = 3;
10571 break;
10572
10573 case 13723: hash_type = HASH_TYPE_SHA512;
10574 salt_type = SALT_TYPE_EMBEDDED;
10575 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10576 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10577 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10578 dgst_size = DGST_SIZE_8_8;
10579 parse_func = veracrypt_parse_hash_500000;
10580 sort_by_digest = sort_by_digest_8_8;
10581 opti_type = OPTI_TYPE_ZERO_BYTE
10582 | OPTI_TYPE_USES_BITS_64;
10583 dgst_pos0 = 0;
10584 dgst_pos1 = 1;
10585 dgst_pos2 = 2;
10586 dgst_pos3 = 3;
10587 break;
10588
10589 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10590 salt_type = SALT_TYPE_EMBEDDED;
10591 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10592 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10593 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10594 dgst_size = DGST_SIZE_4_8;
10595 parse_func = veracrypt_parse_hash_500000;
10596 sort_by_digest = sort_by_digest_4_8;
10597 opti_type = OPTI_TYPE_ZERO_BYTE;
10598 dgst_pos0 = 0;
10599 dgst_pos1 = 1;
10600 dgst_pos2 = 2;
10601 dgst_pos3 = 3;
10602 break;
10603
10604 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10605 salt_type = SALT_TYPE_EMBEDDED;
10606 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10607 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10608 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10609 dgst_size = DGST_SIZE_4_8;
10610 parse_func = veracrypt_parse_hash_500000;
10611 sort_by_digest = sort_by_digest_4_8;
10612 opti_type = OPTI_TYPE_ZERO_BYTE;
10613 dgst_pos0 = 0;
10614 dgst_pos1 = 1;
10615 dgst_pos2 = 2;
10616 dgst_pos3 = 3;
10617 break;
10618
10619 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10620 salt_type = SALT_TYPE_EMBEDDED;
10621 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10622 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10623 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10624 dgst_size = DGST_SIZE_4_8;
10625 parse_func = veracrypt_parse_hash_500000;
10626 sort_by_digest = sort_by_digest_4_8;
10627 opti_type = OPTI_TYPE_ZERO_BYTE;
10628 dgst_pos0 = 0;
10629 dgst_pos1 = 1;
10630 dgst_pos2 = 2;
10631 dgst_pos3 = 3;
10632 break;
10633
10634 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10635 salt_type = SALT_TYPE_EMBEDDED;
10636 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10637 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10638 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10639 dgst_size = DGST_SIZE_4_5;
10640 parse_func = veracrypt_parse_hash_327661;
10641 sort_by_digest = sort_by_digest_4_5;
10642 opti_type = OPTI_TYPE_ZERO_BYTE;
10643 dgst_pos0 = 0;
10644 dgst_pos1 = 1;
10645 dgst_pos2 = 2;
10646 dgst_pos3 = 3;
10647 break;
10648
10649 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10650 salt_type = SALT_TYPE_EMBEDDED;
10651 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10652 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10653 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10654 dgst_size = DGST_SIZE_4_5;
10655 parse_func = veracrypt_parse_hash_327661;
10656 sort_by_digest = sort_by_digest_4_5;
10657 opti_type = OPTI_TYPE_ZERO_BYTE;
10658 dgst_pos0 = 0;
10659 dgst_pos1 = 1;
10660 dgst_pos2 = 2;
10661 dgst_pos3 = 3;
10662 break;
10663
10664 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10665 salt_type = SALT_TYPE_EMBEDDED;
10666 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10667 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10668 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10669 dgst_size = DGST_SIZE_4_5;
10670 parse_func = veracrypt_parse_hash_327661;
10671 sort_by_digest = sort_by_digest_4_5;
10672 opti_type = OPTI_TYPE_ZERO_BYTE;
10673 dgst_pos0 = 0;
10674 dgst_pos1 = 1;
10675 dgst_pos2 = 2;
10676 dgst_pos3 = 3;
10677 break;
10678
10679 case 13751: hash_type = HASH_TYPE_SHA256;
10680 salt_type = SALT_TYPE_EMBEDDED;
10681 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10682 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10683 kern_type = KERN_TYPE_VCSHA256_XTS512;
10684 dgst_size = DGST_SIZE_4_8;
10685 parse_func = veracrypt_parse_hash_500000;
10686 sort_by_digest = sort_by_digest_4_8;
10687 opti_type = OPTI_TYPE_ZERO_BYTE;
10688 dgst_pos0 = 0;
10689 dgst_pos1 = 1;
10690 dgst_pos2 = 2;
10691 dgst_pos3 = 3;
10692 break;
10693
10694 case 13752: hash_type = HASH_TYPE_SHA256;
10695 salt_type = SALT_TYPE_EMBEDDED;
10696 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10697 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10698 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10699 dgst_size = DGST_SIZE_4_8;
10700 parse_func = veracrypt_parse_hash_500000;
10701 sort_by_digest = sort_by_digest_4_8;
10702 opti_type = OPTI_TYPE_ZERO_BYTE;
10703 dgst_pos0 = 0;
10704 dgst_pos1 = 1;
10705 dgst_pos2 = 2;
10706 dgst_pos3 = 3;
10707 break;
10708
10709 case 13753: hash_type = HASH_TYPE_SHA256;
10710 salt_type = SALT_TYPE_EMBEDDED;
10711 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10712 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10713 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10714 dgst_size = DGST_SIZE_4_8;
10715 parse_func = veracrypt_parse_hash_500000;
10716 sort_by_digest = sort_by_digest_4_8;
10717 opti_type = OPTI_TYPE_ZERO_BYTE;
10718 dgst_pos0 = 0;
10719 dgst_pos1 = 1;
10720 dgst_pos2 = 2;
10721 dgst_pos3 = 3;
10722 break;
10723
10724 case 13761: hash_type = HASH_TYPE_SHA256;
10725 salt_type = SALT_TYPE_EMBEDDED;
10726 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10727 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10728 kern_type = KERN_TYPE_VCSHA256_XTS512;
10729 dgst_size = DGST_SIZE_4_8;
10730 parse_func = veracrypt_parse_hash_200000;
10731 sort_by_digest = sort_by_digest_4_8;
10732 opti_type = OPTI_TYPE_ZERO_BYTE;
10733 dgst_pos0 = 0;
10734 dgst_pos1 = 1;
10735 dgst_pos2 = 2;
10736 dgst_pos3 = 3;
10737 break;
10738
10739 case 13762: hash_type = HASH_TYPE_SHA256;
10740 salt_type = SALT_TYPE_EMBEDDED;
10741 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10742 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10743 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10744 dgst_size = DGST_SIZE_4_8;
10745 parse_func = veracrypt_parse_hash_200000;
10746 sort_by_digest = sort_by_digest_4_8;
10747 opti_type = OPTI_TYPE_ZERO_BYTE;
10748 dgst_pos0 = 0;
10749 dgst_pos1 = 1;
10750 dgst_pos2 = 2;
10751 dgst_pos3 = 3;
10752 break;
10753
10754 case 13763: hash_type = HASH_TYPE_SHA256;
10755 salt_type = SALT_TYPE_EMBEDDED;
10756 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10757 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10758 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10759 dgst_size = DGST_SIZE_4_8;
10760 parse_func = veracrypt_parse_hash_200000;
10761 sort_by_digest = sort_by_digest_4_8;
10762 opti_type = OPTI_TYPE_ZERO_BYTE;
10763 dgst_pos0 = 0;
10764 dgst_pos1 = 1;
10765 dgst_pos2 = 2;
10766 dgst_pos3 = 3;
10767 break;
10768
10769
10770 default: usage_mini_print (PROGNAME); return (-1);
10771 }
10772
10773 /**
10774 * parser
10775 */
10776
10777 data.parse_func = parse_func;
10778
10779 /**
10780 * misc stuff
10781 */
10782
10783 if (hex_salt)
10784 {
10785 if (salt_type == SALT_TYPE_INTERN)
10786 {
10787 opts_type |= OPTS_TYPE_ST_HEX;
10788 }
10789 else
10790 {
10791 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10792
10793 return (-1);
10794 }
10795 }
10796
10797 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10798 | (salt_type == SALT_TYPE_EXTERN)
10799 | (salt_type == SALT_TYPE_EMBEDDED)
10800 | (salt_type == SALT_TYPE_VIRTUAL));
10801
10802 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10803
10804 data.hash_type = hash_type;
10805 data.attack_mode = attack_mode;
10806 data.attack_kern = attack_kern;
10807 data.attack_exec = attack_exec;
10808 data.kern_type = kern_type;
10809 data.opts_type = opts_type;
10810 data.dgst_size = dgst_size;
10811 data.salt_type = salt_type;
10812 data.isSalted = isSalted;
10813 data.sort_by_digest = sort_by_digest;
10814 data.dgst_pos0 = dgst_pos0;
10815 data.dgst_pos1 = dgst_pos1;
10816 data.dgst_pos2 = dgst_pos2;
10817 data.dgst_pos3 = dgst_pos3;
10818
10819 esalt_size = 0;
10820
10821 switch (hash_mode)
10822 {
10823 case 2500: esalt_size = sizeof (wpa_t); break;
10824 case 5300: esalt_size = sizeof (ikepsk_t); break;
10825 case 5400: esalt_size = sizeof (ikepsk_t); break;
10826 case 5500: esalt_size = sizeof (netntlm_t); break;
10827 case 5600: esalt_size = sizeof (netntlm_t); break;
10828 case 6211: esalt_size = sizeof (tc_t); break;
10829 case 6212: esalt_size = sizeof (tc_t); break;
10830 case 6213: esalt_size = sizeof (tc_t); break;
10831 case 6221: esalt_size = sizeof (tc_t); break;
10832 case 6222: esalt_size = sizeof (tc_t); break;
10833 case 6223: esalt_size = sizeof (tc_t); break;
10834 case 6231: esalt_size = sizeof (tc_t); break;
10835 case 6232: esalt_size = sizeof (tc_t); break;
10836 case 6233: esalt_size = sizeof (tc_t); break;
10837 case 6241: esalt_size = sizeof (tc_t); break;
10838 case 6242: esalt_size = sizeof (tc_t); break;
10839 case 6243: esalt_size = sizeof (tc_t); break;
10840 case 6600: esalt_size = sizeof (agilekey_t); break;
10841 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10842 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10843 case 7300: esalt_size = sizeof (rakp_t); break;
10844 case 7500: esalt_size = sizeof (krb5pa_t); break;
10845 case 8200: esalt_size = sizeof (cloudkey_t); break;
10846 case 8800: esalt_size = sizeof (androidfde_t); break;
10847 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10848 case 9400: esalt_size = sizeof (office2007_t); break;
10849 case 9500: esalt_size = sizeof (office2010_t); break;
10850 case 9600: esalt_size = sizeof (office2013_t); break;
10851 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10852 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10853 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10854 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10855 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10856 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10857 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10858 case 10200: esalt_size = sizeof (cram_md5_t); break;
10859 case 10400: esalt_size = sizeof (pdf_t); break;
10860 case 10410: esalt_size = sizeof (pdf_t); break;
10861 case 10420: esalt_size = sizeof (pdf_t); break;
10862 case 10500: esalt_size = sizeof (pdf_t); break;
10863 case 10600: esalt_size = sizeof (pdf_t); break;
10864 case 10700: esalt_size = sizeof (pdf_t); break;
10865 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10866 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10867 case 11400: esalt_size = sizeof (sip_t); break;
10868 case 11600: esalt_size = sizeof (seven_zip_t); break;
10869 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10870 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10871 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10872 case 13000: esalt_size = sizeof (rar5_t); break;
10873 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10874 case 13400: esalt_size = sizeof (keepass_t); break;
10875 case 13500: esalt_size = sizeof (pstoken_t); break;
10876 case 13600: esalt_size = sizeof (zip2_t); break;
10877 case 13711: esalt_size = sizeof (tc_t); break;
10878 case 13712: esalt_size = sizeof (tc_t); break;
10879 case 13713: esalt_size = sizeof (tc_t); break;
10880 case 13721: esalt_size = sizeof (tc_t); break;
10881 case 13722: esalt_size = sizeof (tc_t); break;
10882 case 13723: esalt_size = sizeof (tc_t); break;
10883 case 13731: esalt_size = sizeof (tc_t); break;
10884 case 13732: esalt_size = sizeof (tc_t); break;
10885 case 13733: esalt_size = sizeof (tc_t); break;
10886 case 13741: esalt_size = sizeof (tc_t); break;
10887 case 13742: esalt_size = sizeof (tc_t); break;
10888 case 13743: esalt_size = sizeof (tc_t); break;
10889 case 13751: esalt_size = sizeof (tc_t); break;
10890 case 13752: esalt_size = sizeof (tc_t); break;
10891 case 13753: esalt_size = sizeof (tc_t); break;
10892 case 13761: esalt_size = sizeof (tc_t); break;
10893 case 13762: esalt_size = sizeof (tc_t); break;
10894 case 13763: esalt_size = sizeof (tc_t); break;
10895 }
10896
10897 data.esalt_size = esalt_size;
10898
10899 /**
10900 * choose dictionary parser
10901 */
10902
10903 if (hash_type == HASH_TYPE_LM)
10904 {
10905 get_next_word_func = get_next_word_lm;
10906 }
10907 else if (opts_type & OPTS_TYPE_PT_UPPER)
10908 {
10909 get_next_word_func = get_next_word_uc;
10910 }
10911 else
10912 {
10913 get_next_word_func = get_next_word_std;
10914 }
10915
10916 /**
10917 * dictstat
10918 */
10919
10920 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10921
10922 #ifdef _POSIX
10923 size_t dictstat_nmemb = 0;
10924 #endif
10925
10926 #ifdef _WIN
10927 uint dictstat_nmemb = 0;
10928 #endif
10929
10930 char dictstat[256] = { 0 };
10931
10932 FILE *dictstat_fp = NULL;
10933
10934 if (keyspace == 0)
10935 {
10936 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10937
10938 dictstat_fp = fopen (dictstat, "rb");
10939
10940 if (dictstat_fp)
10941 {
10942 #ifdef _POSIX
10943 struct stat tmpstat;
10944
10945 fstat (fileno (dictstat_fp), &tmpstat);
10946 #endif
10947
10948 #ifdef _WIN
10949 struct stat64 tmpstat;
10950
10951 _fstat64 (fileno (dictstat_fp), &tmpstat);
10952 #endif
10953
10954 if (tmpstat.st_mtime < COMPTIME)
10955 {
10956 /* with v0.15 the format changed so we have to ensure user is using a good version
10957 since there is no version-header in the dictstat file */
10958
10959 fclose (dictstat_fp);
10960
10961 unlink (dictstat);
10962 }
10963 else
10964 {
10965 while (!feof (dictstat_fp))
10966 {
10967 dictstat_t d;
10968
10969 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10970
10971 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10972
10973 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10974 {
10975 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10976
10977 return -1;
10978 }
10979 }
10980
10981 fclose (dictstat_fp);
10982 }
10983 }
10984 }
10985
10986 /**
10987 * potfile
10988 */
10989
10990 char potfile[256] = { 0 };
10991
10992 if (potfile_path == NULL)
10993 {
10994 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10995 }
10996 else
10997 {
10998 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10999 }
11000
11001 data.pot_fp = NULL;
11002
11003 FILE *out_fp = NULL;
11004 FILE *pot_fp = NULL;
11005
11006 if (show == 1 || left == 1)
11007 {
11008 pot_fp = fopen (potfile, "rb");
11009
11010 if (pot_fp == NULL)
11011 {
11012 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11013
11014 return (-1);
11015 }
11016
11017 if (outfile != NULL)
11018 {
11019 if ((out_fp = fopen (outfile, "ab")) == NULL)
11020 {
11021 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11022
11023 fclose (pot_fp);
11024
11025 return (-1);
11026 }
11027 }
11028 else
11029 {
11030 out_fp = stdout;
11031 }
11032 }
11033 else
11034 {
11035 if (potfile_disable == 0)
11036 {
11037 pot_fp = fopen (potfile, "ab");
11038
11039 if (pot_fp == NULL)
11040 {
11041 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11042
11043 return (-1);
11044 }
11045
11046 data.pot_fp = pot_fp;
11047 }
11048 }
11049
11050 pot_t *pot = NULL;
11051
11052 uint pot_cnt = 0;
11053 uint pot_avail = 0;
11054
11055 if (show == 1 || left == 1)
11056 {
11057 SUPPRESS_OUTPUT = 1;
11058
11059 pot_avail = count_lines (pot_fp);
11060
11061 rewind (pot_fp);
11062
11063 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11064
11065 uint pot_hashes_avail = 0;
11066
11067 uint line_num = 0;
11068
11069 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11070
11071 while (!feof (pot_fp))
11072 {
11073 line_num++;
11074
11075 int line_len = fgetl (pot_fp, line_buf);
11076
11077 if (line_len == 0) continue;
11078
11079 char *plain_buf = line_buf + line_len;
11080
11081 pot_t *pot_ptr = &pot[pot_cnt];
11082
11083 hash_t *hashes_buf = &pot_ptr->hash;
11084
11085 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11086 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11087
11088 if (pot_cnt == pot_hashes_avail)
11089 {
11090 uint pos = 0;
11091
11092 for (pos = 0; pos < INCR_POT; pos++)
11093 {
11094 if ((pot_cnt + pos) >= pot_avail) break;
11095
11096 pot_t *tmp_pot = &pot[pot_cnt + pos];
11097
11098 hash_t *tmp_hash = &tmp_pot->hash;
11099
11100 tmp_hash->digest = mymalloc (dgst_size);
11101
11102 if (isSalted)
11103 {
11104 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11105 }
11106
11107 if (esalt_size)
11108 {
11109 tmp_hash->esalt = mymalloc (esalt_size);
11110 }
11111
11112 pot_hashes_avail++;
11113 }
11114 }
11115
11116 int plain_len = 0;
11117
11118 int parser_status;
11119
11120 int iter = MAX_CUT_TRIES;
11121
11122 do
11123 {
11124 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11125 {
11126 if (line_buf[i] == ':')
11127 {
11128 line_len--;
11129
11130 break;
11131 }
11132 }
11133
11134 if (data.hash_mode != 2500)
11135 {
11136 parser_status = parse_func (line_buf, line_len, hashes_buf);
11137 }
11138 else
11139 {
11140 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11141
11142 if (line_len > max_salt_size)
11143 {
11144 parser_status = PARSER_GLOBAL_LENGTH;
11145 }
11146 else
11147 {
11148 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11149
11150 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11151
11152 hashes_buf->salt->salt_len = line_len;
11153
11154 parser_status = PARSER_OK;
11155 }
11156 }
11157
11158 // if NOT parsed without error, we add the ":" to the plain
11159
11160 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11161 {
11162 plain_len++;
11163 plain_buf--;
11164 }
11165
11166 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11167
11168 if (parser_status < PARSER_GLOBAL_ZERO)
11169 {
11170 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11171
11172 continue;
11173 }
11174
11175 if (plain_len >= 255) continue;
11176
11177 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11178
11179 pot_ptr->plain_len = plain_len;
11180
11181 pot_cnt++;
11182 }
11183
11184 myfree (line_buf);
11185
11186 fclose (pot_fp);
11187
11188 SUPPRESS_OUTPUT = 0;
11189
11190 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11191 }
11192
11193 /**
11194 * word len
11195 */
11196
11197 uint pw_min = PW_MIN;
11198 uint pw_max = PW_MAX;
11199
11200 switch (hash_mode)
11201 {
11202 case 125: if (pw_max > 32) pw_max = 32;
11203 break;
11204 case 400: if (pw_max > 40) pw_max = 40;
11205 break;
11206 case 500: if (pw_max > 16) pw_max = 16;
11207 break;
11208 case 1500: if (pw_max > 8) pw_max = 8;
11209 break;
11210 case 1600: if (pw_max > 16) pw_max = 16;
11211 break;
11212 case 1800: if (pw_max > 16) pw_max = 16;
11213 break;
11214 case 2100: if (pw_max > 16) pw_max = 16;
11215 break;
11216 case 2500: if (pw_min < 8) pw_min = 8;
11217 break;
11218 case 3000: if (pw_max > 7) pw_max = 7;
11219 break;
11220 case 5200: if (pw_max > 24) pw_max = 24;
11221 break;
11222 case 5800: if (pw_max > 16) pw_max = 16;
11223 break;
11224 case 6300: if (pw_max > 16) pw_max = 16;
11225 break;
11226 case 7400: if (pw_max > 16) pw_max = 16;
11227 break;
11228 case 7500: if (pw_max > 8) pw_max = 8;
11229 break;
11230 case 7900: if (pw_max > 48) pw_max = 48;
11231 break;
11232 case 8500: if (pw_max > 8) pw_max = 8;
11233 break;
11234 case 8600: if (pw_max > 16) pw_max = 16;
11235 break;
11236 case 9710: pw_min = 5;
11237 pw_max = 5;
11238 break;
11239 case 9810: pw_min = 5;
11240 pw_max = 5;
11241 break;
11242 case 10410: pw_min = 5;
11243 pw_max = 5;
11244 break;
11245 case 10300: if (pw_max < 3) pw_min = 3;
11246 if (pw_max > 40) pw_max = 40;
11247 break;
11248 case 10500: if (pw_max < 3) pw_min = 3;
11249 if (pw_max > 40) pw_max = 40;
11250 break;
11251 case 10700: if (pw_max > 16) pw_max = 16;
11252 break;
11253 case 11300: if (pw_max > 40) pw_max = 40;
11254 break;
11255 case 11600: if (pw_max > 32) pw_max = 32;
11256 break;
11257 case 12500: if (pw_max > 20) pw_max = 20;
11258 break;
11259 case 12800: if (pw_max > 24) pw_max = 24;
11260 break;
11261 }
11262
11263 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11264 {
11265 switch (attack_kern)
11266 {
11267 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11268 break;
11269 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11270 break;
11271 }
11272 }
11273
11274 /**
11275 * charsets : keep them together for more easy maintainnce
11276 */
11277
11278 cs_t mp_sys[6] = { { { 0 }, 0 } };
11279 cs_t mp_usr[4] = { { { 0 }, 0 } };
11280
11281 mp_setup_sys (mp_sys);
11282
11283 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11284 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11285 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11286 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11287
11288 /**
11289 * load hashes, part I: find input mode, count hashes
11290 */
11291
11292 uint hashlist_mode = 0;
11293 uint hashlist_format = HLFMT_HASHCAT;
11294
11295 uint hashes_avail = 0;
11296
11297 if (benchmark == 0)
11298 {
11299 struct stat f;
11300
11301 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11302
11303 if ((hash_mode == 2500) ||
11304 (hash_mode == 5200) ||
11305 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11306 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11307 (hash_mode == 9000))
11308 {
11309 hashlist_mode = HL_MODE_ARG;
11310
11311 char *hashfile = myargv[optind];
11312
11313 data.hashfile = hashfile;
11314
11315 logfile_top_var_string ("target", hashfile);
11316 }
11317
11318 if (hashlist_mode == HL_MODE_ARG)
11319 {
11320 if (hash_mode == 2500)
11321 {
11322 struct stat st;
11323
11324 if (stat (data.hashfile, &st) == -1)
11325 {
11326 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11327
11328 return (-1);
11329 }
11330
11331 hashes_avail = st.st_size / sizeof (hccap_t);
11332 }
11333 else
11334 {
11335 hashes_avail = 1;
11336 }
11337 }
11338 else if (hashlist_mode == HL_MODE_FILE)
11339 {
11340 char *hashfile = myargv[optind];
11341
11342 data.hashfile = hashfile;
11343
11344 logfile_top_var_string ("target", hashfile);
11345
11346 FILE *fp = NULL;
11347
11348 if ((fp = fopen (hashfile, "rb")) == NULL)
11349 {
11350 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11351
11352 return (-1);
11353 }
11354
11355 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11356
11357 hashes_avail = count_lines (fp);
11358
11359 rewind (fp);
11360
11361 if (hashes_avail == 0)
11362 {
11363 log_error ("ERROR: hashfile is empty or corrupt");
11364
11365 fclose (fp);
11366
11367 return (-1);
11368 }
11369
11370 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11371
11372 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11373 {
11374 log_error ("ERROR: remove not supported in native hashfile-format mode");
11375
11376 fclose (fp);
11377
11378 return (-1);
11379 }
11380
11381 fclose (fp);
11382 }
11383 }
11384 else
11385 {
11386 hashlist_mode = HL_MODE_ARG;
11387
11388 hashes_avail = 1;
11389 }
11390
11391 if (hash_mode == 3000) hashes_avail *= 2;
11392
11393 data.hashlist_mode = hashlist_mode;
11394 data.hashlist_format = hashlist_format;
11395
11396 logfile_top_uint (hashlist_mode);
11397 logfile_top_uint (hashlist_format);
11398
11399 /**
11400 * load hashes, part II: allocate required memory, set pointers
11401 */
11402
11403 hash_t *hashes_buf = NULL;
11404 void *digests_buf = NULL;
11405 salt_t *salts_buf = NULL;
11406 void *esalts_buf = NULL;
11407
11408 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11409
11410 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11411
11412 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11413 {
11414 u32 hash_pos;
11415
11416 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11417 {
11418 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11419
11420 hashes_buf[hash_pos].hash_info = hash_info;
11421
11422 if (username && (remove || show || left))
11423 {
11424 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11425 }
11426
11427 if (benchmark)
11428 {
11429 hash_info->orighash = (char *) mymalloc (256);
11430 }
11431 }
11432 }
11433
11434 if (isSalted)
11435 {
11436 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11437
11438 if (esalt_size)
11439 {
11440 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11441 }
11442 }
11443 else
11444 {
11445 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11446 }
11447
11448 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11449 {
11450 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11451
11452 if (isSalted)
11453 {
11454 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11455
11456 if (esalt_size)
11457 {
11458 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11459 }
11460 }
11461 else
11462 {
11463 hashes_buf[hash_pos].salt = &salts_buf[0];
11464 }
11465 }
11466
11467 /**
11468 * load hashes, part III: parse hashes or generate them if benchmark
11469 */
11470
11471 uint hashes_cnt = 0;
11472
11473 if (benchmark == 0)
11474 {
11475 if (keyspace == 1)
11476 {
11477 // useless to read hash file for keyspace, cheat a little bit w/ optind
11478 }
11479 else if (hashes_avail == 0)
11480 {
11481 }
11482 else if (hashlist_mode == HL_MODE_ARG)
11483 {
11484 char *input_buf = myargv[optind];
11485
11486 uint input_len = strlen (input_buf);
11487
11488 logfile_top_var_string ("target", input_buf);
11489
11490 char *hash_buf = NULL;
11491 int hash_len = 0;
11492
11493 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11494
11495 bool hash_fmt_error = 0;
11496
11497 if (hash_len < 1) hash_fmt_error = 1;
11498 if (hash_buf == NULL) hash_fmt_error = 1;
11499
11500 if (hash_fmt_error)
11501 {
11502 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11503 }
11504 else
11505 {
11506 if (opts_type & OPTS_TYPE_HASH_COPY)
11507 {
11508 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11509
11510 hash_info_tmp->orighash = mystrdup (hash_buf);
11511 }
11512
11513 if (isSalted)
11514 {
11515 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11516 }
11517
11518 int parser_status = PARSER_OK;
11519
11520 if (hash_mode == 2500)
11521 {
11522 if (hash_len == 0)
11523 {
11524 log_error ("ERROR: hccap file not specified");
11525
11526 return (-1);
11527 }
11528
11529 hashlist_mode = HL_MODE_FILE;
11530
11531 data.hashlist_mode = hashlist_mode;
11532
11533 FILE *fp = fopen (hash_buf, "rb");
11534
11535 if (fp == NULL)
11536 {
11537 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11538
11539 return (-1);
11540 }
11541
11542 if (hashes_avail < 1)
11543 {
11544 log_error ("ERROR: hccap file is empty or corrupt");
11545
11546 fclose (fp);
11547
11548 return (-1);
11549 }
11550
11551 uint hccap_size = sizeof (hccap_t);
11552
11553 char *in = (char *) mymalloc (hccap_size);
11554
11555 while (!feof (fp))
11556 {
11557 int n = fread (in, hccap_size, 1, fp);
11558
11559 if (n != 1)
11560 {
11561 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11562
11563 break;
11564 }
11565
11566 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11567
11568 if (parser_status != PARSER_OK)
11569 {
11570 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11571
11572 continue;
11573 }
11574
11575 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11576
11577 if ((show == 1) || (left == 1))
11578 {
11579 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11580
11581 char *salt_ptr = (char *) tmp_salt->salt_buf;
11582
11583 int cur_pos = tmp_salt->salt_len;
11584 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11585
11586 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11587
11588 // do the appending task
11589
11590 snprintf (salt_ptr + cur_pos,
11591 rem_len,
11592 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11593 wpa->orig_mac1[0],
11594 wpa->orig_mac1[1],
11595 wpa->orig_mac1[2],
11596 wpa->orig_mac1[3],
11597 wpa->orig_mac1[4],
11598 wpa->orig_mac1[5],
11599 wpa->orig_mac2[0],
11600 wpa->orig_mac2[1],
11601 wpa->orig_mac2[2],
11602 wpa->orig_mac2[3],
11603 wpa->orig_mac2[4],
11604 wpa->orig_mac2[5]);
11605
11606 // memset () the remaining part of the salt
11607
11608 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11609 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11610
11611 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11612
11613 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11614 }
11615
11616 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);
11617 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);
11618
11619 hashes_cnt++;
11620 }
11621
11622 fclose (fp);
11623
11624 myfree (in);
11625 }
11626 else if (hash_mode == 3000)
11627 {
11628 if (hash_len == 32)
11629 {
11630 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11631
11632 hash_t *lm_hash_left = NULL;
11633
11634 if (parser_status == PARSER_OK)
11635 {
11636 lm_hash_left = &hashes_buf[hashes_cnt];
11637
11638 hashes_cnt++;
11639 }
11640 else
11641 {
11642 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11643 }
11644
11645 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11646
11647 hash_t *lm_hash_right = NULL;
11648
11649 if (parser_status == PARSER_OK)
11650 {
11651 lm_hash_right = &hashes_buf[hashes_cnt];
11652
11653 hashes_cnt++;
11654 }
11655 else
11656 {
11657 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11658 }
11659
11660 // show / left
11661
11662 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11663 {
11664 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);
11665 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);
11666 }
11667 }
11668 else
11669 {
11670 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11671
11672 if (parser_status == PARSER_OK)
11673 {
11674 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11675 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11676 }
11677
11678 if (parser_status == PARSER_OK)
11679 {
11680 hashes_cnt++;
11681 }
11682 else
11683 {
11684 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11685 }
11686 }
11687 }
11688 else
11689 {
11690 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11691
11692 if (parser_status == PARSER_OK)
11693 {
11694 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11695 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11696 }
11697
11698 if (parser_status == PARSER_OK)
11699 {
11700 hashes_cnt++;
11701 }
11702 else
11703 {
11704 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11705 }
11706 }
11707 }
11708 }
11709 else if (hashlist_mode == HL_MODE_FILE)
11710 {
11711 char *hashfile = data.hashfile;
11712
11713 FILE *fp;
11714
11715 if ((fp = fopen (hashfile, "rb")) == NULL)
11716 {
11717 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11718
11719 return (-1);
11720 }
11721
11722 uint line_num = 0;
11723
11724 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11725
11726 while (!feof (fp))
11727 {
11728 line_num++;
11729
11730 int line_len = fgetl (fp, line_buf);
11731
11732 if (line_len == 0) continue;
11733
11734 char *hash_buf = NULL;
11735 int hash_len = 0;
11736
11737 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11738
11739 bool hash_fmt_error = 0;
11740
11741 if (hash_len < 1) hash_fmt_error = 1;
11742 if (hash_buf == NULL) hash_fmt_error = 1;
11743
11744 if (hash_fmt_error)
11745 {
11746 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11747
11748 continue;
11749 }
11750
11751 if (username)
11752 {
11753 char *user_buf = NULL;
11754 int user_len = 0;
11755
11756 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11757
11758 if (remove || show)
11759 {
11760 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11761
11762 *user = (user_t *) mymalloc (sizeof (user_t));
11763
11764 user_t *user_ptr = *user;
11765
11766 if (user_buf != NULL)
11767 {
11768 user_ptr->user_name = mystrdup (user_buf);
11769 }
11770 else
11771 {
11772 user_ptr->user_name = mystrdup ("");
11773 }
11774
11775 user_ptr->user_len = user_len;
11776 }
11777 }
11778
11779 if (opts_type & OPTS_TYPE_HASH_COPY)
11780 {
11781 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11782
11783 hash_info_tmp->orighash = mystrdup (hash_buf);
11784 }
11785
11786 if (isSalted)
11787 {
11788 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11789 }
11790
11791 if (hash_mode == 3000)
11792 {
11793 if (hash_len == 32)
11794 {
11795 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11796
11797 if (parser_status < PARSER_GLOBAL_ZERO)
11798 {
11799 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11800
11801 continue;
11802 }
11803
11804 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11805
11806 hashes_cnt++;
11807
11808 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11809
11810 if (parser_status < PARSER_GLOBAL_ZERO)
11811 {
11812 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11813
11814 continue;
11815 }
11816
11817 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11818
11819 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);
11820
11821 hashes_cnt++;
11822
11823 // show / left
11824
11825 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);
11826 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);
11827 }
11828 else
11829 {
11830 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11831
11832 if (parser_status < PARSER_GLOBAL_ZERO)
11833 {
11834 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11835
11836 continue;
11837 }
11838
11839 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);
11840
11841 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11842 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11843
11844 hashes_cnt++;
11845 }
11846 }
11847 else
11848 {
11849 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11850
11851 if (parser_status < PARSER_GLOBAL_ZERO)
11852 {
11853 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11854
11855 continue;
11856 }
11857
11858 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);
11859
11860 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11861 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11862
11863 hashes_cnt++;
11864 }
11865 }
11866
11867 myfree (line_buf);
11868
11869 fclose (fp);
11870
11871 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11872
11873 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11874 }
11875 }
11876 else
11877 {
11878 if (isSalted)
11879 {
11880 hashes_buf[0].salt->salt_len = 8;
11881
11882 // special salt handling
11883
11884 switch (hash_mode)
11885 {
11886 case 1500: hashes_buf[0].salt->salt_len = 2;
11887 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11888 break;
11889 case 1731: hashes_buf[0].salt->salt_len = 4;
11890 break;
11891 case 2410: hashes_buf[0].salt->salt_len = 4;
11892 break;
11893 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11894 break;
11895 case 3100: hashes_buf[0].salt->salt_len = 1;
11896 break;
11897 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11898 break;
11899 case 5800: hashes_buf[0].salt->salt_len = 16;
11900 break;
11901 case 6800: hashes_buf[0].salt->salt_len = 32;
11902 break;
11903 case 8400: hashes_buf[0].salt->salt_len = 40;
11904 break;
11905 case 8800: hashes_buf[0].salt->salt_len = 16;
11906 break;
11907 case 8900: hashes_buf[0].salt->salt_len = 16;
11908 hashes_buf[0].salt->scrypt_N = 1024;
11909 hashes_buf[0].salt->scrypt_r = 1;
11910 hashes_buf[0].salt->scrypt_p = 1;
11911 break;
11912 case 9100: hashes_buf[0].salt->salt_len = 16;
11913 break;
11914 case 9300: hashes_buf[0].salt->salt_len = 14;
11915 hashes_buf[0].salt->scrypt_N = 16384;
11916 hashes_buf[0].salt->scrypt_r = 1;
11917 hashes_buf[0].salt->scrypt_p = 1;
11918 break;
11919 case 9400: hashes_buf[0].salt->salt_len = 16;
11920 break;
11921 case 9500: hashes_buf[0].salt->salt_len = 16;
11922 break;
11923 case 9600: hashes_buf[0].salt->salt_len = 16;
11924 break;
11925 case 9700: hashes_buf[0].salt->salt_len = 16;
11926 break;
11927 case 9710: hashes_buf[0].salt->salt_len = 16;
11928 break;
11929 case 9720: hashes_buf[0].salt->salt_len = 16;
11930 break;
11931 case 9800: hashes_buf[0].salt->salt_len = 16;
11932 break;
11933 case 9810: hashes_buf[0].salt->salt_len = 16;
11934 break;
11935 case 9820: hashes_buf[0].salt->salt_len = 16;
11936 break;
11937 case 10300: hashes_buf[0].salt->salt_len = 12;
11938 break;
11939 case 11500: hashes_buf[0].salt->salt_len = 4;
11940 break;
11941 case 11600: hashes_buf[0].salt->salt_len = 4;
11942 break;
11943 case 12400: hashes_buf[0].salt->salt_len = 4;
11944 break;
11945 case 12500: hashes_buf[0].salt->salt_len = 8;
11946 break;
11947 case 12600: hashes_buf[0].salt->salt_len = 64;
11948 break;
11949 }
11950
11951 // special esalt handling
11952
11953 switch (hash_mode)
11954 {
11955 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11956 break;
11957 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11958 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11959 break;
11960 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11961 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11962 break;
11963 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11964 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11965 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11966 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11967 break;
11968 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11969 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11970 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11971 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11972 break;
11973 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11974 break;
11975 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11976 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11977 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11978 break;
11979 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11980 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11981 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11982 break;
11983 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11984 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11985 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11986 break;
11987 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11988 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11989 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11990 break;
11991 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11992 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11993 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11994 break;
11995 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11996 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11997 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11998 break;
11999 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12000 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12001 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12002 break;
12003 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12004 break;
12005 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12006 break;
12007 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12008 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12009 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12010 break;
12011 }
12012 }
12013
12014 // set hashfile
12015
12016 switch (hash_mode)
12017 {
12018 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12019 break;
12020 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12021 break;
12022 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12023 break;
12024 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12025 break;
12026 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12027 break;
12028 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12029 break;
12030 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12031 break;
12032 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12033 break;
12034 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12035 break;
12036 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12037 break;
12038 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12039 break;
12040 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12041 break;
12042 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12043 break;
12044 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12045 break;
12046 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12047 break;
12048 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12049 break;
12050 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12051 break;
12052 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12053 break;
12054 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12055 break;
12056 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12057 break;
12058 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12059 break;
12060 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12061 break;
12062 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12063 break;
12064 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12065 break;
12066 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12067 break;
12068 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12069 break;
12070 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12071 break;
12072 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12073 break;
12074 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12075 break;
12076 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12077 break;
12078 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12079 break;
12080 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12081 break;
12082 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12083 break;
12084 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12085 break;
12086 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12087 break;
12088 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12089 break;
12090 }
12091
12092 // set default iterations
12093
12094 switch (hash_mode)
12095 {
12096 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12097 break;
12098 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12099 break;
12100 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12101 break;
12102 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12103 break;
12104 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12105 break;
12106 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12107 break;
12108 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12109 break;
12110 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12111 break;
12112 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12113 break;
12114 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12115 break;
12116 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12117 break;
12118 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12119 break;
12120 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12121 break;
12122 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12123 break;
12124 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12125 break;
12126 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12127 break;
12128 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12129 break;
12130 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12131 break;
12132 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12133 break;
12134 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12135 break;
12136 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12137 break;
12138 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12139 break;
12140 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12141 break;
12142 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12143 break;
12144 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12145 break;
12146 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12147 break;
12148 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12149 break;
12150 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12151 break;
12152 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12153 break;
12154 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12155 break;
12156 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12157 break;
12158 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12159 break;
12160 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12161 break;
12162 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12163 break;
12164 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12165 break;
12166 case 8900: hashes_buf[0].salt->salt_iter = 1;
12167 break;
12168 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12169 break;
12170 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12171 break;
12172 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12173 break;
12174 case 9300: hashes_buf[0].salt->salt_iter = 1;
12175 break;
12176 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12177 break;
12178 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12179 break;
12180 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12181 break;
12182 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12183 break;
12184 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12185 break;
12186 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12187 break;
12188 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12189 break;
12190 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12191 break;
12192 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12193 break;
12194 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12195 break;
12196 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12197 break;
12198 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12199 break;
12200 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12201 break;
12202 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12203 break;
12204 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12205 break;
12206 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12207 break;
12208 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12209 break;
12210 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12211 break;
12212 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12213 break;
12214 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12215 break;
12216 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12217 break;
12218 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12219 break;
12220 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12221 break;
12222 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12223 break;
12224 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12225 break;
12226 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12227 break;
12228 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12229 break;
12230 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12231 break;
12232 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12233 break;
12234 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12235 break;
12236 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12237 break;
12238 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12239 break;
12240 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12241 break;
12242 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12243 break;
12244 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12245 break;
12246 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12247 break;
12248 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12249 break;
12250 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12251 break;
12252 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12253 break;
12254 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12255 break;
12256 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12257 break;
12258 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12259 break;
12260 }
12261
12262 hashes_cnt = 1;
12263 }
12264
12265 if (show == 1 || left == 1)
12266 {
12267 for (uint i = 0; i < pot_cnt; i++)
12268 {
12269 pot_t *pot_ptr = &pot[i];
12270
12271 hash_t *hashes_buf = &pot_ptr->hash;
12272
12273 local_free (hashes_buf->digest);
12274
12275 if (isSalted)
12276 {
12277 local_free (hashes_buf->salt);
12278 }
12279 }
12280
12281 local_free (pot);
12282
12283 if (data.quiet == 0) log_info_nn ("");
12284
12285 return (0);
12286 }
12287
12288 if (keyspace == 0)
12289 {
12290 if (hashes_cnt == 0)
12291 {
12292 log_error ("ERROR: No hashes loaded");
12293
12294 return (-1);
12295 }
12296 }
12297
12298 /**
12299 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12300 */
12301
12302 if (data.outfile != NULL)
12303 {
12304 if (data.hashfile != NULL)
12305 {
12306 #ifdef _POSIX
12307 struct stat tmpstat_outfile;
12308 struct stat tmpstat_hashfile;
12309 #endif
12310
12311 #ifdef _WIN
12312 struct stat64 tmpstat_outfile;
12313 struct stat64 tmpstat_hashfile;
12314 #endif
12315
12316 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12317
12318 if (tmp_outfile_fp)
12319 {
12320 #ifdef _POSIX
12321 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12322 #endif
12323
12324 #ifdef _WIN
12325 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12326 #endif
12327
12328 fclose (tmp_outfile_fp);
12329 }
12330
12331 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12332
12333 if (tmp_hashfile_fp)
12334 {
12335 #ifdef _POSIX
12336 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12337 #endif
12338
12339 #ifdef _WIN
12340 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12341 #endif
12342
12343 fclose (tmp_hashfile_fp);
12344 }
12345
12346 if (tmp_outfile_fp && tmp_outfile_fp)
12347 {
12348 tmpstat_outfile.st_mode = 0;
12349 tmpstat_outfile.st_nlink = 0;
12350 tmpstat_outfile.st_uid = 0;
12351 tmpstat_outfile.st_gid = 0;
12352 tmpstat_outfile.st_rdev = 0;
12353 tmpstat_outfile.st_atime = 0;
12354
12355 tmpstat_hashfile.st_mode = 0;
12356 tmpstat_hashfile.st_nlink = 0;
12357 tmpstat_hashfile.st_uid = 0;
12358 tmpstat_hashfile.st_gid = 0;
12359 tmpstat_hashfile.st_rdev = 0;
12360 tmpstat_hashfile.st_atime = 0;
12361
12362 #ifdef _POSIX
12363 tmpstat_outfile.st_blksize = 0;
12364 tmpstat_outfile.st_blocks = 0;
12365
12366 tmpstat_hashfile.st_blksize = 0;
12367 tmpstat_hashfile.st_blocks = 0;
12368 #endif
12369
12370 #ifdef _POSIX
12371 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12372 {
12373 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12374
12375 return (-1);
12376 }
12377 #endif
12378
12379 #ifdef _WIN
12380 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12381 {
12382 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12383
12384 return (-1);
12385 }
12386 #endif
12387 }
12388 }
12389 }
12390
12391 /**
12392 * Remove duplicates
12393 */
12394
12395 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12396
12397 if (isSalted)
12398 {
12399 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12400 }
12401 else
12402 {
12403 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12404 }
12405
12406 uint hashes_cnt_orig = hashes_cnt;
12407
12408 hashes_cnt = 1;
12409
12410 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12411 {
12412 if (isSalted)
12413 {
12414 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12415 {
12416 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12417 }
12418 }
12419 else
12420 {
12421 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12422 }
12423
12424 if (hashes_pos > hashes_cnt)
12425 {
12426 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12427 }
12428
12429 hashes_cnt++;
12430 }
12431
12432 /**
12433 * Potfile removes
12434 */
12435
12436 uint potfile_remove_cracks = 0;
12437
12438 if (potfile_disable == 0)
12439 {
12440 hash_t hash_buf;
12441
12442 hash_buf.digest = mymalloc (dgst_size);
12443 hash_buf.salt = NULL;
12444 hash_buf.esalt = NULL;
12445 hash_buf.hash_info = NULL;
12446 hash_buf.cracked = 0;
12447
12448 if (isSalted)
12449 {
12450 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12451 }
12452
12453 if (esalt_size)
12454 {
12455 hash_buf.esalt = mymalloc (esalt_size);
12456 }
12457
12458 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12459
12460 // no solution for these special hash types (for instane because they use hashfile in output etc)
12461 if ((hash_mode != 5200) &&
12462 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12463 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12464 (hash_mode != 9000))
12465 {
12466 FILE *fp = fopen (potfile, "rb");
12467
12468 if (fp != NULL)
12469 {
12470 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12471
12472 // to be safe work with a copy (because of line_len loop, i etc)
12473 // moved up here because it's easier to handle continue case
12474 // it's just 64kb
12475
12476 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12477
12478 while (!feof (fp))
12479 {
12480 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12481
12482 if (ptr == NULL) break;
12483
12484 int line_len = strlen (line_buf);
12485
12486 if (line_len == 0) continue;
12487
12488 int iter = MAX_CUT_TRIES;
12489
12490 for (int i = line_len - 1; i && iter; i--, line_len--)
12491 {
12492 if (line_buf[i] != ':') continue;
12493
12494 if (isSalted)
12495 {
12496 memset (hash_buf.salt, 0, sizeof (salt_t));
12497 }
12498
12499 hash_t *found = NULL;
12500
12501 if (hash_mode == 6800)
12502 {
12503 if (i < 64) // 64 = 16 * uint in salt_buf[]
12504 {
12505 // manipulate salt_buf
12506 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12507
12508 hash_buf.salt->salt_len = i;
12509
12510 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12511 }
12512 }
12513 else if (hash_mode == 2500)
12514 {
12515 if (i < 64) // 64 = 16 * uint in salt_buf[]
12516 {
12517 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12518 // manipulate salt_buf
12519
12520 memcpy (line_buf_cpy, line_buf, i);
12521
12522 char *mac2_pos = strrchr (line_buf_cpy, ':');
12523
12524 if (mac2_pos == NULL) continue;
12525
12526 mac2_pos[0] = 0;
12527 mac2_pos++;
12528
12529 if (strlen (mac2_pos) != 12) continue;
12530
12531 char *mac1_pos = strrchr (line_buf_cpy, ':');
12532
12533 if (mac1_pos == NULL) continue;
12534
12535 mac1_pos[0] = 0;
12536 mac1_pos++;
12537
12538 if (strlen (mac1_pos) != 12) continue;
12539
12540 uint essid_length = mac1_pos - line_buf_cpy - 1;
12541
12542 // here we need the ESSID
12543 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12544
12545 hash_buf.salt->salt_len = essid_length;
12546
12547 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12548
12549 if (found)
12550 {
12551 wpa_t *wpa = (wpa_t *) found->esalt;
12552
12553 // compare hex string(s) vs binary MAC address(es)
12554
12555 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12556 {
12557 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12558 {
12559 found = NULL;
12560
12561 break;
12562 }
12563 }
12564
12565 // early skip ;)
12566 if (!found) continue;
12567
12568 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12569 {
12570 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12571 {
12572 found = NULL;
12573
12574 break;
12575 }
12576 }
12577 }
12578 }
12579 }
12580 else
12581 {
12582 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12583
12584 if (parser_status == PARSER_OK)
12585 {
12586 if (isSalted)
12587 {
12588 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12589 }
12590 else
12591 {
12592 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12593 }
12594 }
12595 }
12596
12597 if (found == NULL) continue;
12598
12599 if (!found->cracked) potfile_remove_cracks++;
12600
12601 found->cracked = 1;
12602
12603 if (found) break;
12604
12605 iter--;
12606 }
12607 }
12608
12609 myfree (line_buf_cpy);
12610
12611 myfree (line_buf);
12612
12613 fclose (fp);
12614 }
12615 }
12616
12617 if (esalt_size)
12618 {
12619 local_free (hash_buf.esalt);
12620 }
12621
12622 if (isSalted)
12623 {
12624 local_free (hash_buf.salt);
12625 }
12626
12627 local_free (hash_buf.digest);
12628 }
12629
12630 /**
12631 * Now generate all the buffers required for later
12632 */
12633
12634 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12635
12636 salt_t *salts_buf_new = NULL;
12637 void *esalts_buf_new = NULL;
12638
12639 if (isSalted)
12640 {
12641 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12642
12643 if (esalt_size)
12644 {
12645 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12646 }
12647 }
12648 else
12649 {
12650 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12651 }
12652
12653 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12654
12655 uint digests_cnt = hashes_cnt;
12656 uint digests_done = 0;
12657
12658 size_t size_digests = digests_cnt * dgst_size;
12659 size_t size_shown = digests_cnt * sizeof (uint);
12660
12661 uint *digests_shown = (uint *) mymalloc (size_shown);
12662 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12663
12664 uint salts_cnt = 0;
12665 uint salts_done = 0;
12666
12667 hashinfo_t **hash_info = NULL;
12668
12669 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12670 {
12671 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12672
12673 if (username && (remove || show))
12674 {
12675 uint user_pos;
12676
12677 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12678 {
12679 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12680
12681 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12682 }
12683 }
12684 }
12685
12686 uint *salts_shown = (uint *) mymalloc (size_shown);
12687
12688 salt_t *salt_buf;
12689
12690 {
12691 // copied from inner loop
12692
12693 salt_buf = &salts_buf_new[salts_cnt];
12694
12695 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12696
12697 if (esalt_size)
12698 {
12699 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12700 }
12701
12702 salt_buf->digests_cnt = 0;
12703 salt_buf->digests_done = 0;
12704 salt_buf->digests_offset = 0;
12705
12706 salts_cnt++;
12707 }
12708
12709 if (hashes_buf[0].cracked == 1)
12710 {
12711 digests_shown[0] = 1;
12712
12713 digests_done++;
12714
12715 salt_buf->digests_done++;
12716 }
12717
12718 salt_buf->digests_cnt++;
12719
12720 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12721
12722 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12723 {
12724 hash_info[0] = hashes_buf[0].hash_info;
12725 }
12726
12727 // copy from inner loop
12728
12729 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12730 {
12731 if (isSalted)
12732 {
12733 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12734 {
12735 salt_buf = &salts_buf_new[salts_cnt];
12736
12737 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12738
12739 if (esalt_size)
12740 {
12741 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12742 }
12743
12744 salt_buf->digests_cnt = 0;
12745 salt_buf->digests_done = 0;
12746 salt_buf->digests_offset = hashes_pos;
12747
12748 salts_cnt++;
12749 }
12750 }
12751
12752 if (hashes_buf[hashes_pos].cracked == 1)
12753 {
12754 digests_shown[hashes_pos] = 1;
12755
12756 digests_done++;
12757
12758 salt_buf->digests_done++;
12759 }
12760
12761 salt_buf->digests_cnt++;
12762
12763 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12764
12765 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12766 {
12767 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12768 }
12769 }
12770
12771 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12772 {
12773 salt_t *salt_buf = &salts_buf_new[salt_pos];
12774
12775 if (salt_buf->digests_done == salt_buf->digests_cnt)
12776 {
12777 salts_shown[salt_pos] = 1;
12778
12779 salts_done++;
12780 }
12781
12782 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12783 }
12784
12785 local_free (digests_buf);
12786 local_free (salts_buf);
12787 local_free (esalts_buf);
12788
12789 digests_buf = digests_buf_new;
12790 salts_buf = salts_buf_new;
12791 esalts_buf = esalts_buf_new;
12792
12793 local_free (hashes_buf);
12794
12795 /**
12796 * special modification not set from parser
12797 */
12798
12799 switch (hash_mode)
12800 {
12801 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12802 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12803 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12804 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12805 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12806 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12807 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12808 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12809 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12810 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12811 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12812 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12813 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12814 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12815 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12816 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12817 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12818 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12819 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12820 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12821 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12822 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12823 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12824 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12825 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12826 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12827 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12828 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12829 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12830 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12831 }
12832
12833 if (truecrypt_keyfiles)
12834 {
12835 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12836
12837 char *keyfiles = strdup (truecrypt_keyfiles);
12838
12839 char *keyfile = strtok (keyfiles, ",");
12840
12841 do
12842 {
12843 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12844
12845 } while ((keyfile = strtok (NULL, ",")) != NULL);
12846
12847 free (keyfiles);
12848 }
12849
12850 if (veracrypt_keyfiles)
12851 {
12852 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12853
12854 char *keyfiles = strdup (veracrypt_keyfiles);
12855
12856 char *keyfile = strtok (keyfiles, ",");
12857
12858 do
12859 {
12860 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12861
12862 } while ((keyfile = strtok (NULL, ",")) != NULL);
12863
12864 free (keyfiles);
12865 }
12866
12867 data.digests_cnt = digests_cnt;
12868 data.digests_done = digests_done;
12869 data.digests_buf = digests_buf;
12870 data.digests_shown = digests_shown;
12871 data.digests_shown_tmp = digests_shown_tmp;
12872
12873 data.salts_cnt = salts_cnt;
12874 data.salts_done = salts_done;
12875 data.salts_buf = salts_buf;
12876 data.salts_shown = salts_shown;
12877
12878 data.esalts_buf = esalts_buf;
12879 data.hash_info = hash_info;
12880
12881 /**
12882 * Automatic Optimizers
12883 */
12884
12885 if (salts_cnt == 1)
12886 opti_type |= OPTI_TYPE_SINGLE_SALT;
12887
12888 if (digests_cnt == 1)
12889 opti_type |= OPTI_TYPE_SINGLE_HASH;
12890
12891 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12892 opti_type |= OPTI_TYPE_NOT_ITERATED;
12893
12894 if (attack_mode == ATTACK_MODE_BF)
12895 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12896
12897 data.opti_type = opti_type;
12898
12899 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12900 {
12901 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12902 {
12903 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12904 {
12905 if (opts_type & OPTS_TYPE_ST_ADD80)
12906 {
12907 opts_type &= ~OPTS_TYPE_ST_ADD80;
12908 opts_type |= OPTS_TYPE_PT_ADD80;
12909 }
12910
12911 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12912 {
12913 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12914 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12915 }
12916
12917 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12918 {
12919 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12920 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12921 }
12922 }
12923 }
12924 }
12925
12926 /**
12927 * Some algorithm, like descrypt, can benefit from JIT compilation
12928 */
12929
12930 int force_jit_compilation = -1;
12931
12932 if (hash_mode == 8900)
12933 {
12934 force_jit_compilation = 8900;
12935 }
12936 else if (hash_mode == 9300)
12937 {
12938 force_jit_compilation = 8900;
12939 }
12940 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12941 {
12942 force_jit_compilation = 1500;
12943 }
12944
12945 /**
12946 * generate bitmap tables
12947 */
12948
12949 const uint bitmap_shift1 = 5;
12950 const uint bitmap_shift2 = 13;
12951
12952 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12953
12954 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12955 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12956 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12957 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12958 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12959 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12960 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12961 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12962
12963 uint bitmap_bits;
12964 uint bitmap_nums;
12965 uint bitmap_mask;
12966 uint bitmap_size;
12967
12968 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12969 {
12970 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12971
12972 bitmap_nums = 1 << bitmap_bits;
12973
12974 bitmap_mask = bitmap_nums - 1;
12975
12976 bitmap_size = bitmap_nums * sizeof (uint);
12977
12978 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12979
12980 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;
12981 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;
12982
12983 break;
12984 }
12985
12986 bitmap_nums = 1 << bitmap_bits;
12987
12988 bitmap_mask = bitmap_nums - 1;
12989
12990 bitmap_size = bitmap_nums * sizeof (uint);
12991
12992 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);
12993 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);
12994
12995 /**
12996 * prepare quick rule
12997 */
12998
12999 data.rule_buf_l = rule_buf_l;
13000 data.rule_buf_r = rule_buf_r;
13001
13002 int rule_len_l = (int) strlen (rule_buf_l);
13003 int rule_len_r = (int) strlen (rule_buf_r);
13004
13005 data.rule_len_l = rule_len_l;
13006 data.rule_len_r = rule_len_r;
13007
13008 /**
13009 * load rules
13010 */
13011
13012 uint *all_kernel_rules_cnt = NULL;
13013
13014 kernel_rule_t **all_kernel_rules_buf = NULL;
13015
13016 if (rp_files_cnt)
13017 {
13018 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13019
13020 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13021 }
13022
13023 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13024
13025 int rule_len = 0;
13026
13027 for (uint i = 0; i < rp_files_cnt; i++)
13028 {
13029 uint kernel_rules_avail = 0;
13030
13031 uint kernel_rules_cnt = 0;
13032
13033 kernel_rule_t *kernel_rules_buf = NULL;
13034
13035 char *rp_file = rp_files[i];
13036
13037 char in[BLOCK_SIZE] = { 0 };
13038 char out[BLOCK_SIZE] = { 0 };
13039
13040 FILE *fp = NULL;
13041
13042 uint rule_line = 0;
13043
13044 if ((fp = fopen (rp_file, "rb")) == NULL)
13045 {
13046 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13047
13048 return (-1);
13049 }
13050
13051 while (!feof (fp))
13052 {
13053 memset (rule_buf, 0, HCBUFSIZ);
13054
13055 rule_len = fgetl (fp, rule_buf);
13056
13057 rule_line++;
13058
13059 if (rule_len == 0) continue;
13060
13061 if (rule_buf[0] == '#') continue;
13062
13063 if (kernel_rules_avail == kernel_rules_cnt)
13064 {
13065 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13066
13067 kernel_rules_avail += INCR_RULES;
13068 }
13069
13070 memset (in, 0, BLOCK_SIZE);
13071 memset (out, 0, BLOCK_SIZE);
13072
13073 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13074
13075 if (result == -1)
13076 {
13077 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13078
13079 continue;
13080 }
13081
13082 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13083 {
13084 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13085
13086 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13087
13088 continue;
13089 }
13090
13091 /* its so slow
13092 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13093 {
13094 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13095
13096 continue;
13097 }
13098 */
13099
13100 kernel_rules_cnt++;
13101 }
13102
13103 fclose (fp);
13104
13105 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13106
13107 all_kernel_rules_buf[i] = kernel_rules_buf;
13108 }
13109
13110 /**
13111 * merge rules or automatic rule generator
13112 */
13113
13114 uint kernel_rules_cnt = 0;
13115
13116 kernel_rule_t *kernel_rules_buf = NULL;
13117
13118 if (attack_mode == ATTACK_MODE_STRAIGHT)
13119 {
13120 if (rp_files_cnt)
13121 {
13122 kernel_rules_cnt = 1;
13123
13124 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13125
13126 repeats[0] = kernel_rules_cnt;
13127
13128 for (uint i = 0; i < rp_files_cnt; i++)
13129 {
13130 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13131
13132 repeats[i + 1] = kernel_rules_cnt;
13133 }
13134
13135 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13136
13137 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13138
13139 for (uint i = 0; i < kernel_rules_cnt; i++)
13140 {
13141 uint out_pos = 0;
13142
13143 kernel_rule_t *out = &kernel_rules_buf[i];
13144
13145 for (uint j = 0; j < rp_files_cnt; j++)
13146 {
13147 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13148 uint in_pos;
13149
13150 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13151
13152 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13153 {
13154 if (out_pos == RULES_MAX - 1)
13155 {
13156 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13157
13158 break;
13159 }
13160
13161 out->cmds[out_pos] = in->cmds[in_pos];
13162 }
13163 }
13164 }
13165
13166 local_free (repeats);
13167 }
13168 else if (rp_gen)
13169 {
13170 uint kernel_rules_avail = 0;
13171
13172 while (kernel_rules_cnt < rp_gen)
13173 {
13174 if (kernel_rules_avail == kernel_rules_cnt)
13175 {
13176 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13177
13178 kernel_rules_avail += INCR_RULES;
13179 }
13180
13181 memset (rule_buf, 0, HCBUFSIZ);
13182
13183 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13184
13185 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13186
13187 kernel_rules_cnt++;
13188 }
13189 }
13190 }
13191
13192 myfree (rule_buf);
13193
13194 /**
13195 * generate NOP rules
13196 */
13197
13198 if (kernel_rules_cnt == 0)
13199 {
13200 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13201
13202 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13203
13204 kernel_rules_cnt++;
13205 }
13206
13207 data.kernel_rules_cnt = kernel_rules_cnt;
13208 data.kernel_rules_buf = kernel_rules_buf;
13209
13210 /**
13211 * OpenCL platforms: detect
13212 */
13213
13214 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13215 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13216
13217 cl_uint platforms_cnt = 0;
13218 cl_uint platform_devices_cnt = 0;
13219
13220 if (keyspace == 0)
13221 {
13222 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13223
13224 if (platforms_cnt == 0)
13225 {
13226 log_info ("");
13227 log_info ("ATTENTION! No OpenCL compatible platform found");
13228 log_info ("");
13229 log_info ("You're probably missing the OpenCL runtime installation");
13230 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13231 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13232 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13233 log_info ("");
13234
13235 return (-1);
13236 }
13237
13238 if (opencl_platforms_filter != (uint) -1)
13239 {
13240 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13241
13242 if (opencl_platforms_filter > platform_cnt_mask)
13243 {
13244 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13245
13246 return (-1);
13247 }
13248 }
13249 }
13250
13251 /**
13252 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13253 */
13254
13255 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13256 {
13257 cl_platform_id platform = platforms[platform_id];
13258
13259 char platform_vendor[INFOSZ] = { 0 };
13260
13261 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13262
13263 #ifdef HAVE_HWMON
13264 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13265 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13266 {
13267 // make sure that we do not directly control the fan for NVidia
13268
13269 gpu_temp_retain = 0;
13270
13271 data.gpu_temp_retain = gpu_temp_retain;
13272 }
13273 #endif // HAVE_NVML || HAVE_NVAPI
13274 #endif
13275 }
13276
13277 /**
13278 * OpenCL device types:
13279 * 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.
13280 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13281 */
13282
13283 if (opencl_device_types == NULL)
13284 {
13285 cl_device_type device_types_all = 0;
13286
13287 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13288 {
13289 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13290
13291 cl_platform_id platform = platforms[platform_id];
13292
13293 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13294
13295 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13296 {
13297 cl_device_id device = platform_devices[platform_devices_id];
13298
13299 cl_device_type device_type;
13300
13301 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13302
13303 device_types_all |= device_type;
13304 }
13305 }
13306
13307 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13308 {
13309 device_types_filter |= CL_DEVICE_TYPE_CPU;
13310 }
13311 }
13312
13313 /**
13314 * OpenCL devices: simply push all devices from all platforms into the same device array
13315 */
13316
13317 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13318
13319 data.devices_param = devices_param;
13320
13321 uint devices_cnt = 0;
13322
13323 uint devices_active = 0;
13324
13325 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13326 {
13327 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13328
13329 cl_platform_id platform = platforms[platform_id];
13330
13331 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13332
13333 char platform_vendor[INFOSZ] = { 0 };
13334
13335 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13336
13337 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13338 // this causes trouble with vendor id based macros
13339 // we'll assign generic to those without special optimization available
13340
13341 cl_uint platform_vendor_id = 0;
13342
13343 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13344 {
13345 platform_vendor_id = VENDOR_ID_AMD;
13346 }
13347 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13348 {
13349 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13350 }
13351 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13352 {
13353 platform_vendor_id = VENDOR_ID_APPLE;
13354 }
13355 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13356 {
13357 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13358 }
13359 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13360 {
13361 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13362 }
13363 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13364 {
13365 platform_vendor_id = VENDOR_ID_MESA;
13366 }
13367 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13368 {
13369 platform_vendor_id = VENDOR_ID_NV;
13370 }
13371 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13372 {
13373 platform_vendor_id = VENDOR_ID_POCL;
13374 }
13375 else
13376 {
13377 platform_vendor_id = VENDOR_ID_GENERIC;
13378 }
13379
13380 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13381 {
13382 size_t param_value_size = 0;
13383
13384 const uint device_id = devices_cnt;
13385
13386 hc_device_param_t *device_param = &data.devices_param[device_id];
13387
13388 device_param->platform_vendor_id = platform_vendor_id;
13389
13390 device_param->device = platform_devices[platform_devices_id];
13391
13392 device_param->device_id = device_id;
13393
13394 device_param->platform_devices_id = platform_devices_id;
13395
13396 // device_type
13397
13398 cl_device_type device_type;
13399
13400 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13401
13402 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13403
13404 device_param->device_type = device_type;
13405
13406 // device_name
13407
13408 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13409
13410 char *device_name = (char *) mymalloc (param_value_size);
13411
13412 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13413
13414 device_param->device_name = device_name;
13415
13416 // device_vendor
13417
13418 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13419
13420 char *device_vendor = (char *) mymalloc (param_value_size);
13421
13422 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13423
13424 device_param->device_vendor = device_vendor;
13425
13426 cl_uint device_vendor_id = 0;
13427
13428 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13429 {
13430 device_vendor_id = VENDOR_ID_AMD;
13431 }
13432 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13433 {
13434 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13435 }
13436 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13437 {
13438 device_vendor_id = VENDOR_ID_APPLE;
13439 }
13440 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13441 {
13442 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13443 }
13444 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13445 {
13446 device_vendor_id = VENDOR_ID_INTEL_SDK;
13447 }
13448 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13449 {
13450 device_vendor_id = VENDOR_ID_MESA;
13451 }
13452 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13453 {
13454 device_vendor_id = VENDOR_ID_NV;
13455 }
13456 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13457 {
13458 device_vendor_id = VENDOR_ID_POCL;
13459 }
13460 else
13461 {
13462 device_vendor_id = VENDOR_ID_GENERIC;
13463 }
13464
13465 device_param->device_vendor_id = device_vendor_id;
13466
13467 // tuning db
13468
13469 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13470
13471 // device_version
13472
13473 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13474
13475 char *device_version = (char *) mymalloc (param_value_size);
13476
13477 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13478
13479 device_param->device_version = device_version;
13480
13481 // device_opencl_version
13482
13483 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13484
13485 char *device_opencl_version = (char *) mymalloc (param_value_size);
13486
13487 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13488
13489 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13490
13491 myfree (device_opencl_version);
13492
13493 // vector_width
13494
13495 cl_uint vector_width;
13496
13497 if (opencl_vector_width_chgd == 0)
13498 {
13499 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13500 {
13501 if (opti_type & OPTI_TYPE_USES_BITS_64)
13502 {
13503 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13504 }
13505 else
13506 {
13507 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13508 }
13509 }
13510 else
13511 {
13512 vector_width = (cl_uint) tuningdb_entry->vector_width;
13513 }
13514 }
13515 else
13516 {
13517 vector_width = opencl_vector_width;
13518 }
13519
13520 if (vector_width > 16) vector_width = 16;
13521
13522 device_param->vector_width = vector_width;
13523
13524 // max_compute_units
13525
13526 cl_uint device_processors;
13527
13528 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13529
13530 device_param->device_processors = device_processors;
13531
13532 // device_maxmem_alloc
13533 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13534
13535 cl_ulong device_maxmem_alloc;
13536
13537 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13538
13539 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13540
13541 // device_global_mem
13542
13543 cl_ulong device_global_mem;
13544
13545 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13546
13547 device_param->device_global_mem = device_global_mem;
13548
13549 // max_work_group_size
13550
13551 size_t device_maxworkgroup_size;
13552
13553 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13554
13555 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13556
13557 // max_clock_frequency
13558
13559 cl_uint device_maxclock_frequency;
13560
13561 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13562
13563 device_param->device_maxclock_frequency = device_maxclock_frequency;
13564
13565 // device_endian_little
13566
13567 cl_bool device_endian_little;
13568
13569 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13570
13571 if (device_endian_little == CL_FALSE)
13572 {
13573 if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13574
13575 device_param->skipped = 1;
13576 }
13577
13578 // device_available
13579
13580 cl_bool device_available;
13581
13582 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13583
13584 if (device_available == CL_FALSE)
13585 {
13586 if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
13587
13588 device_param->skipped = 1;
13589 }
13590
13591 // device_compiler_available
13592
13593 cl_bool device_compiler_available;
13594
13595 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13596
13597 if (device_compiler_available == CL_FALSE)
13598 {
13599 if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13600
13601 device_param->skipped = 1;
13602 }
13603
13604 // device_execution_capabilities
13605
13606 cl_device_exec_capabilities device_execution_capabilities;
13607
13608 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13609
13610 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13611 {
13612 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13613
13614 device_param->skipped = 1;
13615 }
13616
13617 // device_extensions
13618
13619 size_t device_extensions_size;
13620
13621 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13622
13623 char *device_extensions = mymalloc (device_extensions_size + 1);
13624
13625 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13626
13627 if (strstr (device_extensions, "base_atomics") == 0)
13628 {
13629 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13630
13631 device_param->skipped = 1;
13632 }
13633
13634 if (strstr (device_extensions, "byte_addressable_store") == 0)
13635 {
13636 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13637
13638 device_param->skipped = 1;
13639 }
13640
13641 myfree (device_extensions);
13642
13643 // device_local_mem_size
13644
13645 cl_ulong device_local_mem_size;
13646
13647 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13648
13649 if (device_local_mem_size < 32768)
13650 {
13651 if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13652
13653 device_param->skipped = 1;
13654 }
13655
13656 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13657 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13658 // This results in both utilizing it for 50%
13659 // However, Intel has much better SIMD control over their own hardware
13660 // It makes sense to give them full control over their own hardware
13661
13662 if (device_type & CL_DEVICE_TYPE_CPU)
13663 {
13664 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13665 {
13666 if (data.quiet == 0) log_info ("Device #%u: WARNING: not native intel opencl platform", device_id + 1);
13667
13668 device_param->skipped = 1;
13669 }
13670 }
13671
13672 // skipped
13673
13674 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13675 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13676
13677 // driver_version
13678
13679 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13680
13681 char *driver_version = (char *) mymalloc (param_value_size);
13682
13683 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13684
13685 device_param->driver_version = driver_version;
13686
13687 // device_name_chksum
13688
13689 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13690
13691 #if __x86_64__
13692 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);
13693 #else
13694 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);
13695 #endif
13696
13697 uint device_name_digest[4] = { 0 };
13698
13699 md5_64 ((uint *) device_name_chksum, device_name_digest);
13700
13701 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13702
13703 device_param->device_name_chksum = device_name_chksum;
13704
13705 // device_processor_cores
13706
13707 if (device_type & CL_DEVICE_TYPE_CPU)
13708 {
13709 cl_uint device_processor_cores = 1;
13710
13711 device_param->device_processor_cores = device_processor_cores;
13712 }
13713
13714 if (device_type & CL_DEVICE_TYPE_GPU)
13715 {
13716 if (device_vendor_id == VENDOR_ID_AMD)
13717 {
13718 cl_uint device_processor_cores = 0;
13719
13720 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13721
13722 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13723
13724 device_param->device_processor_cores = device_processor_cores;
13725 }
13726 else if (device_vendor_id == VENDOR_ID_NV)
13727 {
13728 cl_uint kernel_exec_timeout = 0;
13729
13730 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13731
13732 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13733
13734 device_param->kernel_exec_timeout = kernel_exec_timeout;
13735
13736 cl_uint device_processor_cores = 0;
13737
13738 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13739
13740 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13741
13742 device_param->device_processor_cores = device_processor_cores;
13743
13744 cl_uint sm_minor = 0;
13745 cl_uint sm_major = 0;
13746
13747 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13748 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13749
13750 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13751 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13752
13753 device_param->sm_minor = sm_minor;
13754 device_param->sm_major = sm_major;
13755 }
13756 else
13757 {
13758 cl_uint device_processor_cores = 1;
13759
13760 device_param->device_processor_cores = device_processor_cores;
13761 }
13762 }
13763
13764 // display results
13765
13766 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13767 {
13768 if (machine_readable == 0)
13769 {
13770 if (device_param->skipped == 0)
13771 {
13772 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13773 device_id + 1,
13774 device_name,
13775 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13776 (unsigned int) (device_global_mem / 1024 / 1024),
13777 (unsigned int) device_processors);
13778 }
13779 else
13780 {
13781 log_info ("Device #%u: %s, skipped",
13782 device_id + 1,
13783 device_name);
13784 }
13785 }
13786 }
13787
13788 // common driver check
13789
13790 if (device_param->skipped == 0)
13791 {
13792 if (device_type & CL_DEVICE_TYPE_GPU)
13793 {
13794 if (platform_vendor_id == VENDOR_ID_AMD)
13795 {
13796 int catalyst_check = (force == 1) ? 0 : 1;
13797
13798 int catalyst_warn = 0;
13799
13800 int catalyst_broken = 0;
13801
13802 if (catalyst_check == 1)
13803 {
13804 catalyst_warn = 1;
13805
13806 // v14.9 and higher
13807 if (atoi (device_param->driver_version) >= 1573)
13808 {
13809 catalyst_warn = 0;
13810 }
13811
13812 catalyst_check = 0;
13813 }
13814
13815 if (catalyst_broken == 1)
13816 {
13817 log_info ("");
13818 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13819 log_info ("It will pass over cracked hashes and does not report them as cracked");
13820 log_info ("You are STRONGLY encouraged not to use it");
13821 log_info ("You can use --force to override this but do not post error reports if you do so");
13822 log_info ("");
13823
13824 return (-1);
13825 }
13826
13827 if (catalyst_warn == 1)
13828 {
13829 log_info ("");
13830 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13831 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13832 log_info ("See hashcat's homepage for official supported catalyst drivers");
13833 #ifdef _WIN
13834 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13835 #endif
13836 log_info ("You can use --force to override this but do not post error reports if you do so");
13837 log_info ("");
13838
13839 return (-1);
13840 }
13841 }
13842 else if (platform_vendor_id == VENDOR_ID_NV)
13843 {
13844 if (device_param->kernel_exec_timeout != 0)
13845 {
13846 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);
13847 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13848 }
13849 }
13850 }
13851
13852 /* turns out pocl still creates segfaults (because of llvm)
13853 if (device_type & CL_DEVICE_TYPE_CPU)
13854 {
13855 if (platform_vendor_id == VENDOR_ID_AMD)
13856 {
13857 if (force == 0)
13858 {
13859 log_info ("");
13860 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13861 log_info ("You are STRONGLY encouraged not to use it");
13862 log_info ("You can use --force to override this but do not post error reports if you do so");
13863 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13864 log_info ("");
13865
13866 return (-1);
13867 }
13868 }
13869 }
13870 */
13871
13872 /**
13873 * kernel accel and loops tuning db adjustment
13874 */
13875
13876 device_param->kernel_accel_min = 1;
13877 device_param->kernel_accel_max = 1024;
13878
13879 device_param->kernel_loops_min = 1;
13880 device_param->kernel_loops_max = 1024;
13881
13882 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13883
13884 if (tuningdb_entry)
13885 {
13886 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13887 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13888
13889 if (_kernel_accel)
13890 {
13891 device_param->kernel_accel_min = _kernel_accel;
13892 device_param->kernel_accel_max = _kernel_accel;
13893 }
13894
13895 if (_kernel_loops)
13896 {
13897 if (workload_profile == 1)
13898 {
13899 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13900 }
13901 else if (workload_profile == 2)
13902 {
13903 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13904 }
13905
13906 device_param->kernel_loops_min = _kernel_loops;
13907 device_param->kernel_loops_max = _kernel_loops;
13908 }
13909 }
13910
13911 // commandline parameters overwrite tuningdb entries
13912
13913 if (kernel_accel)
13914 {
13915 device_param->kernel_accel_min = kernel_accel;
13916 device_param->kernel_accel_max = kernel_accel;
13917 }
13918
13919 if (kernel_loops)
13920 {
13921 device_param->kernel_loops_min = kernel_loops;
13922 device_param->kernel_loops_max = kernel_loops;
13923 }
13924
13925 /**
13926 * activate device
13927 */
13928
13929 devices_active++;
13930 }
13931
13932 // next please
13933
13934 devices_cnt++;
13935 }
13936 }
13937
13938 if (keyspace == 0 && devices_active == 0)
13939 {
13940 log_error ("ERROR: No devices found/left");
13941
13942 return (-1);
13943 }
13944
13945 // 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)
13946
13947 if (devices_filter != (uint) -1)
13948 {
13949 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13950
13951 if (devices_filter > devices_cnt_mask)
13952 {
13953 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13954
13955 return (-1);
13956 }
13957 }
13958
13959 data.devices_cnt = devices_cnt;
13960
13961 data.devices_active = devices_active;
13962
13963 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13964 {
13965 if (machine_readable == 0)
13966 {
13967 log_info ("");
13968 }
13969 }
13970
13971 /**
13972 * HM devices: init
13973 */
13974
13975 #ifdef HAVE_HWMON
13976 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13977 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0 } };
13978 #endif
13979
13980 #ifdef HAVE_ADL
13981 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0 } };
13982 #endif
13983
13984 if (gpu_temp_disable == 0)
13985 {
13986 #if defined(WIN) && defined(HAVE_NVAPI)
13987 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13988
13989 if (nvapi_init (nvapi) == 0)
13990 data.hm_nv = nvapi;
13991
13992 if (data.hm_nv)
13993 {
13994 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13995 {
13996 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13997
13998 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13999
14000 int tmp_out = 0;
14001
14002 for (int i = 0; i < tmp_in; i++)
14003 {
14004 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14005 }
14006
14007 for (int i = 0; i < tmp_out; i++)
14008 {
14009 NV_GPU_COOLER_SETTINGS pCoolerSettings;
14010
14011 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
14012
14013 if (hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, hm_adapters_nv[i].adapter_index.nv, 0, &pCoolerSettings) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
14014 }
14015 }
14016 }
14017 #endif // WIN && HAVE_NVAPI
14018
14019 #if defined(LINUX) && defined(HAVE_NVML)
14020 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14021
14022 if (nvml_init (nvml) == 0)
14023 data.hm_nv = nvml;
14024
14025 if (data.hm_nv)
14026 {
14027 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
14028 {
14029 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
14030
14031 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14032
14033 int tmp_out = 0;
14034
14035 for (int i = 0; i < tmp_in; i++)
14036 {
14037 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14038 }
14039
14040 for (int i = 0; i < tmp_out; i++)
14041 {
14042 unsigned int speed;
14043
14044 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
14045 }
14046 }
14047 }
14048 #endif // LINUX && HAVE_NVML
14049
14050 data.hm_amd = NULL;
14051
14052 #ifdef HAVE_ADL
14053 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14054
14055 if (adl_init (adl) == 0)
14056 data.hm_amd = adl;
14057
14058 if (data.hm_amd)
14059 {
14060 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14061 {
14062 // total number of adapters
14063
14064 int hm_adapters_num;
14065
14066 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
14067
14068 // adapter info
14069
14070 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
14071
14072 if (lpAdapterInfo == NULL) return (-1);
14073
14074 // get a list (of ids of) valid/usable adapters
14075
14076 int num_adl_adapters = 0;
14077
14078 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14079
14080 if (num_adl_adapters > 0)
14081 {
14082 hc_thread_mutex_lock (mux_adl);
14083
14084 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
14085
14086 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14087
14088 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14089 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14090
14091 hc_thread_mutex_unlock (mux_adl);
14092 }
14093
14094 myfree (valid_adl_device_list);
14095 myfree (lpAdapterInfo);
14096 }
14097 }
14098 #endif // HAVE_ADL
14099
14100 if (data.hm_amd == NULL && data.hm_nv == NULL)
14101 {
14102 gpu_temp_disable = 1;
14103 }
14104 }
14105
14106 /**
14107 * OpenCL devices: allocate buffer for device specific information
14108 */
14109
14110 #ifdef HAVE_HWMON
14111 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14112
14113 #ifdef HAVE_ADL
14114 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14115
14116 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14117 #endif // ADL
14118 #endif
14119
14120 /**
14121 * enable custom signal handler(s)
14122 */
14123
14124 if (benchmark == 0)
14125 {
14126 hc_signal (sigHandler_default);
14127 }
14128 else
14129 {
14130 hc_signal (sigHandler_benchmark);
14131 }
14132
14133 /**
14134 * User-defined GPU temp handling
14135 */
14136
14137 #ifdef HAVE_HWMON
14138 if (gpu_temp_disable == 1)
14139 {
14140 gpu_temp_abort = 0;
14141 gpu_temp_retain = 0;
14142 }
14143
14144 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14145 {
14146 if (gpu_temp_abort < gpu_temp_retain)
14147 {
14148 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14149
14150 return (-1);
14151 }
14152 }
14153
14154 data.gpu_temp_disable = gpu_temp_disable;
14155 data.gpu_temp_abort = gpu_temp_abort;
14156 data.gpu_temp_retain = gpu_temp_retain;
14157 #endif
14158
14159 /**
14160 * inform the user
14161 */
14162
14163 if (data.quiet == 0)
14164 {
14165 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14166
14167 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);
14168
14169 if (attack_mode == ATTACK_MODE_STRAIGHT)
14170 {
14171 log_info ("Rules: %u", kernel_rules_cnt);
14172 }
14173
14174 if (opti_type)
14175 {
14176 log_info ("Applicable Optimizers:");
14177
14178 for (uint i = 0; i < 32; i++)
14179 {
14180 const uint opti_bit = 1u << i;
14181
14182 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14183 }
14184 }
14185
14186 /**
14187 * Watchdog and Temperature balance
14188 */
14189
14190 #ifdef HAVE_HWMON
14191 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
14192 {
14193 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14194 }
14195
14196 if (gpu_temp_abort == 0)
14197 {
14198 log_info ("Watchdog: Temperature abort trigger disabled");
14199 }
14200 else
14201 {
14202 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14203 }
14204
14205 if (gpu_temp_retain == 0)
14206 {
14207 log_info ("Watchdog: Temperature retain trigger disabled");
14208 }
14209 else
14210 {
14211 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14212 }
14213
14214 if (data.quiet == 0) log_info ("");
14215 #endif
14216 }
14217
14218 /**
14219 * HM devices: copy
14220 */
14221
14222 if (gpu_temp_disable == 0)
14223 {
14224 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14225 {
14226 hc_device_param_t *device_param = &data.devices_param[device_id];
14227
14228 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14229
14230 if (device_param->skipped) continue;
14231
14232 const uint platform_devices_id = device_param->platform_devices_id;
14233
14234 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14235 if (device_param->device_vendor_id == VENDOR_ID_NV)
14236 {
14237 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14238 }
14239 #endif
14240
14241 #ifdef HAVE_ADL
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 #endif
14247 }
14248 }
14249
14250 /**
14251 * Temporary fix:
14252 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14253 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14254 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14255 * Driver / ADL bug?
14256 */
14257
14258 #ifdef HAVE_ADL
14259 if (powertune_enable == 1)
14260 {
14261 hc_thread_mutex_lock (mux_adl);
14262
14263 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14264 {
14265 hc_device_param_t *device_param = &data.devices_param[device_id];
14266
14267 if (device_param->skipped) continue;
14268
14269 if (data.hm_device[device_id].od_version == 6)
14270 {
14271 // set powertune value only
14272
14273 int powertune_supported = 0;
14274
14275 int ADL_rc = 0;
14276
14277 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14278 {
14279 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14280
14281 return (-1);
14282 }
14283
14284 if (powertune_supported != 0)
14285 {
14286 // powertune set
14287 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14288
14289 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14290 {
14291 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14292
14293 return (-1);
14294 }
14295
14296 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14297 {
14298 log_error ("ERROR: Failed to set new ADL PowerControl values");
14299
14300 return (-1);
14301 }
14302 }
14303 }
14304 }
14305
14306 hc_thread_mutex_unlock (mux_adl);
14307 }
14308 #endif // HAVE_ADK
14309 #endif // HAVE_HWMON
14310
14311 #ifdef DEBUG
14312 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14313 #endif
14314
14315 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14316
14317 uint kernel_power_all = 0;
14318
14319 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14320 {
14321 /**
14322 * host buffer
14323 */
14324
14325 hc_device_param_t *device_param = &data.devices_param[device_id];
14326
14327 if (device_param->skipped) continue;
14328
14329 /**
14330 * device properties
14331 */
14332
14333 const char *device_name_chksum = device_param->device_name_chksum;
14334 const u32 device_processors = device_param->device_processors;
14335 const u32 device_processor_cores = device_param->device_processor_cores;
14336
14337 /**
14338 * create context for each device
14339 */
14340
14341 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14342
14343 /**
14344 * create command-queue
14345 */
14346
14347 // not supported with NV
14348 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14349
14350 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14351
14352 /**
14353 * kernel threads: some algorithms need a fixed kernel-threads count
14354 * because of shared memory usage or bitslice
14355 * there needs to be some upper limit, otherwise there's too much overhead
14356 */
14357
14358 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14359
14360 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14361 {
14362 kernel_threads = KERNEL_THREADS_MAX_CPU;
14363 }
14364
14365 if (hash_mode == 1500) kernel_threads = 64; // DES
14366 if (hash_mode == 3000) kernel_threads = 64; // DES
14367 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14368 if (hash_mode == 7500) kernel_threads = 64; // RC4
14369 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14370 if (hash_mode == 9700) kernel_threads = 64; // RC4
14371 if (hash_mode == 9710) kernel_threads = 64; // RC4
14372 if (hash_mode == 9800) kernel_threads = 64; // RC4
14373 if (hash_mode == 9810) kernel_threads = 64; // RC4
14374 if (hash_mode == 10400) kernel_threads = 64; // RC4
14375 if (hash_mode == 10410) kernel_threads = 64; // RC4
14376 if (hash_mode == 10500) kernel_threads = 64; // RC4
14377 if (hash_mode == 13100) kernel_threads = 64; // RC4
14378
14379 /**
14380 * create input buffers on device : calculate size of fixed memory buffers
14381 */
14382
14383 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14384 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14385
14386 device_param->size_root_css = size_root_css;
14387 device_param->size_markov_css = size_markov_css;
14388
14389 size_t size_results = sizeof (uint);
14390
14391 device_param->size_results = size_results;
14392
14393 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14394 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14395
14396 size_t size_plains = digests_cnt * sizeof (plain_t);
14397 size_t size_salts = salts_cnt * sizeof (salt_t);
14398 size_t size_esalts = salts_cnt * esalt_size;
14399
14400 device_param->size_plains = size_plains;
14401 device_param->size_digests = size_digests;
14402 device_param->size_shown = size_shown;
14403 device_param->size_salts = size_salts;
14404
14405 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14406 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14407 size_t size_tm = 32 * sizeof (bs_word_t);
14408
14409 // scryptV stuff
14410
14411 size_t size_scryptV = 1;
14412
14413 if ((hash_mode == 8900) || (hash_mode == 9300))
14414 {
14415 uint tmto_start = 0;
14416 uint tmto_stop = 10;
14417
14418 if (scrypt_tmto)
14419 {
14420 tmto_start = scrypt_tmto;
14421 }
14422 else
14423 {
14424 // in case the user did not specify the tmto manually
14425 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14426 // but set the lower end only in case the user has a device with too less memory
14427
14428 if (hash_mode == 8900)
14429 {
14430 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14431 {
14432 tmto_start = 1;
14433 }
14434 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14435 {
14436 tmto_start = 2;
14437 }
14438 }
14439 else if (hash_mode == 9300)
14440 {
14441 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14442 {
14443 tmto_start = 2;
14444 }
14445 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14446 {
14447 tmto_start = 2;
14448 }
14449 }
14450 }
14451
14452 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14453 {
14454 // TODO: in theory the following calculation needs to be done per salt, not global
14455 // we assume all hashes have the same scrypt settings
14456
14457 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14458
14459 size_scryptV /= 1 << tmto;
14460
14461 size_scryptV *= device_processors * device_processor_cores;
14462
14463 if (size_scryptV > device_param->device_maxmem_alloc)
14464 {
14465 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14466
14467 continue;
14468 }
14469
14470 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14471 {
14472 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14473 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14474 }
14475
14476 break;
14477 }
14478
14479 if (data.salts_buf[0].scrypt_phy == 0)
14480 {
14481 log_error ("ERROR: can't allocate enough device memory");
14482
14483 return -1;
14484 }
14485
14486 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14487 }
14488
14489 /**
14490 * some algorithms need a fixed kernel-loops count
14491 */
14492
14493 if (hash_mode == 1500)
14494 {
14495 const u32 kernel_loops_fixed = 1024;
14496
14497 device_param->kernel_loops_min = kernel_loops_fixed;
14498 device_param->kernel_loops_max = kernel_loops_fixed;
14499 }
14500
14501 if (hash_mode == 3000)
14502 {
14503 const u32 kernel_loops_fixed = 1024;
14504
14505 device_param->kernel_loops_min = kernel_loops_fixed;
14506 device_param->kernel_loops_max = kernel_loops_fixed;
14507 }
14508
14509 if (hash_mode == 8900)
14510 {
14511 const u32 kernel_loops_fixed = 1;
14512
14513 device_param->kernel_loops_min = kernel_loops_fixed;
14514 device_param->kernel_loops_max = kernel_loops_fixed;
14515 }
14516
14517 if (hash_mode == 9300)
14518 {
14519 const u32 kernel_loops_fixed = 1;
14520
14521 device_param->kernel_loops_min = kernel_loops_fixed;
14522 device_param->kernel_loops_max = kernel_loops_fixed;
14523 }
14524
14525 if (hash_mode == 12500)
14526 {
14527 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14528
14529 device_param->kernel_loops_min = kernel_loops_fixed;
14530 device_param->kernel_loops_max = kernel_loops_fixed;
14531 }
14532
14533 /**
14534 * some algorithms have a maximum kernel-loops count
14535 */
14536
14537 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14538 {
14539 u32 innerloop_cnt = 0;
14540
14541 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14542 {
14543 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14544 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14545 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14546 }
14547 else
14548 {
14549 innerloop_cnt = data.salts_buf[0].salt_iter;
14550 }
14551
14552 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14553 (innerloop_cnt <= device_param->kernel_loops_max))
14554 {
14555 device_param->kernel_loops_max = innerloop_cnt;
14556 }
14557 }
14558
14559 u32 kernel_accel_min = device_param->kernel_accel_min;
14560 u32 kernel_accel_max = device_param->kernel_accel_max;
14561
14562 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14563
14564 size_t size_pws = 4;
14565 size_t size_tmps = 4;
14566 size_t size_hooks = 4;
14567
14568 while (kernel_accel_max >= kernel_accel_min)
14569 {
14570 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14571
14572 // size_pws
14573
14574 size_pws = kernel_power_max * sizeof (pw_t);
14575
14576 // size_tmps
14577
14578 switch (hash_mode)
14579 {
14580 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14581 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14582 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14583 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14584 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14585 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14586 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14587 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14588 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14589 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14590 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14591 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14592 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14593 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14594 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14595 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14596 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14597 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14598 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14599 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14600 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14601 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14602 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14603 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14604 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14605 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14606 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14607 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14608 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14609 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14610 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14611 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14612 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14613 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14614 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14615 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14616 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14617 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14618 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14619 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14620 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14621 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14622 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14623 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14624 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14625 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14626 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14627 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14628 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14629 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14630 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14631 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14632 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14633 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14634 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14635 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14636 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14637 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14638 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14639 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14640 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14641 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14642 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14643 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14644 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14645 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14646 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14647 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14648 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14649 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14650 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14651 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14652 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14653 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14654 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14655 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14656 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14657 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14658 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14659 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14660 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14661 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14662 };
14663
14664 // size_hooks
14665
14666 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14667 {
14668 // none yet
14669 }
14670
14671 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14672 // if not, decrease amplifier and try again
14673
14674 int skip = 0;
14675
14676 const u64 size_total
14677 = bitmap_size
14678 + bitmap_size
14679 + bitmap_size
14680 + bitmap_size
14681 + bitmap_size
14682 + bitmap_size
14683 + bitmap_size
14684 + bitmap_size
14685 + size_bfs
14686 + size_combs
14687 + size_digests
14688 + size_esalts
14689 + size_hooks
14690 + size_markov_css
14691 + size_plains
14692 + size_pws
14693 + size_pws // not a bug
14694 + size_results
14695 + size_root_css
14696 + size_rules
14697 + size_rules_c
14698 + size_salts
14699 + size_scryptV
14700 + size_shown
14701 + size_tm
14702 + size_tmps;
14703
14704 // Don't ask me, ask AMD!
14705
14706 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14707 if (size_total > device_param->device_global_mem) skip = 1;
14708
14709 if (skip == 1)
14710 {
14711 kernel_accel_max--;
14712
14713 continue;
14714 }
14715
14716 break;
14717 }
14718
14719 /*
14720 if (kernel_accel_max == 0)
14721 {
14722 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14723
14724 return -1;
14725 }
14726 */
14727
14728 device_param->kernel_accel_min = kernel_accel_min;
14729 device_param->kernel_accel_max = kernel_accel_max;
14730
14731 /*
14732 if (kernel_accel_max < kernel_accel)
14733 {
14734 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14735
14736 device_param->kernel_accel = kernel_accel_max;
14737 }
14738 */
14739
14740 device_param->size_bfs = size_bfs;
14741 device_param->size_combs = size_combs;
14742 device_param->size_rules = size_rules;
14743 device_param->size_rules_c = size_rules_c;
14744 device_param->size_pws = size_pws;
14745 device_param->size_tmps = size_tmps;
14746 device_param->size_hooks = size_hooks;
14747
14748 // do not confuse kernel_accel_max with kernel_accel here
14749
14750 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14751
14752 device_param->kernel_threads = kernel_threads;
14753 device_param->kernel_power_user = kernel_power;
14754
14755 kernel_power_all += kernel_power;
14756
14757 /**
14758 * default building options
14759 */
14760
14761 char build_opts[1024] = { 0 };
14762
14763 // we don't have sm_* on vendors not NV but it doesn't matter
14764
14765 #if _WIN
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 #else
14768 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s/OpenCL/\" -I '%s/OpenCL/' -I %s/OpenCL/ -I\"%s/OpenCL/\" -I'%s/OpenCL/' -I%s/OpenCL/", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
14769 #endif
14770
14771 char build_opts_new[1024] = { 0 };
14772
14773 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);
14774
14775 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14776
14777 /*
14778 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14779 {
14780 // we do vectorizing much better than the auto-vectorizer
14781
14782 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14783
14784 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14785 }
14786 */
14787
14788 #ifdef DEBUG
14789 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14790 #endif
14791
14792 /**
14793 * main kernel
14794 */
14795
14796 {
14797 /**
14798 * kernel source filename
14799 */
14800
14801 char source_file[256] = { 0 };
14802
14803 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14804
14805 struct stat sst;
14806
14807 if (stat (source_file, &sst) == -1)
14808 {
14809 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14810
14811 return -1;
14812 }
14813
14814 /**
14815 * kernel cached filename
14816 */
14817
14818 char cached_file[256] = { 0 };
14819
14820 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14821
14822 int cached = 1;
14823
14824 struct stat cst;
14825
14826 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14827 {
14828 cached = 0;
14829 }
14830
14831 /**
14832 * kernel compile or load
14833 */
14834
14835 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14836
14837 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14838
14839 if (force_jit_compilation == -1)
14840 {
14841 if (cached == 0)
14842 {
14843 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14844
14845 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14846
14847 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14848
14849 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14850
14851 #ifdef DEBUG
14852 size_t build_log_size = 0;
14853
14854 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14855
14856 if (build_log_size > 1)
14857 {
14858 char *build_log = (char *) malloc (build_log_size + 1);
14859
14860 memset (build_log, 0, build_log_size + 1);
14861
14862 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14863
14864 puts (build_log);
14865
14866 free (build_log);
14867 }
14868 #endif
14869
14870 if (rc != 0)
14871 {
14872 device_param->skipped = true;
14873
14874 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14875
14876 continue;
14877 }
14878
14879 size_t binary_size;
14880
14881 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14882
14883 u8 *binary = (u8 *) mymalloc (binary_size);
14884
14885 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14886
14887 writeProgramBin (cached_file, binary, binary_size);
14888
14889 local_free (binary);
14890 }
14891 else
14892 {
14893 #ifdef DEBUG
14894 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14895 #endif
14896
14897 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14898
14899 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14900
14901 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14902 }
14903 }
14904 else
14905 {
14906 #ifdef DEBUG
14907 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14908 #endif
14909
14910 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14911
14912 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14913
14914 char build_opts_update[1024] = { 0 };
14915
14916 if (force_jit_compilation == 1500)
14917 {
14918 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14919 }
14920 else if (force_jit_compilation == 8900)
14921 {
14922 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);
14923 }
14924 else
14925 {
14926 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14927 }
14928
14929 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14930
14931 #ifdef DEBUG
14932 size_t build_log_size = 0;
14933
14934 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14935
14936 if (build_log_size > 1)
14937 {
14938 char *build_log = (char *) malloc (build_log_size + 1);
14939
14940 memset (build_log, 0, build_log_size + 1);
14941
14942 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14943
14944 puts (build_log);
14945
14946 free (build_log);
14947 }
14948 #endif
14949
14950 if (rc != 0)
14951 {
14952 device_param->skipped = true;
14953
14954 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14955 }
14956 }
14957
14958 local_free (kernel_lengths);
14959 local_free (kernel_sources[0]);
14960 local_free (kernel_sources);
14961 }
14962
14963 /**
14964 * word generator kernel
14965 */
14966
14967 if (attack_mode != ATTACK_MODE_STRAIGHT)
14968 {
14969 /**
14970 * kernel mp source filename
14971 */
14972
14973 char source_file[256] = { 0 };
14974
14975 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14976
14977 struct stat sst;
14978
14979 if (stat (source_file, &sst) == -1)
14980 {
14981 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14982
14983 return -1;
14984 }
14985
14986 /**
14987 * kernel mp cached filename
14988 */
14989
14990 char cached_file[256] = { 0 };
14991
14992 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14993
14994 int cached = 1;
14995
14996 struct stat cst;
14997
14998 if (stat (cached_file, &cst) == -1)
14999 {
15000 cached = 0;
15001 }
15002
15003 /**
15004 * kernel compile or load
15005 */
15006
15007 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15008
15009 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15010
15011 if (cached == 0)
15012 {
15013 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15014 if (quiet == 0) log_info ("");
15015
15016 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15017
15018 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15019
15020 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15021
15022 if (rc != 0)
15023 {
15024 device_param->skipped = true;
15025
15026 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15027
15028 continue;
15029 }
15030
15031 size_t binary_size;
15032
15033 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15034
15035 u8 *binary = (u8 *) mymalloc (binary_size);
15036
15037 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15038
15039 writeProgramBin (cached_file, binary, binary_size);
15040
15041 local_free (binary);
15042 }
15043 else
15044 {
15045 #ifdef DEBUG
15046 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15047 #endif
15048
15049 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15050
15051 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15052
15053 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15054 }
15055
15056 local_free (kernel_lengths);
15057 local_free (kernel_sources[0]);
15058 local_free (kernel_sources);
15059 }
15060
15061 /**
15062 * amplifier kernel
15063 */
15064
15065 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15066 {
15067
15068 }
15069 else
15070 {
15071 /**
15072 * kernel amp source filename
15073 */
15074
15075 char source_file[256] = { 0 };
15076
15077 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15078
15079 struct stat sst;
15080
15081 if (stat (source_file, &sst) == -1)
15082 {
15083 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15084
15085 return -1;
15086 }
15087
15088 /**
15089 * kernel amp cached filename
15090 */
15091
15092 char cached_file[256] = { 0 };
15093
15094 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15095
15096 int cached = 1;
15097
15098 struct stat cst;
15099
15100 if (stat (cached_file, &cst) == -1)
15101 {
15102 cached = 0;
15103 }
15104
15105 /**
15106 * kernel compile or load
15107 */
15108
15109 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15110
15111 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15112
15113 if (cached == 0)
15114 {
15115 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15116 if (quiet == 0) log_info ("");
15117
15118 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15119
15120 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15121
15122 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15123
15124 if (rc != 0)
15125 {
15126 device_param->skipped = true;
15127
15128 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15129
15130 continue;
15131 }
15132
15133 size_t binary_size;
15134
15135 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15136
15137 u8 *binary = (u8 *) mymalloc (binary_size);
15138
15139 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15140
15141 writeProgramBin (cached_file, binary, binary_size);
15142
15143 local_free (binary);
15144 }
15145 else
15146 {
15147 #ifdef DEBUG
15148 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15149 #endif
15150
15151 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15152
15153 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15154
15155 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15156 }
15157
15158 local_free (kernel_lengths);
15159 local_free (kernel_sources[0]);
15160 local_free (kernel_sources);
15161 }
15162
15163 // some algorithm collide too fast, make that impossible
15164
15165 if (benchmark == 1)
15166 {
15167 ((uint *) digests_buf)[0] = -1;
15168 ((uint *) digests_buf)[1] = -1;
15169 ((uint *) digests_buf)[2] = -1;
15170 ((uint *) digests_buf)[3] = -1;
15171 }
15172
15173 /**
15174 * global buffers
15175 */
15176
15177 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15178 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15179 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15180 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15181 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15182 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15183 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15184 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15185 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15186 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15187 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15188 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15189 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15190 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15191 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15192 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15193 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15194 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15195
15196 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);
15197 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);
15198 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);
15199 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);
15200 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);
15201 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);
15202 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);
15203 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);
15204 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15205 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15206 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15207
15208 /**
15209 * special buffers
15210 */
15211
15212 if (attack_kern == ATTACK_KERN_STRAIGHT)
15213 {
15214 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15215 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15216
15217 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15218 }
15219 else if (attack_kern == ATTACK_KERN_COMBI)
15220 {
15221 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15222 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15223 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15224 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15225 }
15226 else if (attack_kern == ATTACK_KERN_BF)
15227 {
15228 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15229 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15230 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15231 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15232 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15233 }
15234
15235 if (size_esalts)
15236 {
15237 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15238
15239 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15240 }
15241
15242 /**
15243 * main host data
15244 */
15245
15246 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15247
15248 device_param->pws_buf = pws_buf;
15249
15250 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15251
15252 device_param->combs_buf = combs_buf;
15253
15254 void *hooks_buf = mymalloc (size_hooks);
15255
15256 device_param->hooks_buf = hooks_buf;
15257
15258 /**
15259 * kernel args
15260 */
15261
15262 device_param->kernel_params_buf32[21] = bitmap_mask;
15263 device_param->kernel_params_buf32[22] = bitmap_shift1;
15264 device_param->kernel_params_buf32[23] = bitmap_shift2;
15265 device_param->kernel_params_buf32[24] = 0; // salt_pos
15266 device_param->kernel_params_buf32[25] = 0; // loop_pos
15267 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15268 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15269 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15270 device_param->kernel_params_buf32[29] = 0; // digests_offset
15271 device_param->kernel_params_buf32[30] = 0; // combs_mode
15272 device_param->kernel_params_buf32[31] = 0; // gid_max
15273
15274 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15275 ? &device_param->d_pws_buf
15276 : &device_param->d_pws_amp_buf;
15277 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15278 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15279 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15280 device_param->kernel_params[ 4] = &device_param->d_tmps;
15281 device_param->kernel_params[ 5] = &device_param->d_hooks;
15282 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15283 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15284 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15285 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15286 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15287 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15288 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15289 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15290 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15291 device_param->kernel_params[15] = &device_param->d_digests_buf;
15292 device_param->kernel_params[16] = &device_param->d_digests_shown;
15293 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15294 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15295 device_param->kernel_params[19] = &device_param->d_result;
15296 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15297 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15298 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15299 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15300 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15301 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15302 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15303 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15304 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15305 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15306 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15307 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15308
15309 device_param->kernel_params_mp_buf64[3] = 0;
15310 device_param->kernel_params_mp_buf32[4] = 0;
15311 device_param->kernel_params_mp_buf32[5] = 0;
15312 device_param->kernel_params_mp_buf32[6] = 0;
15313 device_param->kernel_params_mp_buf32[7] = 0;
15314 device_param->kernel_params_mp_buf32[8] = 0;
15315
15316 device_param->kernel_params_mp[0] = NULL;
15317 device_param->kernel_params_mp[1] = NULL;
15318 device_param->kernel_params_mp[2] = NULL;
15319 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15320 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15321 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15322 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15323 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15324 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15325
15326 device_param->kernel_params_mp_l_buf64[3] = 0;
15327 device_param->kernel_params_mp_l_buf32[4] = 0;
15328 device_param->kernel_params_mp_l_buf32[5] = 0;
15329 device_param->kernel_params_mp_l_buf32[6] = 0;
15330 device_param->kernel_params_mp_l_buf32[7] = 0;
15331 device_param->kernel_params_mp_l_buf32[8] = 0;
15332 device_param->kernel_params_mp_l_buf32[9] = 0;
15333
15334 device_param->kernel_params_mp_l[0] = NULL;
15335 device_param->kernel_params_mp_l[1] = NULL;
15336 device_param->kernel_params_mp_l[2] = NULL;
15337 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15338 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15339 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15340 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15341 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15342 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15343 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15344
15345 device_param->kernel_params_mp_r_buf64[3] = 0;
15346 device_param->kernel_params_mp_r_buf32[4] = 0;
15347 device_param->kernel_params_mp_r_buf32[5] = 0;
15348 device_param->kernel_params_mp_r_buf32[6] = 0;
15349 device_param->kernel_params_mp_r_buf32[7] = 0;
15350 device_param->kernel_params_mp_r_buf32[8] = 0;
15351
15352 device_param->kernel_params_mp_r[0] = NULL;
15353 device_param->kernel_params_mp_r[1] = NULL;
15354 device_param->kernel_params_mp_r[2] = NULL;
15355 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15356 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15357 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15358 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15359 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15360 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15361
15362 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15363 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15364
15365 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15366 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15367 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15368 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15369 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15370 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15371 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15372
15373 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15374 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15375
15376 device_param->kernel_params_memset_buf32[1] = 0; // value
15377 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15378
15379 device_param->kernel_params_memset[0] = NULL;
15380 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15381 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15382
15383 /**
15384 * kernel name
15385 */
15386
15387 size_t kernel_wgs_tmp;
15388
15389 char kernel_name[64] = { 0 };
15390
15391 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15392 {
15393 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15394 {
15395 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15396
15397 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15398
15399 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15400
15401 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15402
15403 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15404
15405 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15406 }
15407 else
15408 {
15409 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15410
15411 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15412
15413 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15414
15415 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15416
15417 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15418
15419 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15420 }
15421
15422 if (data.attack_mode == ATTACK_MODE_BF)
15423 {
15424 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15425 {
15426 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15427
15428 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15429
15430 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);
15431 }
15432 }
15433 }
15434 else
15435 {
15436 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15437
15438 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15439
15440 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15441
15442 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15443
15444 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15445
15446 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15447
15448 if (opts_type & OPTS_TYPE_HOOK12)
15449 {
15450 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15451
15452 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15453
15454 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);
15455 }
15456
15457 if (opts_type & OPTS_TYPE_HOOK23)
15458 {
15459 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15460
15461 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15462
15463 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);
15464 }
15465 }
15466
15467 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);
15468 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);
15469 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);
15470
15471 for (uint i = 0; i <= 20; i++)
15472 {
15473 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15474 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15475 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15476
15477 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15478 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15479 }
15480
15481 for (uint i = 21; i <= 31; i++)
15482 {
15483 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15484 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15485 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15486
15487 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15488 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15489 }
15490
15491 // GPU memset
15492
15493 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15494
15495 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);
15496
15497 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15498 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15499 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15500
15501 // MP start
15502
15503 if (attack_mode == ATTACK_MODE_BF)
15504 {
15505 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15506 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15507
15508 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);
15509 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);
15510
15511 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15512 {
15513 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15514 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15515 }
15516 }
15517 else if (attack_mode == ATTACK_MODE_HYBRID1)
15518 {
15519 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15520
15521 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);
15522 }
15523 else if (attack_mode == ATTACK_MODE_HYBRID2)
15524 {
15525 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15526
15527 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);
15528 }
15529
15530 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15531 {
15532 // nothing to do
15533 }
15534 else
15535 {
15536 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15537
15538 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);
15539 }
15540
15541 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15542 {
15543 // nothing to do
15544 }
15545 else
15546 {
15547 for (uint i = 0; i < 5; i++)
15548 {
15549 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15550 }
15551
15552 for (uint i = 5; i < 7; i++)
15553 {
15554 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15555 }
15556 }
15557
15558 // maybe this has been updated by clGetKernelWorkGroupInfo()
15559 // value can only be decreased, so we don't need to reallocate buffers
15560
15561 device_param->kernel_threads = kernel_threads;
15562
15563 // zero some data buffers
15564
15565 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15566 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15567 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15568 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15569 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15570 run_kernel_bzero (device_param, device_param->d_result, size_results);
15571
15572 /**
15573 * special buffers
15574 */
15575
15576 if (attack_kern == ATTACK_KERN_STRAIGHT)
15577 {
15578 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15579 }
15580 else if (attack_kern == ATTACK_KERN_COMBI)
15581 {
15582 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15583 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15584 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15585 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15586 }
15587 else if (attack_kern == ATTACK_KERN_BF)
15588 {
15589 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15590 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15591 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15592 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15593 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15594 }
15595
15596 /**
15597 * Store thermal target temperature so we can send a notice to user
15598 */
15599
15600 #if defined(HAVE_HWMON)
15601 if (gpu_temp_disable == 0)
15602 {
15603 const int gpu_temp_threshold_slowdown = hm_get_threshold_slowdown_with_device_id (device_id);
15604
15605 data.hm_device[device_id].gpu_temp_threshold_slowdown = (gpu_temp_threshold_slowdown == -1) ? 100000 : gpu_temp_threshold_slowdown;
15606 }
15607 #endif
15608
15609 /**
15610 * Store initial fanspeed if gpu_temp_retain is enabled
15611 */
15612
15613 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15614 int gpu_temp_retain_set = 0;
15615
15616 if (gpu_temp_disable == 0)
15617 {
15618 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15619 {
15620 hc_thread_mutex_lock (mux_adl);
15621
15622 if (data.hm_device[device_id].fan_supported == 1)
15623 {
15624 if (gpu_temp_retain_chgd == 0)
15625 {
15626 uint cur_temp = 0;
15627 uint default_temp = 0;
15628
15629 int ADL_rc = hm_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
15630
15631 if (ADL_rc == ADL_OK)
15632 {
15633 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15634
15635 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15636
15637 // special case with multi gpu setups: always use minimum retain
15638
15639 if (gpu_temp_retain_set == 0)
15640 {
15641 gpu_temp_retain = gpu_temp_retain_target;
15642 gpu_temp_retain_set = 1;
15643 }
15644 else
15645 {
15646 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15647 }
15648
15649 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15650 }
15651 }
15652
15653 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15654
15655 temp_retain_fanspeed_value[device_id] = fan_speed;
15656
15657 if (fan_speed == -1)
15658 {
15659 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15660
15661 temp_retain_fanspeed_value[device_id] = 0;
15662 }
15663 }
15664
15665 hc_thread_mutex_unlock (mux_adl);
15666 }
15667 }
15668
15669 /**
15670 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15671 */
15672
15673 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15674 {
15675 hc_thread_mutex_lock (mux_adl);
15676
15677 if (data.hm_device[device_id].od_version == 6)
15678 {
15679 int ADL_rc;
15680
15681 // check powertune capabilities first, if not available then skip device
15682
15683 int powertune_supported = 0;
15684
15685 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15686 {
15687 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15688
15689 return (-1);
15690 }
15691
15692 if (powertune_supported != 0)
15693 {
15694 // powercontrol settings
15695
15696 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15697
15698 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15699 {
15700 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15701 }
15702
15703 if (ADL_rc != ADL_OK)
15704 {
15705 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15706
15707 return (-1);
15708 }
15709
15710 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15711 {
15712 log_error ("ERROR: Failed to set new ADL PowerControl values");
15713
15714 return (-1);
15715 }
15716
15717 // clocks
15718
15719 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15720
15721 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15722
15723 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)
15724 {
15725 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15726
15727 return (-1);
15728 }
15729
15730 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15731
15732 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15733
15734 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15735 {
15736 log_error ("ERROR: Failed to get ADL device capabilities");
15737
15738 return (-1);
15739 }
15740
15741 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15742 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15743
15744 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15745 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15746
15747 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15748 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15749
15750 // warning if profile has too low max values
15751
15752 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15753 {
15754 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15755 }
15756
15757 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15758 {
15759 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15760 }
15761
15762 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15763
15764 performance_state->iNumberOfPerformanceLevels = 2;
15765
15766 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15767 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15768 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15769 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15770
15771 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)
15772 {
15773 log_info ("ERROR: Failed to set ADL performance state");
15774
15775 return (-1);
15776 }
15777
15778 local_free (performance_state);
15779 }
15780 }
15781
15782 hc_thread_mutex_unlock (mux_adl);
15783 }
15784 #endif // HAVE_HWMON && HAVE_ADL
15785 }
15786
15787 data.kernel_power_all = kernel_power_all;
15788
15789 if (data.quiet == 0) log_info_nn ("");
15790
15791 /**
15792 * In benchmark-mode, inform user which algorithm is checked
15793 */
15794
15795 if (benchmark == 1)
15796 {
15797 if (machine_readable == 0)
15798 {
15799 quiet = 0;
15800
15801 data.quiet = quiet;
15802
15803 char *hash_type = strhashtype (data.hash_mode); // not a bug
15804
15805 log_info ("Hashtype: %s", hash_type);
15806 log_info ("");
15807 }
15808 }
15809
15810 /**
15811 * keep track of the progress
15812 */
15813
15814 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15815 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15816 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15817
15818 /**
15819 * open filehandles
15820 */
15821
15822 #if _WIN
15823 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15824 {
15825 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15826
15827 return (-1);
15828 }
15829
15830 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15831 {
15832 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15833
15834 return (-1);
15835 }
15836
15837 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15838 {
15839 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15840
15841 return (-1);
15842 }
15843 #endif
15844
15845 /**
15846 * dictionary pad
15847 */
15848
15849 segment_size *= (1024 * 1024);
15850
15851 data.segment_size = segment_size;
15852
15853 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15854
15855 wl_data->buf = (char *) mymalloc (segment_size);
15856 wl_data->avail = segment_size;
15857 wl_data->incr = segment_size;
15858 wl_data->cnt = 0;
15859 wl_data->pos = 0;
15860
15861 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15862
15863 data.wordlist_mode = wordlist_mode;
15864
15865 cs_t *css_buf = NULL;
15866 uint css_cnt = 0;
15867 uint dictcnt = 0;
15868 uint maskcnt = 1;
15869 char **masks = NULL;
15870 char **dictfiles = NULL;
15871
15872 uint mask_from_file = 0;
15873
15874 if (attack_mode == ATTACK_MODE_STRAIGHT)
15875 {
15876 if (wordlist_mode == WL_MODE_FILE)
15877 {
15878 int wls_left = myargc - (optind + 1);
15879
15880 for (int i = 0; i < wls_left; i++)
15881 {
15882 char *l0_filename = myargv[optind + 1 + i];
15883
15884 struct stat l0_stat;
15885
15886 if (stat (l0_filename, &l0_stat) == -1)
15887 {
15888 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15889
15890 return (-1);
15891 }
15892
15893 uint is_dir = S_ISDIR (l0_stat.st_mode);
15894
15895 if (is_dir == 0)
15896 {
15897 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15898
15899 dictcnt++;
15900
15901 dictfiles[dictcnt - 1] = l0_filename;
15902 }
15903 else
15904 {
15905 // do not allow --keyspace w/ a directory
15906
15907 if (keyspace == 1)
15908 {
15909 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15910
15911 return (-1);
15912 }
15913
15914 char **dictionary_files = NULL;
15915
15916 dictionary_files = scan_directory (l0_filename);
15917
15918 if (dictionary_files != NULL)
15919 {
15920 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15921
15922 for (int d = 0; dictionary_files[d] != NULL; d++)
15923 {
15924 char *l1_filename = dictionary_files[d];
15925
15926 struct stat l1_stat;
15927
15928 if (stat (l1_filename, &l1_stat) == -1)
15929 {
15930 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15931
15932 return (-1);
15933 }
15934
15935 if (S_ISREG (l1_stat.st_mode))
15936 {
15937 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15938
15939 dictcnt++;
15940
15941 dictfiles[dictcnt - 1] = strdup (l1_filename);
15942 }
15943 }
15944 }
15945
15946 local_free (dictionary_files);
15947 }
15948 }
15949
15950 if (dictcnt < 1)
15951 {
15952 log_error ("ERROR: No usable dictionary file found.");
15953
15954 return (-1);
15955 }
15956 }
15957 else if (wordlist_mode == WL_MODE_STDIN)
15958 {
15959 dictcnt = 1;
15960 }
15961 }
15962 else if (attack_mode == ATTACK_MODE_COMBI)
15963 {
15964 // display
15965
15966 char *dictfile1 = myargv[optind + 1 + 0];
15967 char *dictfile2 = myargv[optind + 1 + 1];
15968
15969 // find the bigger dictionary and use as base
15970
15971 FILE *fp1 = NULL;
15972 FILE *fp2 = NULL;
15973
15974 struct stat tmp_stat;
15975
15976 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15977 {
15978 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15979
15980 return (-1);
15981 }
15982
15983 if (stat (dictfile1, &tmp_stat) == -1)
15984 {
15985 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15986
15987 fclose (fp1);
15988
15989 return (-1);
15990 }
15991
15992 if (S_ISDIR (tmp_stat.st_mode))
15993 {
15994 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15995
15996 fclose (fp1);
15997
15998 return (-1);
15999 }
16000
16001 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16002 {
16003 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16004
16005 fclose (fp1);
16006
16007 return (-1);
16008 }
16009
16010 if (stat (dictfile2, &tmp_stat) == -1)
16011 {
16012 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16013
16014 fclose (fp1);
16015 fclose (fp2);
16016
16017 return (-1);
16018 }
16019
16020 if (S_ISDIR (tmp_stat.st_mode))
16021 {
16022 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16023
16024 fclose (fp1);
16025 fclose (fp2);
16026
16027 return (-1);
16028 }
16029
16030 data.combs_cnt = 1;
16031
16032 data.quiet = 1;
16033
16034 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16035
16036 data.quiet = quiet;
16037
16038 if (words1_cnt == 0)
16039 {
16040 log_error ("ERROR: %s: empty file", dictfile1);
16041
16042 fclose (fp1);
16043 fclose (fp2);
16044
16045 return (-1);
16046 }
16047
16048 data.combs_cnt = 1;
16049
16050 data.quiet = 1;
16051
16052 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16053
16054 data.quiet = quiet;
16055
16056 if (words2_cnt == 0)
16057 {
16058 log_error ("ERROR: %s: empty file", dictfile2);
16059
16060 fclose (fp1);
16061 fclose (fp2);
16062
16063 return (-1);
16064 }
16065
16066 fclose (fp1);
16067 fclose (fp2);
16068
16069 data.dictfile = dictfile1;
16070 data.dictfile2 = dictfile2;
16071
16072 if (words1_cnt >= words2_cnt)
16073 {
16074 data.combs_cnt = words2_cnt;
16075 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16076
16077 dictfiles = &data.dictfile;
16078
16079 dictcnt = 1;
16080 }
16081 else
16082 {
16083 data.combs_cnt = words1_cnt;
16084 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16085
16086 dictfiles = &data.dictfile2;
16087
16088 dictcnt = 1;
16089
16090 // we also have to switch wordlist related rules!
16091
16092 char *tmpc = data.rule_buf_l;
16093
16094 data.rule_buf_l = data.rule_buf_r;
16095 data.rule_buf_r = tmpc;
16096
16097 int tmpi = data.rule_len_l;
16098
16099 data.rule_len_l = data.rule_len_r;
16100 data.rule_len_r = tmpi;
16101 }
16102 }
16103 else if (attack_mode == ATTACK_MODE_BF)
16104 {
16105 char *mask = NULL;
16106
16107 maskcnt = 0;
16108
16109 if (benchmark == 0)
16110 {
16111 mask = myargv[optind + 1];
16112
16113 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16114
16115 if ((optind + 2) <= myargc)
16116 {
16117 struct stat file_stat;
16118
16119 if (stat (mask, &file_stat) == -1)
16120 {
16121 maskcnt = 1;
16122
16123 masks[maskcnt - 1] = mystrdup (mask);
16124 }
16125 else
16126 {
16127 int wls_left = myargc - (optind + 1);
16128
16129 uint masks_avail = INCR_MASKS;
16130
16131 for (int i = 0; i < wls_left; i++)
16132 {
16133 if (i != 0)
16134 {
16135 mask = myargv[optind + 1 + i];
16136
16137 if (stat (mask, &file_stat) == -1)
16138 {
16139 log_error ("ERROR: %s: %s", mask, strerror (errno));
16140
16141 return (-1);
16142 }
16143 }
16144
16145 uint is_file = S_ISREG (file_stat.st_mode);
16146
16147 if (is_file == 1)
16148 {
16149 FILE *mask_fp;
16150
16151 if ((mask_fp = fopen (mask, "r")) == NULL)
16152 {
16153 log_error ("ERROR: %s: %s", mask, strerror (errno));
16154
16155 return (-1);
16156 }
16157
16158 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16159
16160 while (!feof (mask_fp))
16161 {
16162 memset (line_buf, 0, HCBUFSIZ);
16163
16164 int line_len = fgetl (mask_fp, line_buf);
16165
16166 if (line_len == 0) continue;
16167
16168 if (line_buf[0] == '#') continue;
16169
16170 if (masks_avail == maskcnt)
16171 {
16172 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16173
16174 masks_avail += INCR_MASKS;
16175 }
16176
16177 masks[maskcnt] = mystrdup (line_buf);
16178
16179 maskcnt++;
16180 }
16181
16182 myfree (line_buf);
16183
16184 fclose (mask_fp);
16185 }
16186 else
16187 {
16188 log_error ("ERROR: %s: unsupported file-type", mask);
16189
16190 return (-1);
16191 }
16192 }
16193
16194 mask_from_file = 1;
16195 }
16196 }
16197 else
16198 {
16199 custom_charset_1 = (char *) "?l?d?u";
16200 custom_charset_2 = (char *) "?l?d";
16201 custom_charset_3 = (char *) "?l?d*!$@_";
16202
16203 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16204 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16205 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16206
16207 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16208
16209 wordlist_mode = WL_MODE_MASK;
16210
16211 data.wordlist_mode = wordlist_mode;
16212
16213 increment = 1;
16214
16215 maskcnt = 1;
16216 }
16217 }
16218 else
16219 {
16220 /**
16221 * generate full masks and charsets
16222 */
16223
16224 masks = (char **) mymalloc (sizeof (char *));
16225
16226 switch (hash_mode)
16227 {
16228 case 1731: pw_min = 5;
16229 pw_max = 5;
16230 mask = mystrdup ("?b?b?b?b?b");
16231 break;
16232 case 12500: pw_min = 5;
16233 pw_max = 5;
16234 mask = mystrdup ("?b?b?b?b?b");
16235 break;
16236 default: pw_min = 7;
16237 pw_max = 7;
16238 mask = mystrdup ("?b?b?b?b?b?b?b");
16239 break;
16240 }
16241
16242 maskcnt = 1;
16243
16244 masks[maskcnt - 1] = mystrdup (mask);
16245
16246 wordlist_mode = WL_MODE_MASK;
16247
16248 data.wordlist_mode = wordlist_mode;
16249
16250 increment = 1;
16251 }
16252
16253 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16254
16255 if (increment)
16256 {
16257 if (increment_min > pw_min) pw_min = increment_min;
16258
16259 if (increment_max < pw_max) pw_max = increment_max;
16260 }
16261 }
16262 else if (attack_mode == ATTACK_MODE_HYBRID1)
16263 {
16264 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16265
16266 // display
16267
16268 char *mask = myargv[myargc - 1];
16269
16270 maskcnt = 0;
16271
16272 masks = (char **) mymalloc (1 * sizeof (char *));
16273
16274 // mod
16275
16276 struct stat file_stat;
16277
16278 if (stat (mask, &file_stat) == -1)
16279 {
16280 maskcnt = 1;
16281
16282 masks[maskcnt - 1] = mystrdup (mask);
16283 }
16284 else
16285 {
16286 uint is_file = S_ISREG (file_stat.st_mode);
16287
16288 if (is_file == 1)
16289 {
16290 FILE *mask_fp;
16291
16292 if ((mask_fp = fopen (mask, "r")) == NULL)
16293 {
16294 log_error ("ERROR: %s: %s", mask, strerror (errno));
16295
16296 return (-1);
16297 }
16298
16299 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16300
16301 uint masks_avail = 1;
16302
16303 while (!feof (mask_fp))
16304 {
16305 memset (line_buf, 0, HCBUFSIZ);
16306
16307 int line_len = fgetl (mask_fp, line_buf);
16308
16309 if (line_len == 0) continue;
16310
16311 if (line_buf[0] == '#') continue;
16312
16313 if (masks_avail == maskcnt)
16314 {
16315 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16316
16317 masks_avail += INCR_MASKS;
16318 }
16319
16320 masks[maskcnt] = mystrdup (line_buf);
16321
16322 maskcnt++;
16323 }
16324
16325 myfree (line_buf);
16326
16327 fclose (mask_fp);
16328
16329 mask_from_file = 1;
16330 }
16331 else
16332 {
16333 maskcnt = 1;
16334
16335 masks[maskcnt - 1] = mystrdup (mask);
16336 }
16337 }
16338
16339 // base
16340
16341 int wls_left = myargc - (optind + 2);
16342
16343 for (int i = 0; i < wls_left; i++)
16344 {
16345 char *filename = myargv[optind + 1 + i];
16346
16347 struct stat file_stat;
16348
16349 if (stat (filename, &file_stat) == -1)
16350 {
16351 log_error ("ERROR: %s: %s", filename, strerror (errno));
16352
16353 return (-1);
16354 }
16355
16356 uint is_dir = S_ISDIR (file_stat.st_mode);
16357
16358 if (is_dir == 0)
16359 {
16360 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16361
16362 dictcnt++;
16363
16364 dictfiles[dictcnt - 1] = filename;
16365 }
16366 else
16367 {
16368 // do not allow --keyspace w/ a directory
16369
16370 if (keyspace == 1)
16371 {
16372 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16373
16374 return (-1);
16375 }
16376
16377 char **dictionary_files = NULL;
16378
16379 dictionary_files = scan_directory (filename);
16380
16381 if (dictionary_files != NULL)
16382 {
16383 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16384
16385 for (int d = 0; dictionary_files[d] != NULL; d++)
16386 {
16387 char *l1_filename = dictionary_files[d];
16388
16389 struct stat l1_stat;
16390
16391 if (stat (l1_filename, &l1_stat) == -1)
16392 {
16393 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16394
16395 return (-1);
16396 }
16397
16398 if (S_ISREG (l1_stat.st_mode))
16399 {
16400 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16401
16402 dictcnt++;
16403
16404 dictfiles[dictcnt - 1] = strdup (l1_filename);
16405 }
16406 }
16407 }
16408
16409 local_free (dictionary_files);
16410 }
16411 }
16412
16413 if (dictcnt < 1)
16414 {
16415 log_error ("ERROR: No usable dictionary file found.");
16416
16417 return (-1);
16418 }
16419
16420 if (increment)
16421 {
16422 maskcnt = 0;
16423
16424 uint mask_min = increment_min; // we can't reject smaller masks here
16425 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16426
16427 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16428 {
16429 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16430
16431 if (cur_mask == NULL) break;
16432
16433 masks[maskcnt] = cur_mask;
16434
16435 maskcnt++;
16436
16437 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16438 }
16439 }
16440 }
16441 else if (attack_mode == ATTACK_MODE_HYBRID2)
16442 {
16443 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16444
16445 // display
16446
16447 char *mask = myargv[optind + 1 + 0];
16448
16449 maskcnt = 0;
16450
16451 masks = (char **) mymalloc (1 * sizeof (char *));
16452
16453 // mod
16454
16455 struct stat file_stat;
16456
16457 if (stat (mask, &file_stat) == -1)
16458 {
16459 maskcnt = 1;
16460
16461 masks[maskcnt - 1] = mystrdup (mask);
16462 }
16463 else
16464 {
16465 uint is_file = S_ISREG (file_stat.st_mode);
16466
16467 if (is_file == 1)
16468 {
16469 FILE *mask_fp;
16470
16471 if ((mask_fp = fopen (mask, "r")) == NULL)
16472 {
16473 log_error ("ERROR: %s: %s", mask, strerror (errno));
16474
16475 return (-1);
16476 }
16477
16478 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16479
16480 uint masks_avail = 1;
16481
16482 while (!feof (mask_fp))
16483 {
16484 memset (line_buf, 0, HCBUFSIZ);
16485
16486 int line_len = fgetl (mask_fp, line_buf);
16487
16488 if (line_len == 0) continue;
16489
16490 if (line_buf[0] == '#') continue;
16491
16492 if (masks_avail == maskcnt)
16493 {
16494 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16495
16496 masks_avail += INCR_MASKS;
16497 }
16498
16499 masks[maskcnt] = mystrdup (line_buf);
16500
16501 maskcnt++;
16502 }
16503
16504 myfree (line_buf);
16505
16506 fclose (mask_fp);
16507
16508 mask_from_file = 1;
16509 }
16510 else
16511 {
16512 maskcnt = 1;
16513
16514 masks[maskcnt - 1] = mystrdup (mask);
16515 }
16516 }
16517
16518 // base
16519
16520 int wls_left = myargc - (optind + 2);
16521
16522 for (int i = 0; i < wls_left; i++)
16523 {
16524 char *filename = myargv[optind + 2 + i];
16525
16526 struct stat file_stat;
16527
16528 if (stat (filename, &file_stat) == -1)
16529 {
16530 log_error ("ERROR: %s: %s", filename, strerror (errno));
16531
16532 return (-1);
16533 }
16534
16535 uint is_dir = S_ISDIR (file_stat.st_mode);
16536
16537 if (is_dir == 0)
16538 {
16539 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16540
16541 dictcnt++;
16542
16543 dictfiles[dictcnt - 1] = filename;
16544 }
16545 else
16546 {
16547 // do not allow --keyspace w/ a directory
16548
16549 if (keyspace == 1)
16550 {
16551 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16552
16553 return (-1);
16554 }
16555
16556 char **dictionary_files = NULL;
16557
16558 dictionary_files = scan_directory (filename);
16559
16560 if (dictionary_files != NULL)
16561 {
16562 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16563
16564 for (int d = 0; dictionary_files[d] != NULL; d++)
16565 {
16566 char *l1_filename = dictionary_files[d];
16567
16568 struct stat l1_stat;
16569
16570 if (stat (l1_filename, &l1_stat) == -1)
16571 {
16572 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16573
16574 return (-1);
16575 }
16576
16577 if (S_ISREG (l1_stat.st_mode))
16578 {
16579 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16580
16581 dictcnt++;
16582
16583 dictfiles[dictcnt - 1] = strdup (l1_filename);
16584 }
16585 }
16586 }
16587
16588 local_free (dictionary_files);
16589 }
16590 }
16591
16592 if (dictcnt < 1)
16593 {
16594 log_error ("ERROR: No usable dictionary file found.");
16595
16596 return (-1);
16597 }
16598
16599 if (increment)
16600 {
16601 maskcnt = 0;
16602
16603 uint mask_min = increment_min; // we can't reject smaller masks here
16604 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16605
16606 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16607 {
16608 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16609
16610 if (cur_mask == NULL) break;
16611
16612 masks[maskcnt] = cur_mask;
16613
16614 maskcnt++;
16615
16616 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16617 }
16618 }
16619 }
16620
16621 data.pw_min = pw_min;
16622 data.pw_max = pw_max;
16623
16624 /**
16625 * weak hash check
16626 */
16627
16628 if (weak_hash_threshold >= salts_cnt)
16629 {
16630 hc_device_param_t *device_param = NULL;
16631
16632 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16633 {
16634 device_param = &data.devices_param[device_id];
16635
16636 if (device_param->skipped) continue;
16637
16638 break;
16639 }
16640
16641 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16642
16643 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16644 {
16645 weak_hash_check (device_param, salt_pos);
16646 }
16647
16648 // Display hack, guarantee that there is at least one \r before real start
16649
16650 //if (data.quiet == 0) log_info ("");
16651 }
16652
16653 /**
16654 * status and monitor threads
16655 */
16656
16657 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16658
16659 hc_thread_t i_thread = 0;
16660
16661 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16662 {
16663 hc_thread_create (i_thread, thread_keypress, &benchmark);
16664 }
16665
16666 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16667
16668 uint ni_threads_cnt = 0;
16669
16670 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16671
16672 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16673
16674 ni_threads_cnt++;
16675
16676 /**
16677 * Outfile remove
16678 */
16679
16680 if (keyspace == 0)
16681 {
16682 if (outfile_check_timer != 0)
16683 {
16684 if (data.outfile_check_directory != NULL)
16685 {
16686 if ((hash_mode != 5200) &&
16687 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16688 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16689 (hash_mode != 9000))
16690 {
16691 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16692
16693 ni_threads_cnt++;
16694 }
16695 else
16696 {
16697 outfile_check_timer = 0;
16698 }
16699 }
16700 else
16701 {
16702 outfile_check_timer = 0;
16703 }
16704 }
16705 }
16706
16707 /**
16708 * Inform the user if we got some hashes remove because of the pot file remove feature
16709 */
16710
16711 if (data.quiet == 0)
16712 {
16713 if (potfile_remove_cracks > 0)
16714 {
16715 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16716 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16717 }
16718 }
16719
16720 data.outfile_check_timer = outfile_check_timer;
16721
16722 /**
16723 * main loop
16724 */
16725
16726 char **induction_dictionaries = NULL;
16727
16728 int induction_dictionaries_cnt = 0;
16729
16730 hcstat_table_t *root_table_buf = NULL;
16731 hcstat_table_t *markov_table_buf = NULL;
16732
16733 uint initial_restore_done = 0;
16734
16735 data.maskcnt = maskcnt;
16736
16737 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16738 {
16739 if (data.devices_status == STATUS_CRACKED) break;
16740
16741 data.devices_status = STATUS_INIT;
16742
16743 if (maskpos > rd->maskpos)
16744 {
16745 rd->dictpos = 0;
16746 }
16747
16748 rd->maskpos = maskpos;
16749 data.maskpos = maskpos;
16750
16751 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16752 {
16753 char *mask = masks[maskpos];
16754
16755 if (mask_from_file == 1)
16756 {
16757 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16758
16759 char *str_ptr;
16760 uint str_pos;
16761
16762 uint mask_offset = 0;
16763
16764 uint separator_cnt;
16765
16766 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16767 {
16768 str_ptr = strstr (mask + mask_offset, ",");
16769
16770 if (str_ptr == NULL) break;
16771
16772 str_pos = str_ptr - mask;
16773
16774 // escaped separator, i.e. "\,"
16775
16776 if (str_pos > 0)
16777 {
16778 if (mask[str_pos - 1] == '\\')
16779 {
16780 separator_cnt --;
16781
16782 mask_offset = str_pos + 1;
16783
16784 continue;
16785 }
16786 }
16787
16788 // reset the offset
16789
16790 mask_offset = 0;
16791
16792 mask[str_pos] = '\0';
16793
16794 switch (separator_cnt)
16795 {
16796 case 0:
16797 mp_reset_usr (mp_usr, 0);
16798
16799 custom_charset_1 = mask;
16800 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16801 break;
16802
16803 case 1:
16804 mp_reset_usr (mp_usr, 1);
16805
16806 custom_charset_2 = mask;
16807 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16808 break;
16809
16810 case 2:
16811 mp_reset_usr (mp_usr, 2);
16812
16813 custom_charset_3 = mask;
16814 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16815 break;
16816
16817 case 3:
16818 mp_reset_usr (mp_usr, 3);
16819
16820 custom_charset_4 = mask;
16821 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16822 break;
16823 }
16824
16825 mask = mask + str_pos + 1;
16826 }
16827 }
16828
16829 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16830 {
16831 if (maskpos > 0)
16832 {
16833 local_free (css_buf);
16834 local_free (data.root_css_buf);
16835 local_free (data.markov_css_buf);
16836
16837 local_free (masks[maskpos - 1]);
16838 }
16839
16840 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16841
16842 data.mask = mask;
16843 data.css_cnt = css_cnt;
16844 data.css_buf = css_buf;
16845
16846 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16847
16848 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16849
16850 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16851 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16852
16853 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16854
16855 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16856
16857 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16858 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16859
16860 data.root_css_buf = root_css_buf;
16861 data.markov_css_buf = markov_css_buf;
16862
16863 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16864
16865 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16866
16867 local_free (root_table_buf);
16868 local_free (markov_table_buf);
16869
16870 // args
16871
16872 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16873 {
16874 hc_device_param_t *device_param = &data.devices_param[device_id];
16875
16876 if (device_param->skipped) continue;
16877
16878 device_param->kernel_params_mp[0] = &device_param->d_combs;
16879 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16880 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16881
16882 device_param->kernel_params_mp_buf64[3] = 0;
16883 device_param->kernel_params_mp_buf32[4] = css_cnt;
16884 device_param->kernel_params_mp_buf32[5] = 0;
16885 device_param->kernel_params_mp_buf32[6] = 0;
16886 device_param->kernel_params_mp_buf32[7] = 0;
16887
16888 if (attack_mode == ATTACK_MODE_HYBRID1)
16889 {
16890 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16891 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16892 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16893 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16894 }
16895 else if (attack_mode == ATTACK_MODE_HYBRID2)
16896 {
16897 device_param->kernel_params_mp_buf32[5] = 0;
16898 device_param->kernel_params_mp_buf32[6] = 0;
16899 device_param->kernel_params_mp_buf32[7] = 0;
16900 }
16901
16902 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]);
16903 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]);
16904 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]);
16905
16906 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);
16907 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);
16908 }
16909 }
16910 else if (attack_mode == ATTACK_MODE_BF)
16911 {
16912 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16913
16914 if (increment)
16915 {
16916 for (uint i = 0; i < dictcnt; i++)
16917 {
16918 local_free (dictfiles[i]);
16919 }
16920
16921 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16922 {
16923 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16924
16925 if (l1_filename == NULL) break;
16926
16927 dictcnt++;
16928
16929 dictfiles[dictcnt - 1] = l1_filename;
16930 }
16931 }
16932 else
16933 {
16934 dictcnt++;
16935
16936 dictfiles[dictcnt - 1] = mask;
16937 }
16938
16939 if (dictcnt == 0)
16940 {
16941 log_error ("ERROR: Mask is too small");
16942
16943 return (-1);
16944 }
16945 }
16946 }
16947
16948 free (induction_dictionaries);
16949
16950 // induction_dictionaries_cnt = 0; // implied
16951
16952 if (attack_mode != ATTACK_MODE_BF)
16953 {
16954 if (keyspace == 0)
16955 {
16956 induction_dictionaries = scan_directory (induction_directory);
16957
16958 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16959 }
16960 }
16961
16962 if (induction_dictionaries_cnt)
16963 {
16964 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16965 }
16966
16967 /**
16968 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16969 */
16970 if (keyspace == 1)
16971 {
16972 if ((maskcnt > 1) || (dictcnt > 1))
16973 {
16974 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16975
16976 return (-1);
16977 }
16978 }
16979
16980 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16981 {
16982 char *subid = logfile_generate_subid ();
16983
16984 data.subid = subid;
16985
16986 logfile_sub_msg ("START");
16987
16988 data.devices_status = STATUS_INIT;
16989
16990 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16991 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16992 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16993
16994 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16995
16996 data.cpt_pos = 0;
16997
16998 data.cpt_start = time (NULL);
16999
17000 data.cpt_total = 0;
17001
17002 if (data.restore == 0)
17003 {
17004 rd->words_cur = skip;
17005
17006 skip = 0;
17007
17008 data.skip = 0;
17009 }
17010
17011 data.ms_paused = 0;
17012
17013 data.words_cur = rd->words_cur;
17014
17015 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17016 {
17017 hc_device_param_t *device_param = &data.devices_param[device_id];
17018
17019 if (device_param->skipped) continue;
17020
17021 device_param->speed_pos = 0;
17022
17023 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17024 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17025
17026 device_param->exec_pos = 0;
17027
17028 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17029
17030 device_param->kernel_power = device_param->kernel_power_user;
17031
17032 device_param->outerloop_pos = 0;
17033 device_param->outerloop_left = 0;
17034 device_param->innerloop_pos = 0;
17035 device_param->innerloop_left = 0;
17036
17037 // some more resets:
17038
17039 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17040
17041 device_param->pws_cnt = 0;
17042
17043 device_param->words_off = 0;
17044 device_param->words_done = 0;
17045 }
17046
17047 data.kernel_power_div = 0;
17048
17049 // figure out some workload
17050
17051 if (attack_mode == ATTACK_MODE_STRAIGHT)
17052 {
17053 if (data.wordlist_mode == WL_MODE_FILE)
17054 {
17055 char *dictfile = NULL;
17056
17057 if (induction_dictionaries_cnt)
17058 {
17059 dictfile = induction_dictionaries[0];
17060 }
17061 else
17062 {
17063 dictfile = dictfiles[dictpos];
17064 }
17065
17066 data.dictfile = dictfile;
17067
17068 logfile_sub_string (dictfile);
17069
17070 for (uint i = 0; i < rp_files_cnt; i++)
17071 {
17072 logfile_sub_var_string ("rulefile", rp_files[i]);
17073 }
17074
17075 FILE *fd2 = fopen (dictfile, "rb");
17076
17077 if (fd2 == NULL)
17078 {
17079 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17080
17081 return (-1);
17082 }
17083
17084 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17085
17086 fclose (fd2);
17087
17088 if (data.words_cnt == 0)
17089 {
17090 if (data.devices_status == STATUS_CRACKED) break;
17091 if (data.devices_status == STATUS_ABORTED) break;
17092
17093 dictpos++;
17094
17095 continue;
17096 }
17097 }
17098 }
17099 else if (attack_mode == ATTACK_MODE_COMBI)
17100 {
17101 char *dictfile = data.dictfile;
17102 char *dictfile2 = data.dictfile2;
17103
17104 logfile_sub_string (dictfile);
17105 logfile_sub_string (dictfile2);
17106
17107 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17108 {
17109 FILE *fd2 = fopen (dictfile, "rb");
17110
17111 if (fd2 == NULL)
17112 {
17113 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17114
17115 return (-1);
17116 }
17117
17118 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17119
17120 fclose (fd2);
17121 }
17122 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17123 {
17124 FILE *fd2 = fopen (dictfile2, "rb");
17125
17126 if (fd2 == NULL)
17127 {
17128 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17129
17130 return (-1);
17131 }
17132
17133 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17134
17135 fclose (fd2);
17136 }
17137
17138 if (data.words_cnt == 0)
17139 {
17140 if (data.devices_status == STATUS_CRACKED) break;
17141 if (data.devices_status == STATUS_ABORTED) break;
17142
17143 dictpos++;
17144
17145 continue;
17146 }
17147 }
17148 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17149 {
17150 char *dictfile = NULL;
17151
17152 if (induction_dictionaries_cnt)
17153 {
17154 dictfile = induction_dictionaries[0];
17155 }
17156 else
17157 {
17158 dictfile = dictfiles[dictpos];
17159 }
17160
17161 data.dictfile = dictfile;
17162
17163 char *mask = data.mask;
17164
17165 logfile_sub_string (dictfile);
17166 logfile_sub_string (mask);
17167
17168 FILE *fd2 = fopen (dictfile, "rb");
17169
17170 if (fd2 == NULL)
17171 {
17172 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17173
17174 return (-1);
17175 }
17176
17177 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17178
17179 fclose (fd2);
17180
17181 if (data.words_cnt == 0)
17182 {
17183 if (data.devices_status == STATUS_CRACKED) break;
17184 if (data.devices_status == STATUS_ABORTED) break;
17185
17186 dictpos++;
17187
17188 continue;
17189 }
17190 }
17191 else if (attack_mode == ATTACK_MODE_BF)
17192 {
17193 local_free (css_buf);
17194 local_free (data.root_css_buf);
17195 local_free (data.markov_css_buf);
17196
17197 char *mask = dictfiles[dictpos];
17198
17199 logfile_sub_string (mask);
17200
17201 // base
17202
17203 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17204
17205 if (opts_type & OPTS_TYPE_PT_UNICODE)
17206 {
17207 uint css_cnt_unicode = css_cnt * 2;
17208
17209 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17210
17211 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17212 {
17213 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17214
17215 css_buf_unicode[j + 1].cs_buf[0] = 0;
17216 css_buf_unicode[j + 1].cs_len = 1;
17217 }
17218
17219 free (css_buf);
17220
17221 css_buf = css_buf_unicode;
17222 css_cnt = css_cnt_unicode;
17223 }
17224
17225 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17226
17227 uint mask_min = pw_min;
17228 uint mask_max = pw_max;
17229
17230 if (opts_type & OPTS_TYPE_PT_UNICODE)
17231 {
17232 mask_min *= 2;
17233 mask_max *= 2;
17234 }
17235
17236 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17237 {
17238 if (css_cnt < mask_min)
17239 {
17240 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17241 }
17242
17243 if (css_cnt > mask_max)
17244 {
17245 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17246 }
17247
17248 // skip to next mask
17249
17250 dictpos++;
17251
17252 rd->dictpos = dictpos;
17253
17254 logfile_sub_msg ("STOP");
17255
17256 continue;
17257 }
17258
17259 uint save_css_cnt = css_cnt;
17260
17261 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17262 {
17263 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17264 {
17265 uint salt_len = (uint) data.salts_buf[0].salt_len;
17266 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17267
17268 uint css_cnt_salt = css_cnt + salt_len;
17269
17270 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17271
17272 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17273
17274 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17275 {
17276 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17277 css_buf_salt[j].cs_len = 1;
17278 }
17279
17280 free (css_buf);
17281
17282 css_buf = css_buf_salt;
17283 css_cnt = css_cnt_salt;
17284 }
17285 }
17286
17287 data.mask = mask;
17288 data.css_cnt = css_cnt;
17289 data.css_buf = css_buf;
17290
17291 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17292
17293 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17294
17295 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17296
17297 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17298 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17299
17300 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17301
17302 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17303
17304 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17305 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17306
17307 data.root_css_buf = root_css_buf;
17308 data.markov_css_buf = markov_css_buf;
17309
17310 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17311
17312 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17313
17314 local_free (root_table_buf);
17315 local_free (markov_table_buf);
17316
17317 // copy + args
17318
17319 uint css_cnt_l = css_cnt;
17320 uint css_cnt_r;
17321
17322 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17323 {
17324 if (save_css_cnt < 6)
17325 {
17326 css_cnt_r = 1;
17327 }
17328 else if (save_css_cnt == 6)
17329 {
17330 css_cnt_r = 2;
17331 }
17332 else
17333 {
17334 if (opts_type & OPTS_TYPE_PT_UNICODE)
17335 {
17336 if (save_css_cnt == 8 || save_css_cnt == 10)
17337 {
17338 css_cnt_r = 2;
17339 }
17340 else
17341 {
17342 css_cnt_r = 4;
17343 }
17344 }
17345 else
17346 {
17347 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17348 {
17349 css_cnt_r = 3;
17350 }
17351 else
17352 {
17353 css_cnt_r = 4;
17354 }
17355 }
17356 }
17357 }
17358 else
17359 {
17360 css_cnt_r = 1;
17361
17362 /* unfinished code?
17363 int sum = css_buf[css_cnt_r - 1].cs_len;
17364
17365 for (uint i = 1; i < 4 && i < css_cnt; i++)
17366 {
17367 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17368
17369 css_cnt_r++;
17370
17371 sum *= css_buf[css_cnt_r - 1].cs_len;
17372 }
17373 */
17374 }
17375
17376 css_cnt_l -= css_cnt_r;
17377
17378 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17379
17380 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17381 {
17382 hc_device_param_t *device_param = &data.devices_param[device_id];
17383
17384 if (device_param->skipped) continue;
17385
17386 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17387 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17388 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17389
17390 device_param->kernel_params_mp_l_buf64[3] = 0;
17391 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17392 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17393 device_param->kernel_params_mp_l_buf32[6] = 0;
17394 device_param->kernel_params_mp_l_buf32[7] = 0;
17395 device_param->kernel_params_mp_l_buf32[8] = 0;
17396
17397 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17398 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17399 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17400 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17401
17402 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17403 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17404 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17405
17406 device_param->kernel_params_mp_r_buf64[3] = 0;
17407 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17408 device_param->kernel_params_mp_r_buf32[5] = 0;
17409 device_param->kernel_params_mp_r_buf32[6] = 0;
17410 device_param->kernel_params_mp_r_buf32[7] = 0;
17411
17412 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]);
17413 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]);
17414 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]);
17415
17416 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]);
17417 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]);
17418 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]);
17419
17420 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);
17421 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);
17422 }
17423 }
17424
17425 u64 words_base = data.words_cnt;
17426
17427 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17428 {
17429 if (data.kernel_rules_cnt)
17430 {
17431 words_base /= data.kernel_rules_cnt;
17432 }
17433 }
17434 else if (data.attack_kern == ATTACK_KERN_COMBI)
17435 {
17436 if (data.combs_cnt)
17437 {
17438 words_base /= data.combs_cnt;
17439 }
17440 }
17441 else if (data.attack_kern == ATTACK_KERN_BF)
17442 {
17443 if (data.bfs_cnt)
17444 {
17445 words_base /= data.bfs_cnt;
17446 }
17447 }
17448
17449 data.words_base = words_base;
17450
17451 if (keyspace == 1)
17452 {
17453 log_info ("%llu", (unsigned long long int) words_base);
17454
17455 return (0);
17456 }
17457
17458 if (data.words_cur > data.words_base)
17459 {
17460 log_error ("ERROR: restore value greater keyspace");
17461
17462 return (-1);
17463 }
17464
17465 if (data.words_cur)
17466 {
17467 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17468 {
17469 for (uint i = 0; i < data.salts_cnt; i++)
17470 {
17471 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17472 }
17473 }
17474 else if (data.attack_kern == ATTACK_KERN_COMBI)
17475 {
17476 for (uint i = 0; i < data.salts_cnt; i++)
17477 {
17478 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17479 }
17480 }
17481 else if (data.attack_kern == ATTACK_KERN_BF)
17482 {
17483 for (uint i = 0; i < data.salts_cnt; i++)
17484 {
17485 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17486 }
17487 }
17488 }
17489
17490 /*
17491 * Inform user about possible slow speeds
17492 */
17493
17494 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17495 {
17496 if (data.words_base < kernel_power_all)
17497 {
17498 if (quiet == 0)
17499 {
17500 log_info ("ATTENTION!");
17501 log_info (" The wordlist or mask you are using is too small.");
17502 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17503 log_info (" The cracking speed will drop.");
17504 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17505 log_info ("");
17506 }
17507 }
17508 }
17509
17510 /*
17511 * Update loopback file
17512 */
17513
17514 if (loopback == 1)
17515 {
17516 time_t now;
17517
17518 time (&now);
17519
17520 uint random_num = get_random_num (0, 9999);
17521
17522 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17523
17524 data.loopback_file = loopback_file;
17525 }
17526
17527 /*
17528 * Update dictionary statistic
17529 */
17530
17531 if (keyspace == 0)
17532 {
17533 dictstat_fp = fopen (dictstat, "wb");
17534
17535 if (dictstat_fp)
17536 {
17537 lock_file (dictstat_fp);
17538
17539 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17540
17541 fclose (dictstat_fp);
17542 }
17543 }
17544
17545 data.devices_status = STATUS_RUNNING;
17546
17547 if (initial_restore_done == 0)
17548 {
17549 if (data.restore_disable == 0) cycle_restore ();
17550
17551 initial_restore_done = 1;
17552 }
17553
17554 hc_timer_set (&data.timer_running);
17555
17556 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17557 {
17558 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17559 {
17560 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17561 if (quiet == 0) fflush (stdout);
17562 }
17563 }
17564 else if (wordlist_mode == WL_MODE_STDIN)
17565 {
17566 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17567 if (data.quiet == 0) log_info ("");
17568 }
17569
17570 time_t runtime_start;
17571
17572 time (&runtime_start);
17573
17574 data.runtime_start = runtime_start;
17575
17576 /**
17577 * create cracker threads
17578 */
17579
17580 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17581
17582 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17583 {
17584 hc_device_param_t *device_param = &devices_param[device_id];
17585
17586 if (wordlist_mode == WL_MODE_STDIN)
17587 {
17588 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17589 }
17590 else
17591 {
17592 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17593 }
17594 }
17595
17596 // wait for crack threads to exit
17597
17598 hc_thread_wait (data.devices_cnt, c_threads);
17599
17600 local_free (c_threads);
17601
17602 data.restore = 0;
17603
17604 // finalize task
17605
17606 logfile_sub_var_uint ("status-after-work", data.devices_status);
17607
17608 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17609
17610 if (data.devices_status == STATUS_CRACKED) break;
17611 if (data.devices_status == STATUS_ABORTED) break;
17612
17613 if (data.devices_status == STATUS_BYPASS)
17614 {
17615 data.devices_status = STATUS_RUNNING;
17616 }
17617
17618 if (induction_dictionaries_cnt)
17619 {
17620 unlink (induction_dictionaries[0]);
17621 }
17622
17623 free (induction_dictionaries);
17624
17625 if (attack_mode != ATTACK_MODE_BF)
17626 {
17627 induction_dictionaries = scan_directory (induction_directory);
17628
17629 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17630 }
17631
17632 if (benchmark == 0)
17633 {
17634 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17635 {
17636 if (quiet == 0) clear_prompt ();
17637
17638 if (quiet == 0) log_info ("");
17639
17640 if (status == 1)
17641 {
17642 status_display ();
17643 }
17644 else
17645 {
17646 if (quiet == 0) status_display ();
17647 }
17648
17649 if (quiet == 0) log_info ("");
17650 }
17651 }
17652
17653 if (attack_mode == ATTACK_MODE_BF)
17654 {
17655 dictpos++;
17656
17657 rd->dictpos = dictpos;
17658 }
17659 else
17660 {
17661 if (induction_dictionaries_cnt)
17662 {
17663 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17664 }
17665 else
17666 {
17667 dictpos++;
17668
17669 rd->dictpos = dictpos;
17670 }
17671 }
17672
17673 time_t runtime_stop;
17674
17675 time (&runtime_stop);
17676
17677 data.runtime_stop = runtime_stop;
17678
17679 logfile_sub_uint (runtime_start);
17680 logfile_sub_uint (runtime_stop);
17681
17682 logfile_sub_msg ("STOP");
17683
17684 global_free (subid);
17685 }
17686
17687 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17688
17689 if (data.devices_status == STATUS_CRACKED) break;
17690 if (data.devices_status == STATUS_ABORTED) break;
17691 if (data.devices_status == STATUS_QUIT) break;
17692
17693 if (data.devices_status == STATUS_BYPASS)
17694 {
17695 data.devices_status = STATUS_RUNNING;
17696 }
17697 }
17698
17699 // 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
17700
17701 if (attack_mode == ATTACK_MODE_STRAIGHT)
17702 {
17703 if (data.wordlist_mode == WL_MODE_FILE)
17704 {
17705 if (data.dictfile == NULL)
17706 {
17707 if (dictfiles != NULL)
17708 {
17709 data.dictfile = dictfiles[0];
17710
17711 hc_timer_set (&data.timer_running);
17712 }
17713 }
17714 }
17715 }
17716 // NOTE: combi is okay because it is already set beforehand
17717 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17718 {
17719 if (data.dictfile == NULL)
17720 {
17721 if (dictfiles != NULL)
17722 {
17723 hc_timer_set (&data.timer_running);
17724
17725 data.dictfile = dictfiles[0];
17726 }
17727 }
17728 }
17729 else if (attack_mode == ATTACK_MODE_BF)
17730 {
17731 if (data.mask == NULL)
17732 {
17733 hc_timer_set (&data.timer_running);
17734
17735 data.mask = masks[0];
17736 }
17737 }
17738
17739 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17740 {
17741 data.devices_status = STATUS_EXHAUSTED;
17742 }
17743
17744 // if cracked / aborted remove last induction dictionary
17745
17746 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17747 {
17748 struct stat induct_stat;
17749
17750 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17751 {
17752 unlink (induction_dictionaries[file_pos]);
17753 }
17754 }
17755
17756 // wait for non-interactive threads
17757
17758 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17759 {
17760 hc_thread_wait (1, &ni_threads[thread_idx]);
17761 }
17762
17763 local_free (ni_threads);
17764
17765 // wait for interactive threads
17766
17767 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17768 {
17769 hc_thread_wait (1, &i_thread);
17770 }
17771
17772 // we dont need restore file anymore
17773 if (data.restore_disable == 0)
17774 {
17775 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17776 {
17777 unlink (eff_restore_file);
17778 unlink (new_restore_file);
17779 }
17780 else
17781 {
17782 cycle_restore ();
17783 }
17784 }
17785
17786 // finally save left hashes
17787
17788 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17789 {
17790 save_hash ();
17791 }
17792
17793 /**
17794 * Clean up
17795 */
17796
17797 if (benchmark == 1)
17798 {
17799 status_benchmark ();
17800
17801 if (machine_readable == 0)
17802 {
17803 log_info ("");
17804 }
17805 }
17806 else
17807 {
17808 if (quiet == 0) clear_prompt ();
17809
17810 if (quiet == 0) log_info ("");
17811
17812 if (status == 1)
17813 {
17814 status_display ();
17815 }
17816 else
17817 {
17818 if (quiet == 0) status_display ();
17819 }
17820
17821 if (quiet == 0) log_info ("");
17822 }
17823
17824 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17825 {
17826 hc_device_param_t *device_param = &data.devices_param[device_id];
17827
17828 if (device_param->skipped) continue;
17829
17830 local_free (device_param->combs_buf);
17831
17832 local_free (device_param->hooks_buf);
17833
17834 local_free (device_param->device_name);
17835
17836 local_free (device_param->device_name_chksum);
17837
17838 local_free (device_param->device_version);
17839
17840 local_free (device_param->driver_version);
17841
17842 if (device_param->pws_buf) myfree (device_param->pws_buf);
17843 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17844 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17845 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17846 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17847 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17848 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17849 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17850 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17851 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17852 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17853 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17854 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17855 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17856 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17857 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17858 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17859 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17860 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17861 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17862 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17863 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17864 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17865 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17866 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17867 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17868 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17869 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17870 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17871
17872 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17873 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17874 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17875 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17876 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17877 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17878 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17879 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17880 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17881 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17882 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17883
17884 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17885 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17886 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17887
17888 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17889 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17890 }
17891
17892 // reset default fan speed
17893
17894 #ifdef HAVE_HWMON
17895 if (gpu_temp_disable == 0)
17896 {
17897 #ifdef HAVE_ADL
17898 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17899 {
17900 hc_thread_mutex_lock (mux_adl);
17901
17902 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17903 {
17904 hc_device_param_t *device_param = &data.devices_param[device_id];
17905
17906 if (device_param->skipped) continue;
17907
17908 if (data.hm_device[device_id].fan_supported == 1)
17909 {
17910 int fanspeed = temp_retain_fanspeed_value[device_id];
17911
17912 if (fanspeed == -1) continue;
17913
17914 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17915
17916 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17917 }
17918 }
17919
17920 hc_thread_mutex_unlock (mux_adl);
17921 }
17922 #endif // HAVE_ADL
17923 }
17924
17925 #ifdef HAVE_ADL
17926 // reset power tuning
17927
17928 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17929 {
17930 hc_thread_mutex_lock (mux_adl);
17931
17932 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17933 {
17934 hc_device_param_t *device_param = &data.devices_param[device_id];
17935
17936 if (device_param->skipped) continue;
17937
17938 if (data.hm_device[device_id].od_version == 6)
17939 {
17940 // check powertune capabilities first, if not available then skip device
17941
17942 int powertune_supported = 0;
17943
17944 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17945 {
17946 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17947
17948 return (-1);
17949 }
17950
17951 if (powertune_supported != 0)
17952 {
17953 // powercontrol settings
17954
17955 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)
17956 {
17957 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17958
17959 return (-1);
17960 }
17961
17962 // clocks
17963
17964 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17965
17966 performance_state->iNumberOfPerformanceLevels = 2;
17967
17968 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17969 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17970 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17971 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17972
17973 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)
17974 {
17975 log_info ("ERROR: Failed to restore ADL performance state");
17976
17977 return (-1);
17978 }
17979
17980 local_free (performance_state);
17981 }
17982 }
17983 }
17984
17985 hc_thread_mutex_unlock (mux_adl);
17986 }
17987 #endif // HAVE_ADL
17988
17989 if (gpu_temp_disable == 0)
17990 {
17991 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17992 if (data.hm_nv)
17993 {
17994 #if defined(LINUX) && defined(HAVE_NVML)
17995
17996 hm_NVML_nvmlShutdown (data.hm_nv);
17997
17998 nvml_close (data.hm_nv);
17999
18000 #elif defined(WIN) && (HAVE_NVAPI)
18001
18002 hm_NvAPI_Unload (data.hm_nv);
18003
18004 nvapi_close (data.hm_nv);
18005
18006 #endif
18007
18008 data.hm_nv = NULL;
18009 }
18010 #endif
18011
18012 #ifdef HAVE_ADL
18013 if (data.hm_amd)
18014 {
18015 hm_ADL_Main_Control_Destroy (data.hm_amd);
18016
18017 adl_close (data.hm_amd);
18018 data.hm_amd = NULL;
18019 }
18020 #endif
18021 }
18022 #endif // HAVE_HWMON
18023
18024 // free memory
18025
18026 local_free (masks);
18027
18028 local_free (dictstat_base);
18029
18030 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18031 {
18032 pot_t *pot_ptr = &pot[pot_pos];
18033
18034 hash_t *hash = &pot_ptr->hash;
18035
18036 local_free (hash->digest);
18037
18038 if (isSalted)
18039 {
18040 local_free (hash->salt);
18041 }
18042 }
18043
18044 local_free (pot);
18045
18046 local_free (all_kernel_rules_cnt);
18047 local_free (all_kernel_rules_buf);
18048
18049 local_free (wl_data->buf);
18050 local_free (wl_data);
18051
18052 local_free (bitmap_s1_a);
18053 local_free (bitmap_s1_b);
18054 local_free (bitmap_s1_c);
18055 local_free (bitmap_s1_d);
18056 local_free (bitmap_s2_a);
18057 local_free (bitmap_s2_b);
18058 local_free (bitmap_s2_c);
18059 local_free (bitmap_s2_d);
18060
18061 #ifdef HAVE_HWMON
18062 local_free (temp_retain_fanspeed_value);
18063 #ifdef HAVE_ADL
18064 local_free (od_clock_mem_status);
18065 local_free (od_power_control_status);
18066 #endif // ADL
18067 #endif
18068
18069 global_free (devices_param);
18070
18071 global_free (kernel_rules_buf);
18072
18073 global_free (root_css_buf);
18074 global_free (markov_css_buf);
18075
18076 global_free (digests_buf);
18077 global_free (digests_shown);
18078 global_free (digests_shown_tmp);
18079
18080 global_free (salts_buf);
18081 global_free (salts_shown);
18082
18083 global_free (esalts_buf);
18084
18085 global_free (words_progress_done);
18086 global_free (words_progress_rejected);
18087 global_free (words_progress_restored);
18088
18089 if (pot_fp) fclose (pot_fp);
18090
18091 if (data.devices_status == STATUS_QUIT) break;
18092 }
18093
18094 // destroy others mutex
18095
18096 hc_thread_mutex_delete (mux_dispatcher);
18097 hc_thread_mutex_delete (mux_counter);
18098 hc_thread_mutex_delete (mux_display);
18099 hc_thread_mutex_delete (mux_adl);
18100
18101 // free memory
18102
18103 local_free (eff_restore_file);
18104 local_free (new_restore_file);
18105
18106 local_free (rd);
18107
18108 // tuning db
18109
18110 tuning_db_destroy (tuning_db);
18111
18112 // loopback
18113
18114 local_free (loopback_file);
18115
18116 if (loopback == 1) unlink (loopback_file);
18117
18118 // induction directory
18119
18120 if (induction_dir == NULL)
18121 {
18122 if (attack_mode != ATTACK_MODE_BF)
18123 {
18124 if (rmdir (induction_directory) == -1)
18125 {
18126 if (errno == ENOENT)
18127 {
18128 // good, we can ignore
18129 }
18130 else if (errno == ENOTEMPTY)
18131 {
18132 // good, we can ignore
18133 }
18134 else
18135 {
18136 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18137
18138 return (-1);
18139 }
18140 }
18141
18142 local_free (induction_directory);
18143 }
18144 }
18145
18146 // outfile-check directory
18147
18148 if (outfile_check_dir == NULL)
18149 {
18150 if (rmdir (outfile_check_directory) == -1)
18151 {
18152 if (errno == ENOENT)
18153 {
18154 // good, we can ignore
18155 }
18156 else if (errno == ENOTEMPTY)
18157 {
18158 // good, we can ignore
18159 }
18160 else
18161 {
18162 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18163
18164 return (-1);
18165 }
18166 }
18167
18168 local_free (outfile_check_directory);
18169 }
18170
18171 time_t proc_stop;
18172
18173 time (&proc_stop);
18174
18175 logfile_top_uint (proc_start);
18176 logfile_top_uint (proc_stop);
18177
18178 logfile_top_msg ("STOP");
18179
18180 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18181 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18182
18183 if (data.ocl) ocl_close (data.ocl);
18184
18185 if (data.devices_status == STATUS_ABORTED) return 2;
18186 if (data.devices_status == STATUS_QUIT) return 2;
18187 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18188 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18189 if (data.devices_status == STATUS_CRACKED) return 0;
18190
18191 return -1;
18192 }
Hashcat additions to support pwdhash